python區塊鏈基本原型簡版實現示例

Posted on by

說明

本文根據https://github.com/liuchengxu/blockchain-tutorial的內容，用python實現的，但根據個人的理解進行瞭一些修改，大量引用瞭原文的內容。文章末尾有"本節完整源碼實現地址"。

引言

區塊鏈是 21 世紀最具革命性的技術之一，它仍然處於不斷成長的階段，而且還有很多潛力尚未顯現。 本質上，區塊鏈隻是一個分佈式數據庫而已。 不過，使它獨一無二的是，區塊鏈是一個公開的數據庫，而不是一個私人數據庫，也就是說，每個使用它的人都有一個完整或部分的副本。 隻有經過其他“數據庫管理員”的同意，才能向數據庫中添加新的記錄。 此外，也正是由於區塊鏈，才使得加密貨幣和智能合約成為現實。

在本系列文章中，我們將實現一個簡化版的區塊鏈，並基於它來構建一個簡化版的加密貨幣。

區塊

首先從 “區塊” 談起。在區塊鏈中，真正存儲有效信息的是區塊（block）。而在比特幣中，真正有價值的信息就是交易（transaction）。實際上，交易信息是所有加密貨幣的價值所在。除此以外，區塊還包含瞭一些技術實現的相關信息，比如版本，當前時間戳和前一個區塊的哈希。

不過，我們要實現的是一個簡化版的區塊鏈，而不是一個像比特幣技術規范所描述那樣成熟完備的區塊鏈。所以在我們目前的實現中，區塊僅包含瞭部分關鍵信息，它的數據結構如下：

class Block(object):
    """A Block
    Attributes:
        _magic_no (int): Magic number
        _block_header (Block): Header of the previous Block.
        _transactions (Transaction): transactions of the current Block.
    """
    MAGIC_NO = 0xBCBCBCBC
    def __init__(self, block_header, transactions):
        self._magic_no = self.MAGIC_NO
        self._block_header = block_header
        self._transactions = transactions
字段 解釋
_magic_no 魔數
_block_header 區塊頭
_transactions 交易

這裡的_magic_no, _block_header, _transactions, 也是比特幣區塊的構成部分，這裡我們簡化瞭一部分信息。在真正的比特幣中，區塊 的數據結構如下：

Field Description Size
Magic no value always 0xD9B4BEF9 4 bytes
Blocksize number of bytes following up to end of block 4 bytes
Blockheader consists of 6 items 80 bytes
Transaction counter positive integer VI = VarInt 1 – 9 bytes
transactions the (non empty) list of transactions -many transactions

區塊頭

class BlockHeader(object):
    """ A BlockHeader
    Attributes:
        timestamp (str): Creation timestamp of Block
        prev_block_hash (str): Hash of the previous Block.
        hash (str): Hash of the current Block.
        hash_merkle_root(str): Hash of the merkle_root.
        height (int): Height of Block
        nonce (int): A 32 bit arbitrary random number that is typically used once.
    """
    def __init__(self, hash_merkle_root, height, pre_block_hash=''):
        self.timestamp = str(time.time())
        self.prev_block_hash = pre_block_hash
        self.hash = None
        self.hash_merkle_root = hash_merkle_root
        self.height = height
        self.nonce = None
字段 解釋
timestamp 當前時間戳，也就是區塊創建的時間
prev_block_hash 前一個塊的哈希，即父哈希
hash 當前塊頭的哈希
hash_merkle_root 區塊存儲的交易的merkle樹的根哈希

我們這裡的 timestamp，prev_block_hash, Hash，hash_merkle_root, 在比特幣技術規范中屬於區塊頭（block header），區塊頭是一個單獨的數據結構。
完整的 比特幣的區塊頭（block header）結構 如下：

Field Purpose Updated when… Size (Bytes)
Version Block version number You upgrade the software and it specifies a new version 4
hashPrevBlock 256-bit hash of the previous block header A new block comes in 32
hashMerkleRoot 256-bit hash based on all of the transactions in the block A transaction is accepted 32
Time Current timestamp as seconds since 1970-01-01T00:00 UTC Every few seconds 4
Bits Current target in compact format The difficulty is adjusted 4
Nonce 32-bit number (starts at 0) A hash is tried (increments) 4

我們的簡化版的區塊頭裡，hash和hash_merkle_root是需要計算的。hash_merkle_root暫且不管留空，它是由區塊中的交易信息生成的merkle樹的根哈希。
而hash的計算如下:

    def set_hash(self):
        """
        Set hash of the header
        """
        data_list = [str(self.timestamp),
                     str(self.prev_block_hash),
                     str(self.hash_merkle_root),
                     str(self.height),
                     str(self.nonce)]
        data = ''.join(data_list)
        self.hash = sum256_hex(data)

區塊鏈

有瞭區塊，下面讓我們來實現區塊鏈。本質上，區塊鏈就是一個有著特定結構的數據庫，是一個有序，每一個塊都連接到前一個塊的鏈表。也就是說，區塊按照插入的順序進行存儲，每個塊都與前一個塊相連。這樣的結構，能夠讓我們快速地獲取鏈上的最新塊，並且高效地通過哈希來檢索一個塊。

class BlockChain(object):
    def __init__(self):
        self.blocks = []

這就是我們的第一個區塊鏈！就是一個list。
我們還需要一個添加區塊的函數:

    def add_block(self, transactions):
        """
        add a block to block_chain
        """
        last_block = self.blocks[-1]
        prev_hash = last_block.get_header_hash()
        height = len(self.blocks)
        block_header = BlockHeader('', height, prev_hash)
        block = Block(block_header, transactions)
        block.set_header_hash()
        self.blocks.append(block)

為瞭加入一個新的塊，我們必須要有一個已有的塊，但是，初始狀態下，我們的鏈是空的，一個塊都沒有！所以，在任何一個區塊鏈中，都必須至少有一個塊。這個塊，也就是鏈中的第一個塊，通常叫做創世塊（genesis block）. 讓我們實現一個方法來創建創世塊：

    # class BlockChain
    def new_genesis_block(self):
        if not self.blocks:
            genesis_block = Block.new_genesis_block('genesis_block')
            genesis_block.set_header_hash()
            self.blocks.append(genesis_block)
    # class Block
    @classmethod
    def new_genesis_block(cls, coin_base_tx):
        block_header = BlockHeader.new_genesis_block_header()
        return cls(block_header, coin_base_tx)
    # class BlockHeader
    @classmethod
    def new_genesis_block_header(cls):
        """
        NewGenesisBlock creates and returns genesis Block
        """
        return cls('', 0, '')

上面分別對應三個函數分別對應鏈中創世塊生成，創世塊生成，和創世塊頭的生成。

創世塊高度為0。這裡我們暫時還沒有交易類，交易暫時用字符串代替。prev_block_hash和hash_merkle_root都暫時留空。

讓BlockChain支持迭代

    # class BlockChain
    def __getitem__(self, index):
        if index < len(self.blocks):
            return self.blocks[index]
        else:
            raise IndexError('Index is out of range')

最後再進行簡單的測試:

def main():
    bc = BlockChain()
    bc.new_genesis_block()
    bc.add_block('Send 1 BTC to B')
    bc.add_block('Send 2 BTC to B')
    for block in bc:
        print(block)
if __name__ == "__main__":
    main()

輸出:

Block(_block_header=BlockHeader(timestamp='1548150457.22', hash_merkle_root='', prev_block_hash='', hash='f91f638a9a2b4caf241112d3bc92c9168cc9d52207a5580b3a549ed5343e2ed3', nonce=None, height=0))
Block(_block_header=BlockHeader(timestamp='1548150457.22', hash_merkle_root='', prev_block_hash='f91f638a9a2b4caf241112d3bc92c9168cc9d52207a5580b3a549ed5343e2ed3', hash='d21570e36f0c6f75c112d98416ca4ffae14e5cf02492bea5a7f8c398c1d458ca', nonce=None, height=1))
Block(_block_header=BlockHeader(timestamp='1548150457.22', hash_merkle_root='', prev_block_hash='d21570e36f0c6f75c112d98416ca4ffae14e5cf02492bea5a7f8c398c1d458ca', hash='9c78f38ec78a0d492a27e69ab04a3e0ba07d70d31a1ef96d581e8198d9781bc0', nonce=None, height=2))

總結

我們創建瞭一個非常簡單的區塊鏈原型：它僅僅是一個數組構成的一系列區塊，每個塊都與前一個塊相關聯。真實的區塊鏈要比這復雜得多。在我們的區塊鏈中，加入新的塊非常簡單，也很快，但是在真實的區塊鏈中，加入新的塊需要很多工作：你必須要經過十分繁重的計算（這個機制叫做工作量證明），來獲得添加一個新塊的權力。並且，區塊鏈是一個分佈式數據庫，並且沒有單一決策者。因此，要加入一個新塊，必須要被網絡的其他參與者確認和同意（這個機制叫做共識（consensus））。還有一點，我們的區塊鏈還沒有任何的交易！

參考：
[1] basic-prototype

[2] 完整實現源碼

以上就是python區塊鏈基本原型簡版實現示例的詳細內容，更多關於python區塊鏈基本原型的資料請關註WalkonNet其它相關文章！

推薦閱讀：