用Python实现简单的区块链（二）

继续上一篇文章的内容，我们已经有一个可以证实的区块链了，但是现在链中只保存着一些无用的信息，这篇文章中我们将会实现简单的钱包（wallet）和交易（transaction），用交易来替换这些数据，创建一个非常简单的加密货币：”NoobCoin”。

创建Wallet

在加密货币中，币的所有权在区块链上通过交易转移，参与者有一个地址来发送和接收币。基本形式的钱包只能保存地址，但大多数钱包是能够在区块链上创建新交易的软件。

上图显示了钱包、交易和区块链的关系，钱包可以创建交易，交易被存储在区块中，一个区块中可以有多个交易。具体的内容下面会详细介绍。
首先创建一个钱包类来保存私钥和公钥，UTXOs的作用后面再介绍：
代码清单 wallet.py

import random
from ecdsa.util import PRNG
from ecdsa import SigningKey

class Wallet:
    def __init__(self):
        rng = PRNG(str(random.random()))
        self.privateKey = SigningKey.generate(entropy=rng)
        self.publicKey = self.privateKey.get_verifying_key()
        self.UTXOs = {}

在noobcoin中，公钥实际上是作为地址使用的，被共享给其他人来接收付款。私钥是用来签名交易的，这样除了私钥的所有者，没有人能花我们的币。公钥也和交易一起发送，用来验证签名是合法的，数据没有被篡改。

这里用的椭圆曲线加密来产生公私钥对，用到了一个第三方库python-ecdsa。

交易和签名

每个交易都会包含以下数据：

• 资金发送者的公钥（地址）
• 资金接收者的公钥（地址）
• 转移资金的数目
• 输入（inputs），引用先前的交易，证明发送者有资金可以发送
• 输出（outputs），显示了接收资金的所有地址，这些输出在新交易中会被当做输入
• 加密签名，证明地址的所有者是发送这个交易的人，并且数据没有被篡改

下面创建交易类：
代码清单 transaction.py

class Transaction:
    def __init__(self, pubkey_from, pubkey_to, value, inputs):
        self.transactionId = ""
        self.sender = pubkey_from
        self.reciepient = pubkey_to
        self.value = value
        self.inputs = inputs
        self.outputs = []
        self.sequence = 0
    
    def calculateHash(self):
        self.sequence += 1
        return StringUtils.sha256(self.sender.to_string() + self.reciepient.to_string() + str(self.value) + str(self.sequence))

在创建产生签名的方法之前，我们需要先在StringUtils类中加一些辅助函数：
代码清单 strutils.py

@staticmethod
def applyECDSASig(prikey, inputs):
    return prikey.sign(inputs)

@staticmethod
def verifyECDSASig(pubkey, data, signature):
    return pubkey.verify(signature, data)

现在我们把签名方法用到Transaction类中，添加一个generateSignature()和verifySignature()方法：
代码清单 transaction.py

def generateSignature(self, prikey):
    data = self.sender.to_string() + self.reciepient.to_string() + str(self.value)
    self.signature = StringUtils.applyECDSASig(prikey, data)

def verifySignature(self):
    data = self.sender.to_string() + self.reciepient.to_string() + str(self.value)
    return StringUtils.verifyECDSASig(self.sender, data, self.signature)

实际中会签名更多的信息，例如outputs/inputs和timestamp等，但现在我们只签名最少的。一个新的交易添加到一个区块时，矿工将会验证签名。

测试钱包和签名

测试一下上面的代码：
代码清单 noobchain.py

from wallet import Wallet
from transaction import Transaction
walletA = Wallet()
walletB = Wallet()

print "Private and public keys: "
print walletA.privateKey.to_pem()
print walletA.publicKey.to_pem()

transaction = Transaction(walletA.publicKey, walletB.publicKey, 5, None);
transaction.generateSignature(walletA.privateKey);
print "Is signature verified"
print transaction.verifySignature()

运行结果：

$ python noobchain.py
Private and public keys:
-----BEGIN EC PRIVATE KEY-----
MF8CAQEEGIAnlP0QuZpVjYN8cF1g0VK+QIDhpySdUqAKBggqhkjOPQMBAaE0AzIA
BF5wfHb88KlyjGkVeSSnqge/4Q4vxDIlHkwu5BvrszPLaEHs00DVwFEFdmjp5wkv
vw==
-----END EC PRIVATE KEY-----

-----BEGIN PUBLIC KEY-----
MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEXnB8dvzwqXKMaRV5JKeqB7/hDi/E
MiUeTC7kG+uzM8toQezTQNXAUQV2aOnnCS+/
-----END PUBLIC KEY-----

Is signature verified
True

上面的代码创建了两个钱包，打印了walletA的公私钥。创建了一个交易，用walletA的私钥给它签名。
接下来介绍outputs和inputs，并把交易保存到区块链。

outputs & inputs

加密货币是如何被拥有的

你要拥有一个比特币需要先接收一个比特币，分布式账本并不会真的添加一个比特币给你，减少发送者的一个比特币，发送者会引用以前的交易证明他有一个比特币并作为input，然后创建一个交易output来证明发送了一个比特币到你的地址。（交易的input就是引用先前的交易output作为证明）
你钱包的余额就是所有未使用的地址是你的交易output的总和。
这里我们遵循比特币的惯例，称未使用的交易输出为：UTXO.
下面来创建TransactionInput和TransactionOutput类：
代码清单 transaction.py

class TransactionInput:
    def __init__(self, transactionOutputId):
        self.transactionOutputId = transactionOutputId
        self.UTXO = None # 包含未使用的交易output

class TransactionOutput:
    def __init__(self, pubkey_to, value, parentTransactionId):
        self.reciepient = pubkey_to
        self.value = value
        self.parentTransactionId = parentTransactionId
        self.id = StringUtils.sha256(pubkey_to.to_string()+str(value)+parentTransactionId)

    def isMine(self, publicKey):
        return publicKey == self.reciepient

大致的工作流程：初始钱包手动创建一个交易，给A钱包100个币，这个交易没有input，只有output。output显示接收者为A钱包，金额是100，output会被添加到全局UTXOs，这个交易会被添加到第0个区块，不会被验证。钱包A要给钱包B发送40个币，交易的input就是引用上一笔交易的output，证明自己有足够的币可以发送，交易会有两个output，一个是接收者为B钱包，金额是40，另一个是接收者为A钱包，金额是60（找零）。这两个output会被添加到全局UTXOs，并将交易的input引用的output从全局UTXOs中删除，这笔交易会被添加到区块上。

处理交易

链上的区块可能会接收到很多交易，区块链可能会很长，处理一个新的交易会花费大量的时间，因为我们必须要验证它的inputs。为了解决这个问题，就需要保存一个额外的集合：所有可用来做input的未花费output，因此我们新建一个config.py文件：

blockchain = []
# 未使用的output
UTXOs = {}
minimumTransaction = 0.1
difficulty = 3

在Transaction类中添加一个processTransaction()方法：
代码清单 transaction.py

def processTransaction(self):
    if self.verifySignature() == False:
        print "#Transaction Signature failed to verify"
        return False
    # 收集交易input（确保他们是未花费的）
    for i in self.inputs:
        i.UTXO = config.UTXOs[i.transactionOutputId]
    # 输入的和不能小于最小交易额
    if self.getInputsValue() < config.minimumTransaction:
        print "#Transaction Inputs too small: " + self.getInputsValue()
        return False
    # 产生交易输出
    leftOver = self.getInputsValue() - self.value
    self.transactionId = self.calculateHash()
    # 发送value给reciptient
    self.outputs.append(TransactionOutput(self.reciepient, self.value, self.transactionId))
    # 发送找零给sender
    self.outputs.append(TransactionOutput(self.sender, leftOver, self.transactionId))
    for o in self.outputs:
        config.UTXOs[o.id] = o
    # 从UTXO删除交易inputs当做花费
    for i in self.inputs:
        if i.UTXO == None:
            continue
        del config.UTXOs[i.UTXO.id]
    return True

# 返回输入值的和
def getInputsValue(self):
    total = 0
    for i in self.inputs:
        if i.UTXO == None:
            continue
        total += i.UTXO.value
    return total

# 返回输出值的和
def getOutputsValue(self):
    total = 0
    for o in self.outputs:
        total += o.value
    return total

我们用这个方法来做一些检查，确保交易是合法的。最后，我们从UTXOs中删除了input引用到的output，意味着一个交易的output只能被用做一次input。
最后再来更新钱包：

• 收集我们的余额（通过遍历UTXOs列表来检查交易的output是否是自己的）
• 为我们创建交易

代码清单 wallet.py

import config
from transaction import Transaction, TransactionInput

class Wallet:
    def __init__(self):
        ...
    # 计算自己的余额
    def getBalance(self):
        total = 0
        for item in config.UTXOs.items():
            UTXO = item[1]
            if UTXO.isMine(self.publicKey): # 将全局UTXOs中是自己的output添加到自己钱包的UTXOs
                self.UTXOs[UTXO.id] = UTXO
                total += UTXO.value
        return total
    # 发送金额给其他人
    def sendFunds(self, _recipient, value):
        if self.getBalance() < value:
            print "#Not Enough funds to send transaction. Transaction Discarded."
            return None
        inputs = []
        total = 0
        # 需要引用到的output
        for item in self.UTXOs.items():
            UTXO = item[1]
            total += UTXO.value
            inputs.append(TransactionInput(UTXO.id))
            if total > value:
                break
        # 创建交易
        newTransaction = Transaction(self.publicKey, _recipient, value, inputs)
        newTransaction.generateSignature(self.privateKey)
        # 删除引用过的output
        for i in inputs:
            del self.UTXOs[i.transactionOutputId]
        return newTransaction

添加交易到区块上

现在交易系统已经可以运行，我们需要把它实现到区块链上。把区块链上无用的数据替换为一个交易的列表。一个区块上可能会有上千个交易，对于计算hash来说需要包含的太多。因此，我们使用交易的merkle root。在StringUtils类中添加一个产生merkleroot的辅助方法：
代码清单 strutils.py

@staticmethod
def getMerkleRoot(transactions):
    count = len(transactions)
    previousTreeLayer = []
    for transaction in transactions:
        previousTreeLayer.append(transaction.transactionId)
    treeLayer = previousTreeLayer
    while count > 1:
        treeLayer = []
        for i in range(1, len(previous)):
            treeLayer.append(sha256(previousTreeLayer[i-1]+previousTreeLayer[i]))
        count = len(treeLayer)
        previousTreeLayer = treeLayer
    merkleRoot = treeLayer[0] if len(treeLayer) == 1 else ""
    return merkleRoot

接下来修改Block类：
代码清单 block.py

class Block:
    def __init__(self, previousHash):
        self.previousHash = previousHash
        self.timeStamp = time.time()
        self.transactions = []
        self.nonce = 0
        self.merkleRoot = ""
        self.hash = self.calculateHash()

    def calculateHash(self):
        return StringUtils.sha256(self.previousHash+str(self.timeStamp)+str(self.nonce)+self.merkleRoot)

    def mineBlock(self, difficulty):
        self.merkleRoot = StringUtils.getMerkleRoot(self.transactions)
        target = '0'*difficulty
        while self.hash[0:difficulty] != target:
            self.nonce += 1
            self.hash = self.calculateHash()
        print "Block Mined!!! : " + self.hash
    # 将交易添加到这个区块上
    def addTransaction(self, transaction):
        if transaction == None:
            return False
        if self.previousHash != "0":
            if transaction.processTransaction() != True:
                print "Transaction failed to process. Discarded."
                return False
        self.transactions.append(transaction)
        print "Transaction Successfully added to Block"
        return True

运行noobcoin

我们需要测试用钱包发送和接收币，更新我们区块链的合法性检查。有许多方法来创建新币，在比特币区块链，矿工可以用一笔交易作为挖到区块的奖励。现在，我们直接释放我们想用到的所有币，在第0个区块（genesis block）。就像比特币，我们将硬编码Genesis区块。
我们来更新noobchain.py文件：

• 一个Genesis区块，释放100个noobcoin给walletA
• 一个更新的链合法性检查，将交易考虑在内
• 一些测试交易，来看看是否运行正常

代码清单 noobchain.py

import config
from block import Block
from wallet import Wallet
from transaction import Transaction, TransactionOutput, TransactionInput

walletA = Wallet()
walletB = Wallet()
coinbase = Wallet()

# 将coinbase里的100个coin给A
genesisTransaction = Transaction(coinbase.publicKey, walletA.publicKey, 100, None)
genesisTransaction.generateSignature(coinbase.privateKey)
genesisTransaction.transactionId = "0"
genesisTransaction.outputs.append(TransactionOutput(genesisTransaction.reciepient, genesisTransaction.value, genesisTransaction.transactionId))
config.UTXOs[genesisTransaction.outputs[0].id] = genesisTransaction.outputs[0]

print "Creating and Mining Genesis block... "
genesis = Block("0")
genesis.addTransaction(genesisTransaction)
genesis.mineBlock(config.difficulty)
config.blockchain.append(genesis)

# testing
block1 = Block(genesis.hash)
print "walletA's balance is: %f" % walletA.getBalance()
print "walletA is attempting to send funds (40) to walletB..."
block1.addTransaction(walletA.sendFunds(walletB.publicKey, 40))
block1.mineBlock(config.difficulty)
config.blockchain.append(block1)
print "walletA's balance is: %f"  % walletA.getBalance()
print "walletB's balance is: %f"  % walletB.getBalance()

block2 = Block(block1.hash)
print "walletA is attempting to send more funds (1000) than it has..."
block2.addTransaction(walletA.sendFunds(walletB.publicKey, 1000))
block2.mineBlock(config.difficulty)
config.blockchain.append(block2)
print "walletA's balance is: %f" % walletA.getBalance()
print "walletB's balance is: %f" % walletB.getBalance()

block3 = Block(block2.hash)
print "walletB is attempting to send funds (20) to walletA..."
block3.addTransaction(walletB.sendFunds(walletA.publicKey, 20))
print "walletA's balance is: %f" % walletA.getBalance()
print "walletB's balance is: %f" % walletB.getBalance()

运行结果：

$ python noobchain.py
Creating and Mining Genesis block...
Transaction Successfully added to Block
Block Mined!!! : 000ecc366d3c553e131693c972dc77b7f2bb7c8156aa7125bb10c9e4052d8874
walletA's balance is: 100.000000
walletA is attempting to send funds (40) to walletB...
Transaction Successfully added to Block
Block Mined!!! : 0005af73ad51e2a0fa80444bdd284342c102dc202c9139889f62a3f989d8343d
walletA's balance is: 60.000000
walletB's balance is: 40.000000
walletA is attempting to send more funds (1000) than it has...
#Not Enough funds to send transaction. Transaction Discarded.
Block Mined!!! : 00035606ee8cd61c0afb21c496193fdfc67a17172befd6cae90d7a9410a27d5f
walletA's balance is: 60.000000
walletB's balance is: 40.000000
walletB is attempting to send funds (20) to walletA...
Transaction Successfully added to Block
walletA's balance is: 80.000000
walletB's balance is: 20.000000

我们的钱包现在可以在区块链上发送资金了，我们有了一个本地的加密货币。最后，再加上检查区块链合法性的方法即可：
代码清单 noobchain.py

def isChainValid():
    hashTarget = '0' * config.difficulty
    tempUTXOs = {}
    tempUTXOs[genesisTransaction.outputs[0].id] = genesisTransaction.outputs[0]
    for i in range(1, len(config.blockchain)):
        curblock = config.blockchain[i]
        preblock = config.blockchain[i-1]
        if curblock.hash != curblock.calculateHash():
            print 'Current Hashes not equal'
            return False
        if preblock.hash != curblock.previousHash:
            print 'Previous Hashes not equal'
            return False
        if curblock.hash[:config.difficulty] != hashTarget:
            print '#This block hasnt been mined'
            return False
        for t in range(len(curblock.transactions)):
            curTransaction = curblock.transactions[t]
            if not curTransaction.verifySignature():
                print '#Signature on Transaction %d is Invalid' % t
                return False
            if curTransaction.getInputsValue() != curTransaction.getOutputsValue():
                print '#Inputs are not equal to outputs on Transaction %d' % t
                return False
            for i in curTransaction.inputs:
                tempOutput = tempUTXOs[i.transactionOutputId]
                if tempOutput == None:
                    print '#Referenced input on Transaction %d is Missing' % t
                    return False
                if i.UTXO.value != tempOutput.value:
                    print '#Referenced input Transaction %d value is Invalid' % t
                    return False
                del tempUTXOs[i.transactionOutputId]
            for o in curTransaction.outputs:
                tempUTXOs[o.id] = o
            if curTransaction.outputs[0].reciepient != curTransaction.reciepient:
                print '#Transaction %d output reciepient is not who it should be' % t
                return False
            if curTransaction.outputs[1].reciepient != curTransaction.sender:
                print '#Transaction %d output change is not sender' % t
                return False
    print 'Blockchain is valid'
    return True

项目完整代码
reference
https://medium.com/programmers-blockchain/creating-your-first-blockchain-with-java-part-2-transactions-2cdac335e0ce
https://github.com/warner/python-ecdsa
https://www.cnblogs.com/fengzhiwu/p/5524324.html