摘要：引言交易是比特幣的核心所在，而區(qū)塊鏈的唯一目的，也正是為了能夠安全可靠地存儲交易。比特幣使用了一個更加復雜的技術(shù)它將一個塊里面包含的所有交易表示為一個，然后在工作量證明系統(tǒng)中使用樹的根哈希。

翻譯的系列文章我已經(jīng)放到了 GitHub 上：blockchain-tutorial，后續(xù)如有更新都會在 GitHub 上，可能就不在這里同步了。如果想直接運行代碼，也可以 clone GitHub 上的教程倉庫，進入 src 目錄執(zhí)行 make 即可。

交易（transaction）是比特幣的核心所在，而區(qū)塊鏈的唯一目的，也正是為了能夠安全可靠地存儲交易。在區(qū)塊鏈中，交易一旦被創(chuàng)建，就沒有任何人能夠再去修改或是刪除它。在今天的文章中，我們將會開始實現(xiàn)交易這個部分。不過，由于交易是很大的話題，我會把它分為兩部分來講：在今天這個部分，我們會實現(xiàn)交易的通用機制。在第二部分，我們會繼續(xù)討論它的一些細節(jié)。

此外，由于代碼實現(xiàn)變化很大，就不在文章中羅列所有代碼了，這里 可以看到所有的改動。

如果以前開發(fā)過 web 應用，在支付的實現(xiàn)環(huán)節(jié)，你可能會在數(shù)據(jù)庫中創(chuàng)建這樣兩張表：

accounts

transactions

account（賬戶）會存儲用戶信息，里面包括了個人信息和余額。transaction（交易）會存儲資金轉(zhuǎn)移信息，也就是資金從一個賬戶轉(zhuǎn)移到另一個賬戶這樣的內(nèi)容。在比特幣中，支付是另外一種完全不同的方式：

沒有賬戶（account）

沒有余額（balance）

沒有住址（address）

沒有貨幣（coin）

沒有發(fā)送人和接收人（sender，receiver）（這里所說的發(fā)送人和接收人是基于目前現(xiàn)實生活場景，交易雙方與人是一一對應的。而在比特幣中，“交易雙方”是地址，地址背后才是人，人與地址并不是一一對應的關(guān)系，一個人可能有很多個地址。）

鑒于區(qū)塊鏈是一個公開開放的數(shù)據(jù)庫，所以我們并不想要存儲錢包所有者的敏感信息（所以具有一定的匿名性）。資金不是通過賬戶來收集，交易也不是從一個地址將錢轉(zhuǎn)移到另一個地址，也沒有一個字段或者屬性來保存賬戶余額。交易就是區(qū)塊鏈要表達的所有內(nèi)容。那么，交易里面到底有什么內(nèi)容呢？

一筆交易由一些輸入（input）和輸出（output）組合而來：

type Transaction struct {
    ID   []byte
    Vin  []TXInput
    Vout []TXOutput
}

對于每一筆新的交易，它的輸入會引用（reference）之前一筆交易的輸出（這里有個例外，也就是我們待會兒要談到的 coinbase 交易）。所謂引用之前的一個輸出，也就是將之前的一個輸出包含在另一筆交易的輸入當中。交易的輸出，也就是幣實際存儲的地方。下面的圖示闡釋了交易之間的互相關(guān)聯(lián)：

注意：

有一些輸出并沒有被關(guān)聯(lián)到某個輸入上

一筆交易的輸入可以引用之前多筆交易的輸出

一個輸入必須引用一個輸出

貫穿本文，我們將會使用像“錢（money）”，“幣（coin）”，“花費（spend）”，“發(fā)送（send）”，“賬戶（account）” 等等這樣的詞。但是在比特幣中，實際并不存在這樣的概念。交易僅僅是通過一個腳本（script）來鎖定（lock）一些價值（value），而這些價值只可以被鎖定它們的人解鎖（unlock）。

讓我們先從輸出（output）開始：

type TXOutput struct {
    Value        int
    ScriptPubKey string
}

實際上，正是輸出里面存儲了“幣”（注意，也就是上面的 Value 字段）。而這里的存儲，指的是用一個數(shù)學難題對輸出進行鎖定，這個難題被存儲在 ScriptPubKey 里面。在內(nèi)部，比特幣使用了一個叫做 Script 的腳本語言，用它來定義鎖定和解鎖輸出的邏輯。雖然這個語言相當?shù)脑迹ㄟ@是為了避免潛在的黑客攻擊和濫用而有意為之），并不復雜，但是我們并不會在這里討論它的細節(jié)。你可以在這里 找到詳細解釋。

在比特幣中，value 字段存儲的是 satoshi 的數(shù)量，而不是>有 BTC 的數(shù)量。一個 satoshi 等于一百萬分之一的 >BTC(0.00000001 BTC)，這也是比特幣里面最小的貨幣單位>（就像是 1 分的硬幣）。

由于還沒有實現(xiàn)地址（address），所以目前我們會避免涉及邏輯相關(guān)的完整腳本。ScriptPubKey 將會存儲一個任意的字符串（用戶定義的錢包地址）。

順便說一下，有了一個這樣的腳本語言，也意味著比特幣其實也可以作為一個智能合約平臺。

關(guān)于輸出，非常重要的一點是：它們是不可再分的（invisible），這也就是說，你無法僅引用它的其中某一部分。要么不用，如果要用，必須一次性用完。當一個新的交易中引用了某個輸出，那么這個輸出必須被全部花費。如果它的值比需要的值大，那么就會產(chǎn)生一個找零，找零會返還給發(fā)送方。這跟現(xiàn)實世界的場景十分類似，當你想要支付的時候，如果一個東西值 1 美元，而你給了一個 5 美元的紙幣，那么你會得到一個 4 美元的找零。

這里是輸入：

type TXInput struct {
    Txid      []byte
    Vout      int
    ScriptSig string
}

正如之前所提到的，一個輸入引用了之前一筆交易的一個輸出：Txid 存儲的是這筆交易的 ID，Vout 存儲的是該輸出在這筆交易中所有輸出的索引（因為一筆交易可能有多個輸出，需要有信息指明是具體的哪一個）。ScriptSig 是一個腳本，提供了可作用于一個輸出的 ScriptPubKey 的數(shù)據(jù)。如果 ScriptSig 提供的數(shù)據(jù)是正確的，那么輸出就會被解鎖，然后被解鎖的值就可以被用于產(chǎn)生新的輸出；如果數(shù)據(jù)不正確，輸出就無法被引用在輸入中，或者說，也就是無法使用這個輸出。這種機制，保證了用戶無法花費屬于其他人的幣。

再次強調(diào)，由于我們還沒有實現(xiàn)地址，所以 ScriptSig 將僅僅存儲一個任意用戶定義的錢包地址。我們會在下一篇文章中實現(xiàn)公鑰（public key）和簽名（signature）。

來簡要總結(jié)一下。輸出，就是 “幣” 存儲的地方。每個輸出都會帶有一個解鎖腳本，這個腳本定義了解鎖該輸出的邏輯。每筆新的交易，必須至少有一個輸入和輸出。一個輸入引用了之前一筆交易的輸出，并提供了數(shù)據(jù)（也就是 ScriptSig 字段），該數(shù)據(jù)會被用在輸出的解鎖腳本中解鎖輸出，解鎖完成后即可使用它的值去產(chǎn)生新的輸出。

也就是說，每一筆輸入都是之前一筆交易的輸出，那么從一筆交易開始不斷往前追溯，它涉及的輸入和輸出到底是誰先存在呢？換個說法，這是個雞和蛋誰先誰后的問題，是先有蛋還是先有雞呢？

在比特幣中，是先有蛋，然后才有雞。輸入引用輸出的邏輯，是經(jīng)典的“蛋還是雞”問題：輸入先產(chǎn)生輸出，然后輸出使得輸入成為可能。在比特幣中，最先有輸出，然后才有輸入。換而言之，第一筆交易只有輸出，沒有輸入。

當?shù)V工挖出一個新的塊時，它會向新的塊中添加一個 coinbase 交易。coinbase 交易是一種特殊的交易，它不需要引用之前一筆交易的輸出。它“憑空”產(chǎn)生了幣（也就是產(chǎn)生了新幣），這也是礦工獲得挖出新塊的獎勵，可以理解為“發(fā)行新幣”。

在區(qū)塊鏈的最初，也就是第一個塊，叫做創(chuàng)世塊。正是這個創(chuàng)世塊，產(chǎn)生了區(qū)塊鏈最開始的輸出。對于創(chuàng)世塊，不需要引用之前交易的輸出。因為在創(chuàng)世塊之前根本不存在交易，也就沒有不存在有交易輸出。

來創(chuàng)建一個 coinbase 交易：

func NewCoinbaseTX(to, data string) *Transaction {
    if data == "" {
        data = fmt.Sprintf("Reward to "%s"", to)
    }

    txin := TXInput{[]byte{}, -1, data}
    txout := TXOutput{subsidy, to}
    tx := Transaction{nil, []TXInput{txin}, []TXOutput{txout}}
    tx.SetID()

    return &tx
}

coinbase 交易只有一個輸出，沒有輸入。在我們的實現(xiàn)中，它的 Txid 為空，Vout 等于 -1。并且，在目前的視線中，coinbase 交易也沒有在 ScriptSig 中存儲一個腳本，而只是存儲了一個任意的字符串。

在比特幣中，第一筆 coinbase 交易包含了如下信息：“The Times 03/Jan/2009 Chancellor on brink of second bailout for banks”?？牲c擊這里查看.

subsidy 是獎勵的數(shù)額。在比特幣中，實際并沒有存儲這個數(shù)字，而是基于區(qū)塊總數(shù)進行計算而得：區(qū)塊總數(shù)除以 210000 就是 subsidy。挖出創(chuàng)世塊的獎勵是 50 BTC，每挖出 210000 個塊后，獎勵減半。在我們的實現(xiàn)中，這個獎勵值將會是一個常量（至少目前是）。

從現(xiàn)在開始，每個塊必須存儲至少一筆交易。如果沒有交易，也就不可能挖出新的塊。這意味著我們應該移除 Block 的 Data 字段，取而代之的是存儲交易：

type Block struct {
    Timestamp     int64
    Transactions  []*Transaction
    PrevBlockHash []byte
    Hash          []byte
    Nonce         int
}

NewBlock 和 NewGenesisBlock 也必須做出相應改變：

func NewBlock(transactions []*Transaction, prevBlockHash []byte) *Block {
    block := &Block{time.Now().Unix(), transactions, prevBlockHash, []byte{}, 0}
    ...
}

func NewGenesisBlock(coinbase *Transaction) *Block {
    return NewBlock([]*Transaction{coinbase}, []byte{})
}

接下來修改創(chuàng)建新鏈的函數(shù)：

func CreateBlockchain(address string) *Blockchain {
    ...
    err = db.Update(func(tx *bolt.Tx) error {
        cbtx := NewCoinbaseTX(address, genesisCoinbaseData)
        genesis := NewGenesisBlock(cbtx)

        b, err := tx.CreateBucket([]byte(blocksBucket))
        err = b.Put(genesis.Hash, genesis.Serialize())
        ...
    })
    ...
}

現(xiàn)在，這個函數(shù)會接受一個地址作為參數(shù)，這個地址會用來接收挖出創(chuàng)世塊的獎勵。

工作量證明算法必須要將存儲在區(qū)塊里面的交易考慮進去，以此保證區(qū)塊鏈交易存儲的一致性和可靠性。所以，我們必須修改 ProofOfWork.prepareData 方法：

func (pow *ProofOfWork) prepareData(nonce int) []byte {
    data := bytes.Join(
        [][]byte{
            pow.block.PrevBlockHash,
            pow.block.HashTransactions(), // This line was changed
            IntToHex(pow.block.Timestamp),
            IntToHex(int64(targetBits)),
            IntToHex(int64(nonce)),
        },
        []byte{},
    )

    return data
}

不像之前使用 pow.block.Data，現(xiàn)在我們使用 pow.block.HashTransactions() ：

func (b *Block) HashTransactions() []byte {
    var txHashes [][]byte
    var txHash [32]byte

    for _, tx := range b.Transactions {
        txHashes = append(txHashes, tx.ID)
    }
    txHash = sha256.Sum256(bytes.Join(txHashes, []byte{}))

    return txHash[:]
}

我們使用哈希提供數(shù)據(jù)的唯一表示，這個之前也遇到過。我們想要通過僅僅一個哈希，就可以識別一個塊里面的所有交易。為此，我們獲得每筆交易的哈希，將它們關(guān)聯(lián)起來，然后獲得一個連接后的組合哈希。

比特幣使用了一個更加復雜的技術(shù)：它將一個塊里面包含的所有交易表示為一個 ?Merkle tree ，然后在工作量證明系統(tǒng)中使用樹的根哈希（root hash）。這個方法能夠讓我們快速檢索一個塊里面是否包含了某筆交易，即只需 root hash 而無需下載所有交易即可完成判斷。

來檢查一下到目前為止是否正確：

$ blockchain_go createblockchain -address Ivan
00000093450837f8b52b78c25f8163bb6137caf43ff4d9a01d1b731fa8ddcc8a

Done!

很好！我們已經(jīng)獲得了第一筆挖礦獎勵，但是，我們要如何查看余額呢？

我們需要找到所有的未花費交易輸出（unspent transactions outputs, UTXO）。未花費（unspent） 指的是這個輸出還沒有被包含在任何交易的輸入中，或者說沒有被任何輸入引用。在上面的圖示中，未花費的輸出是：

tx0, output 1;

tx1, output 0;

tx3, output 0;

tx4, output 0.

當然了，當我們檢查余額時，我們并不需要知道整個區(qū)塊鏈上所有的 UTXO，只需要關(guān)注那些我們能夠解鎖的那些 UTXO（目前我們還沒有實現(xiàn)密鑰，所以我們將會使用用戶定義的地址來代替）。首先，讓我們定義在輸入和輸出上的鎖定和解鎖方法：

func (in *TXInput) CanUnlockOutputWith(unlockingData string) bool {
    return in.ScriptSig == unlockingData
}

func (out *TXOutput) CanBeUnlockedWith(unlockingData string) bool {
    return out.ScriptPubKey == unlockingData
}

在這里，我們只是將 script 字段與 unlockingData 進行了比較。在后續(xù)文章我們基于私鑰實現(xiàn)了地址以后，會對這部分進行改進。

下一步，找到包含未花費輸出的交易，這一步相當困難：

func (bc *Blockchain) FindUnspentTransactions(address string) []Transaction {
  var unspentTXs []Transaction
  spentTXOs := make(map[string][]int)
  bci := bc.Iterator()

  for {
    block := bci.Next()

    for _, tx := range block.Transactions {
      txID := hex.EncodeToString(tx.ID)

    Outputs:
      for outIdx, out := range tx.Vout {
        // Was the output spent?
        if spentTXOs[txID] != nil {
          for _, spentOut := range spentTXOs[txID] {
            if spentOut == outIdx {
              continue Outputs
            }
          }
        }

        if out.CanBeUnlockedWith(address) {
          unspentTXs = append(unspentTXs, *tx)
        }
      }

      if tx.IsCoinbase() == false {
        for _, in := range tx.Vin {
          if in.CanUnlockOutputWith(address) {
            inTxID := hex.EncodeToString(in.Txid)
            spentTXOs[inTxID] = append(spentTXOs[inTxID], in.Vout)
          }
        }
      }
    }

    if len(block.PrevBlockHash) == 0 {
      break
    }
  }

  return unspentTXs
}

由于交易被存儲在區(qū)塊里，所以我們不得不檢查區(qū)塊鏈里的每一筆交易。從輸出開始：

if out.CanBeUnlockedWith(address) {
    unspentTXs = append(unspentTXs, tx)
}

如果一個輸出被一個地址鎖定，并且這個地址恰好是我們要找的未花費交易輸出的地址，那么這個輸出就是我們想要的。不過在獲取它之前，我們需要檢查該輸出是否已經(jīng)被包含在一個輸入中，也就是檢查它是否已經(jīng)被花費了：

if spentTXOs[txID] != nil {
    for _, spentOut := range spentTXOs[txID] {
        if spentOut == outIdx {
            continue Outputs
        }
    }
}

我們跳過那些已經(jīng)被包含在其他輸入中的輸出（被包含在輸入中，也就是說明這個輸出已經(jīng)被花費，無法再用了）。檢查完輸出以后，我們將所有能夠解鎖給定地址鎖定的輸出的輸入聚集起來（這并不適用于 coinbase 交易，因為它們不解鎖輸出）：

if tx.IsCoinbase() == false {
    for _, in := range tx.Vin {
        if in.CanUnlockOutputWith(address) {
            inTxID := hex.EncodeToString(in.Txid)
            spentTXOs[inTxID] = append(spentTXOs[inTxID], in.Vout)
        }
    }
}

這個函數(shù)返回了一個交易列表，里面包含了未花費輸出。為了計算余額，我們還需要一個函數(shù)將這些交易作為輸入，然后僅返回一個輸出：

func (bc *Blockchain) FindUTXO(address string) []TXOutput {
       var UTXOs []TXOutput
       unspentTransactions := bc.FindUnspentTransactions(address)

       for _, tx := range unspentTransactions {
               for _, out := range tx.Vout {
                       if out.CanBeUnlockedWith(address) {
                               UTXOs = append(UTXOs, out)
                       }
               }
       }

       return UTXOs
}

就是這么多了！現(xiàn)在我們來實現(xiàn) getbalance 命令：

func (cli *CLI) getBalance(address string) {
    bc := NewBlockchain(address)
    defer bc.db.Close()

    balance := 0
    UTXOs := bc.FindUTXO(address)

    for _, out := range UTXOs {
        balance += out.Value
    }

    fmt.Printf("Balance of "%s": %d
", address, balance)
}

賬戶余額就是由賬戶地址鎖定的所有未花費交易輸出的總和。

在挖出創(chuàng)世塊以后，來檢查一下我們的余額：

$ blockchain_go getbalance -address Ivan
Balance of "Ivan": 10

這就是我們的第一筆錢！

現(xiàn)在，我們想要給其他人發(fā)送一些幣。為此，我們需要創(chuàng)建一筆新的交易，將它放到一個塊里，然后挖出這個塊。之前我們只實現(xiàn)了 coinbase 交易（這是一種特殊的交易），現(xiàn)在我們需要一種通用的交易：

func NewUTXOTransaction(from, to string, amount int, bc *Blockchain) *Transaction {
    var inputs []TXInput
    var outputs []TXOutput

    acc, validOutputs := bc.FindSpendableOutputs(from, amount)

    if acc < amount {
        log.Panic("ERROR: Not enough funds")
    }

    // Build a list of inputs
    for txid, outs := range validOutputs {
        txID, err := hex.DecodeString(txid)

        for _, out := range outs {
            input := TXInput{txID, out, from}
            inputs = append(inputs, input)
        }
    }

    // Build a list of outputs
    outputs = append(outputs, TXOutput{amount, to})
    if acc > amount {
        outputs = append(outputs, TXOutput{acc - amount, from}) // a change
    }

    tx := Transaction{nil, inputs, outputs}
    tx.SetID()

    return &tx
}

在創(chuàng)建新的輸出前，我們首先必須找到所有的未花費輸出，并且確保它們存儲了足夠的值（value），這就是 FindSpendableOutputs 方法做的事情。隨后，對于每個找到的輸出，會創(chuàng)建一個引用該輸出的輸入。接下來，我們創(chuàng)建兩個輸出：

一個由接收者地址鎖定。這是給實際給其他地址轉(zhuǎn)移的幣。

一個由發(fā)送者地址鎖定。這是一個找零。只有當未花費輸出超過新交易所需時產(chǎn)生。記住：輸出是不可再分的。

FindSpendableOutputs 方法基于之前定義的 FindUnspentTransactions 方法：

func (bc *Blockchain) FindSpendableOutputs(address string, amount int) (int, map[string][]int) {
    unspentOutputs := make(map[string][]int)
    unspentTXs := bc.FindUnspentTransactions(address)
    accumulated := 0

Work:
    for _, tx := range unspentTXs {
        txID := hex.EncodeToString(tx.ID)

        for outIdx, out := range tx.Vout {
            if out.CanBeUnlockedWith(address) && accumulated < amount {
                accumulated += out.Value
                unspentOutputs[txID] = append(unspentOutputs[txID], outIdx)

                if accumulated >= amount {
                    break Work
                }
            }
        }
    }

    return accumulated, unspentOutputs
}

這個方法對所有的未花費交易進行迭代，并對它的值進行累加。當累加值大于或等于我們想要傳送的值時，它就會停止并返回累加值，同時返回的還有通過交易 ID 進行分組的輸出索引。我們并不想要取出超出需要花費的錢。

現(xiàn)在，我們可以修改 Blockchain.MineBlock 方法：

func (bc *Blockchain) MineBlock(transactions []*Transaction) {
    ...
    newBlock := NewBlock(transactions, lastHash)
    ...
}

最后，讓我們來實現(xiàn) send 方法：

func (cli *CLI) send(from, to string, amount int) {
    bc := NewBlockchain(from)
    defer bc.db.Close()

    tx := NewUTXOTransaction(from, to, amount, bc)
    bc.MineBlock([]*Transaction{tx})
    fmt.Println("Success!")
}

發(fā)送幣意味著創(chuàng)建新的交易，并通過挖出新塊的方式將交易打包到區(qū)塊鏈中。不過，比特幣并不是一連串立刻完成這些事情（不過我們的實現(xiàn)是這么做的）。相反，它會將所有新的交易放到一個內(nèi)存池中（mempool），然后當一個礦工準備挖出一個新塊時，它就從內(nèi)存池中取出所有的交易，創(chuàng)建一個候選塊。只有當包含這些交易的塊被挖出來，并添加到區(qū)塊鏈以后，里面的交易才開始確認。

讓我們來檢查一下發(fā)送幣是否能工作：

$ blockchain_go send -from Ivan -to Pedro -amount 6
00000001b56d60f86f72ab2a59fadb197d767b97d4873732be505e0a65cc1e37

Success!

$ blockchain_go getbalance -address Ivan
Balance of "Ivan": 4

$ blockchain_go getbalance -address Pedro
Balance of "Pedro": 6

很好！現(xiàn)在，讓我們創(chuàng)建更多的交易，確保從多個輸出中發(fā)送幣也正常工作：

$ blockchain_go send -from Pedro -to Helen -amount 2
00000099938725eb2c7730844b3cd40209d46bce2c2af9d87c2b7611fe9d5bdf

Success!

$ blockchain_go send -from Ivan -to Helen -amount 2
000000a2edf94334b1d94f98d22d7e4c973261660397dc7340464f7959a7a9aa

Success!

現(xiàn)在，Helen 的幣被鎖定在了兩個輸出中：一個來自 Pedro，一個來自 Ivan。讓我們把它們發(fā)送給其他人：

$ blockchain_go send -from Helen -to Rachel -amount 3
000000c58136cffa669e767b8f881d16e2ede3974d71df43058baaf8c069f1a0

Success!

$ blockchain_go getbalance -address Ivan
Balance of "Ivan": 2

$ blockchain_go getbalance -address Pedro
Balance of "Pedro": 4

$ blockchain_go getbalance -address Helen
Balance of "Helen": 1

$ blockchain_go getbalance -address Rachel
Balance of "Rachel": 3

看起來沒問題！現(xiàn)在，來測試一些失敗的情況：

$ blockchain_go send -from Pedro -to Ivan -amount 5
panic: ERROR: Not enough funds

$ blockchain_go getbalance -address Pedro
Balance of "Pedro": 4

$ blockchain_go getbalance -address Ivan
Balance of "Ivan": 2

雖然不容易，但是現(xiàn)在終于實現(xiàn)交易了！不過，我們依然缺少了一些像比特幣那樣的一些關(guān)鍵特性：

地址（address）。我們還沒有基于私鑰（private key）的真實地址。

獎勵（reward）?，F(xiàn)在挖礦是肯定無法盈利的！

UTXO 集。獲取余額需要掃描整個區(qū)塊鏈，而當區(qū)塊非常多的時候，這么做就會花費很長時間。并且，如果我們想要驗證后續(xù)交易，也需要花費很長時間。而 UTXO 集就是為了解決這些問題，加快交易相關(guān)的操作。

內(nèi)存池（mempool）。在交易被打包到塊之前，這些交易被存儲在內(nèi)存池里面。在我們目前的實現(xiàn)中，一個塊僅僅包含一筆交易，這是相當?shù)托У摹?/p>

鏈接:

Full source codes

Transaction

Merkle tree

Coinbase

本文源代碼：part_4

原文鏈接：Building Blockchain in Go. Part 4: Transactions 1