Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-06-06 14:16:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Dev 334 make id merkle root and transaction id, fix tests, and add new tests (#166)

Browse Source 
* [DEV-329] Add TxID

* [DEV-329] Change Transaction inputs to reference by tx id instead of tx hash

* [DEV-329] Fix tests

* [DEV-329] change txhash to txid in mempool

* [DEV-334] Make IDMerkleRoot

* [DEV-329] Add txid that excludes payload, gas and ScriptSigs (#158)

* [DEV-329] Add TxID

* [DEV-329] Change Transaction inputs to reference by tx id instead of tx hash

* [DEV-329] Fix tests

* [DEV-329] change txhash to txid in mempool

* [DEV-329] replace thinEncoding bool with txEncoding bitmask

* [DEV-329] Change txencoding var names

* [DEV-329] change txEncodingexcludeSignatureScript -> txEncodingExcludeSignatureScript

* [DEV-334] Add IDMerkleRoot to blocknode and recalculate IDMerkleRoot when extraNonce is changed

* [DEV-334] Fix tests

* [DEV-334] Fix tests

* [DEV-334] fix SubnetworkDAGCoin -> SubnetworkIDNative

* [DEV-334] Add ID() function to Coin interface and rename hash to txID in a few places

* [DEV-334] Add Root method for merkle root

* [DEV-334] add comment to dag.SubnetworkID()

* [DEV-334] fix serializeSize comment
This commit is contained in:
Ori Newman 2019-01-23 14:04:23 +02:00 committed by GitHub
parent 4be23bff07
commit b963c0d364
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
86 changed files with 1288 additions and 1165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
blockdag/accept_test.go
View File

@ -29,7 +29,7 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
orphanBlockFile := "blk_3B.dat" orphanBlockFile := "blk_3B.dat"
loadedBlocks, err := loadBlocks(orphanBlockFile) loadedBlocks, err := loadBlocks(orphanBlockFile)
if err != nil { if err != nil {
t.Fatalf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+ t.Fatalf("TestMaybeAcceptBlockErrors: "+
"Error loading file '%s': %s\n", orphanBlockFile, err) "Error loading file '%s': %s\n", orphanBlockFile, err)
} }
block := loadedBlocks[0] block := loadedBlocks[0]
@ -52,7 +52,7 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
blocksFile := "blk_0_to_4.dat" blocksFile := "blk_0_to_4.dat"
blocks, err := loadBlocks(blocksFile) blocks, err := loadBlocks(blocksFile)
if err != nil { if err != nil {
t.Fatalf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+ t.Fatalf("TestMaybeAcceptBlockErrors: "+
"Error loading file '%s': %s\n", blocksFile, err) "Error loading file '%s': %s\n", blocksFile, err)
} }

31
blockdag/bench_test.go
View File

@ -1,31 +0,0 @@
// Copyright (c) 2015 The btcsuite developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package blockdag
import (
"testing"
"github.com/daglabs/btcd/util"
)
// BenchmarkIsCoinBase performs a simple benchmark against the IsCoinBase
// function.
func BenchmarkIsCoinBase(b *testing.B) {
tx, _ := util.NewBlock(&Block100000).Tx(1)
b.ResetTimer()
for i := 0; i < b.N; i++ {
IsCoinBase(tx)
}
}
// BenchmarkIsCoinBaseTx performs a simple benchmark against the IsCoinBaseTx
// function.
func BenchmarkIsCoinBaseTx(b *testing.B) {
tx := Block100000.Transactions[1]
b.ResetTimer()
for i := 0; i < b.N; i++ {
IsCoinBaseTx(tx)
}
}

27
blockdag/blocknode.go
View File

@ -102,11 +102,12 @@ type blockNode struct {
// reconstructing headers from memory. These must be treated as // reconstructing headers from memory. These must be treated as
// immutable and are intentionally ordered to avoid padding on 64-bit // immutable and are intentionally ordered to avoid padding on 64-bit
// platforms. // platforms.
version int32 version int32
bits uint32 bits uint32
nonce uint64 nonce uint64
timestamp int64 timestamp int64
merkleRoot daghash.Hash hashMerkleRoot daghash.Hash
idMerkleRoot daghash.Hash
// status is a bitfield representing the validation state of the block. The // status is a bitfield representing the validation state of the block. The
// status field, unlike the other fields, may be written to and so should // status field, unlike the other fields, may be written to and so should
@ -134,7 +135,8 @@ func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, parents block
node.bits = blockHeader.Bits node.bits = blockHeader.Bits
node.nonce = blockHeader.Nonce node.nonce = blockHeader.Nonce
node.timestamp = blockHeader.Timestamp.Unix() node.timestamp = blockHeader.Timestamp.Unix()
node.merkleRoot = blockHeader.MerkleRoot node.hashMerkleRoot = blockHeader.HashMerkleRoot
node.idMerkleRoot = blockHeader.IDMerkleRoot
// update parents to point to new node // update parents to point to new node
for _, p := range parents { for _, p := range parents {
@ -185,12 +187,13 @@ func (node *blockNode) detachFromParents() {
func (node *blockNode) Header() *wire.BlockHeader { func (node *blockNode) Header() *wire.BlockHeader {
// No lock is needed because all accessed fields are immutable. // No lock is needed because all accessed fields are immutable.
return &wire.BlockHeader{ return &wire.BlockHeader{
Version: node.version, Version: node.version,
ParentHashes: node.ParentHashes(), ParentHashes: node.ParentHashes(),
MerkleRoot: node.merkleRoot, HashMerkleRoot: node.hashMerkleRoot,
Timestamp: time.Unix(node.timestamp, 0), IDMerkleRoot: node.idMerkleRoot,
Bits: node.bits, Timestamp: time.Unix(node.timestamp, 0),
Nonce: node.nonce, Bits: node.bits,
Nonce: node.nonce,
} }
} }

8
blockdag/common_test.go
View File

@ -106,9 +106,9 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
utxoSet := NewFullUTXOSet() utxoSet := NewFullUTXOSet()
for { for {
// Hash of the utxo entry. // Tx ID of the utxo entry.
var hash daghash.Hash var txID daghash.Hash
_, err := io.ReadAtLeast(r, hash[:], len(hash[:])) _, err := io.ReadAtLeast(r, txID[:], len(txID[:]))
if err != nil { if err != nil {
// Expected EOF at the right offset. // Expected EOF at the right offset.
if err == io.EOF { if err == io.EOF {
@ -143,7 +143,7 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
utxoSet.utxoCollection[wire.OutPoint{Hash: hash, Index: index}] = entry utxoSet.utxoCollection[wire.OutPoint{TxID: txID, Index: index}] = entry
} }
return utxoSet, nil return utxoSet, nil

6
blockdag/dag.go
View File

@ -7,11 +7,12 @@ package blockdag
import ( import (
"errors" "errors"
"fmt" "fmt"
"github.com/daglabs/btcd/util/subnetworkid"
"math" "math"
"sync" "sync"
"time" "time"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/dagconfig" "github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash" "github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/database" "github.com/daglabs/btcd/database"
@ -364,7 +365,7 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
str := fmt.Sprintf("output %v referenced from "+ str := fmt.Sprintf("output %v referenced from "+
"transaction %s:%d either does not exist or "+ "transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint, "has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex) tx.ID(), txInIndex)
return sequenceLock, ruleError(ErrMissingTxOut, str) return sequenceLock, ruleError(ErrMissingTxOut, str)
} }
@ -1343,6 +1344,7 @@ func (dag *BlockDAG) LocateHeaders(locator BlockLocator, hashStop *daghash.Hash)
return headers return headers
} }
// SubnetworkID returns the node's subnetwork ID
func (dag *BlockDAG) SubnetworkID() *subnetworkid.SubnetworkID { func (dag *BlockDAG) SubnetworkID() *subnetworkid.SubnetworkID {
return dag.subnetworkID return dag.subnetworkID
} }

12
blockdag/dag_test.go
View File

@ -41,7 +41,7 @@ func TestBlockCount(t *testing.T) {
} }
// Create a new database and DAG instance to run tests against. // Create a new database and DAG instance to run tests against.
dag, teardownFunc, err := DAGSetup("haveblock", Config{ dag, teardownFunc, err := DAGSetup("TestBlockCount", Config{
DAGParams: &dagconfig.SimNetParams, DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll, SubnetworkID: &wire.SubnetworkIDSupportsAll,
}) })
@ -158,7 +158,7 @@ func TestHaveBlock(t *testing.T) {
} }
rErr, ok := err.(RuleError) rErr, ok := err.(RuleError)
if !ok { if !ok {
t.Fatalf("ProcessBlock for block 3D expected a RuleError, but got something else\n") t.Fatalf("ProcessBlock for block 3D expected a RuleError, but got %v\n", err)
} }
if !ok || rErr.ErrorCode != ErrDuplicateTxInputs { if !ok || rErr.ErrorCode != ErrDuplicateTxInputs {
t.Fatalf("ProcessBlock for block 3D expected error code %s but got %s\n", ErrDuplicateTxInputs, rErr.ErrorCode) t.Fatalf("ProcessBlock for block 3D expected error code %s but got %s\n", ErrDuplicateTxInputs, rErr.ErrorCode)
@ -187,10 +187,10 @@ func TestHaveBlock(t *testing.T) {
{hash: dagconfig.SimNetParams.GenesisHash.String(), want: true}, {hash: dagconfig.SimNetParams.GenesisHash.String(), want: true},
// Block 3b should be present (as a second child of Block 2). // Block 3b should be present (as a second child of Block 2).
{hash: "2664223a8b2abba475ed5760433e8204806c17b60f12d826b876cccbf5f74be6", want: true}, {hash: "4b89947c906a2a95fa9b4a4b4cb11a51f87cae2cfa2c9bcddfd45140a7e62e1f", want: true},
// Block 100000 should be present (as an orphan). // Block 100000 should be present (as an orphan).
{hash: "66965d8ebcdccae2b3791f652326ef1063fa0a7e506c66f68e0c7bbb59104711", want: true}, {hash: "22accd0c0281c0776dc3b5d5957bae3f61290e1075f97c99cd347c38cc26555a", want: true},
// Random hashes should not be available. // Random hashes should not be available.
{hash: "123", want: false}, {hash: "123", want: false},
@ -252,7 +252,7 @@ func TestCalcSequenceLock(t *testing.T) {
// point of view that they were originally calculated from for a given // point of view that they were originally calculated from for a given
// utxo. That is to say, the height prior to it. // utxo. That is to say, the height prior to it.
utxo := wire.OutPoint{ utxo := wire.OutPoint{
Hash: *targetTx.Hash(), TxID: *targetTx.ID(),
Index: 0, Index: 0,
} }
prevUtxoHeight := int32(numBlocksToGenerate) - 4 prevUtxoHeight := int32(numBlocksToGenerate) - 4
@ -278,7 +278,7 @@ func TestCalcSequenceLock(t *testing.T) {
}}, }},
} }
unConfUtxo := wire.OutPoint{ unConfUtxo := wire.OutPoint{
Hash: unConfTx.TxHash(), TxID: unConfTx.TxID(),
Index: 0, Index: 0,
} }

4
blockdag/dagio.go
View File

@ -473,7 +473,7 @@ func outpointKey(outpoint wire.OutPoint) *[]byte {
key := outpointKeyPool.Get().(*[]byte) key := outpointKeyPool.Get().(*[]byte)
idx := uint64(outpoint.Index) idx := uint64(outpoint.Index)
*key = (*key)[:daghash.HashSize+serializeSizeVLQ(idx)] *key = (*key)[:daghash.HashSize+serializeSizeVLQ(idx)]
copy(*key, outpoint.Hash[:]) copy(*key, outpoint.TxID[:])
putVLQ((*key)[daghash.HashSize:], idx) putVLQ((*key)[daghash.HashSize:], idx)
return key return key
} }
@ -712,7 +712,7 @@ func (dag *BlockDAG) createDAGState() error {
genesisCoinbase := genesisBlock.Transactions()[0].MsgTx() genesisCoinbase := genesisBlock.Transactions()[0].MsgTx()
genesisCoinbaseTxIn := genesisCoinbase.TxIn[0] genesisCoinbaseTxIn := genesisCoinbase.TxIn[0]
genesisCoinbaseTxOut := genesisCoinbase.TxOut[0] genesisCoinbaseTxOut := genesisCoinbase.TxOut[0]
genesisCoinbaseOutpoint := *wire.NewOutPoint(&genesisCoinbaseTxIn.PreviousOutPoint.Hash, genesisCoinbaseTxIn.PreviousOutPoint.Index) genesisCoinbaseOutpoint := *wire.NewOutPoint(&genesisCoinbaseTxIn.PreviousOutPoint.TxID, genesisCoinbaseTxIn.PreviousOutPoint.Index)
genesisCoinbaseUTXOEntry := NewUTXOEntry(genesisCoinbaseTxOut, true, 0) genesisCoinbaseUTXOEntry := NewUTXOEntry(genesisCoinbaseTxOut, true, 0)
node.diff = &UTXODiff{ node.diff = &UTXODiff{
toAdd: utxoCollection{genesisCoinbaseOutpoint: genesisCoinbaseUTXOEntry}, toAdd: utxoCollection{genesisCoinbaseOutpoint: genesisCoinbaseUTXOEntry},

10
blockdag/dagio_test.go
View File

@ -233,7 +233,7 @@ func TestSpendJournalSerialization(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"), TxID: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),
Index: 0, Index: 0,
}, },
SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"), SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),
@ -268,7 +268,7 @@ func TestSpendJournalSerialization(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *newHashFromStr("c0ed017828e59ad5ed3cf70ee7c6fb0f426433047462477dc7a5d470f987a537"), TxID: *newHashFromStr("c0ed017828e59ad5ed3cf70ee7c6fb0f426433047462477dc7a5d470f987a537"),
Index: 1, Index: 1,
}, },
SignatureScript: hexToBytes("493046022100c167eead9840da4a033c9a56470d7794a9bb1605b377ebe5688499b39f94be59022100fb6345cab4324f9ea0b9ee9169337534834638d818129778370f7d378ee4a325014104d962cac5390f12ddb7539507065d0def320d68c040f2e73337c3a1aaaab7195cb5c4d02e0959624d534f3c10c3cf3d73ca5065ebd62ae986b04c6d090d32627c"), SignatureScript: hexToBytes("493046022100c167eead9840da4a033c9a56470d7794a9bb1605b377ebe5688499b39f94be59022100fb6345cab4324f9ea0b9ee9169337534834638d818129778370f7d378ee4a325014104d962cac5390f12ddb7539507065d0def320d68c040f2e73337c3a1aaaab7195cb5c4d02e0959624d534f3c10c3cf3d73ca5065ebd62ae986b04c6d090d32627c"),
@ -286,7 +286,7 @@ func TestSpendJournalSerialization(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *newHashFromStr("92fbe1d4be82f765dfabc9559d4620864b05cc897c4db0e29adac92d294e52b7"), TxID: *newHashFromStr("92fbe1d4be82f765dfabc9559d4620864b05cc897c4db0e29adac92d294e52b7"),
Index: 0, Index: 0,
}, },
SignatureScript: hexToBytes("483045022100e256743154c097465cf13e89955e1c9ff2e55c46051b627751dee0144183157e02201d8d4f02cde8496aae66768f94d35ce54465bd4ae8836004992d3216a93a13f00141049d23ce8686fe9b802a7a938e8952174d35dd2c2089d4112001ed8089023ab4f93a3c9fcd5bfeaa9727858bf640dc1b1c05ec3b434bb59837f8640e8810e87742"), SignatureScript: hexToBytes("483045022100e256743154c097465cf13e89955e1c9ff2e55c46051b627751dee0144183157e02201d8d4f02cde8496aae66768f94d35ce54465bd4ae8836004992d3216a93a13f00141049d23ce8686fe9b802a7a938e8952174d35dd2c2089d4112001ed8089023ab4f93a3c9fcd5bfeaa9727858bf640dc1b1c05ec3b434bb59837f8640e8810e87742"),
@ -353,7 +353,7 @@ func TestSpendJournalErrors(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"), TxID: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),
Index: 0, Index: 0,
}, },
SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"), SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),
@ -370,7 +370,7 @@ func TestSpendJournalErrors(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"), TxID: *newHashFromStr("0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9"),
Index: 0, Index: 0,
}, },
SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"), SignatureScript: hexToBytes("47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"),

2
blockdag/example_test.go
View File

@ -70,7 +70,7 @@ func ExampleBlockDAG_ProcessBlock() {
fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan) fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan)
// Output: // Output:
// Failed to process block: already have block 4acd12ea38e16dd28b067c13f677511ac0a4d9074c932223082fd444655fd9ca // Failed to process block: already have block ccc309e79328f036bdd6964adbed68ff374cfb878c7a797c0aae3fec4bf9b853
} }
// This example demonstrates how to convert the compact "bits" in a block header // This example demonstrates how to convert the compact "bits" in a block header

36
blockdag/fullblocktests/generate.go
View File

@ -161,7 +161,7 @@ type spendableOut struct {
func makeSpendableOutForTx(tx *wire.MsgTx, txOutIndex uint32) spendableOut { func makeSpendableOutForTx(tx *wire.MsgTx, txOutIndex uint32) spendableOut {
return spendableOut{ return spendableOut{
prevOut: wire.OutPoint{ prevOut: wire.OutPoint{
Hash: tx.TxHash(), TxID: tx.TxID(),
Index: txOutIndex, Index: txOutIndex,
}, },
amount: util.Amount(tx.TxOut[txOutIndex].Value), amount: util.Amount(tx.TxOut[txOutIndex].Value),
@ -297,9 +297,9 @@ func (g *testGenerator) createCoinbaseTx(blockHeight int32) *wire.MsgTx {
return tx return tx
} }
// calcMerkleRoot creates a merkle tree from the slice of transactions and // calcHashMerkleRoot creates a merkle tree from the slice of transactions and
// returns the root of the tree. // returns the root of the tree.
func calcMerkleRoot(txns []*wire.MsgTx) daghash.Hash { func calcHashMerkleRoot(txns []*wire.MsgTx) daghash.Hash {
if len(txns) == 0 { if len(txns) == 0 {
return daghash.Hash{} return daghash.Hash{}
} }
@ -308,8 +308,8 @@ func calcMerkleRoot(txns []*wire.MsgTx) daghash.Hash {
for _, tx := range txns { for _, tx := range txns {
utilTxns = append(utilTxns, util.NewTx(tx)) utilTxns = append(utilTxns, util.NewTx(tx))
} }
merkles := blockdag.BuildMerkleTreeStore(utilTxns) merkleTree := blockdag.BuildHashMerkleTreeStore(utilTxns)
return *merkles[len(merkles)-1] return *merkleTree.Root()
} }
// solveBlock attempts to find a nonce which makes the passed block header hash // solveBlock attempts to find a nonce which makes the passed block header hash
@ -509,25 +509,25 @@ func (g *testGenerator) nextBlock(blockName string, spend *spendableOut, mungers
block := wire.MsgBlock{ block := wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{g.tip.BlockHash()}, // TODO: (Stas) This is wrong. Modified only to satisfy compilation. ParentHashes: []daghash.Hash{g.tip.BlockHash()}, // TODO: (Stas) This is wrong. Modified only to satisfy compilation.
MerkleRoot: calcMerkleRoot(txns), HashMerkleRoot: calcHashMerkleRoot(txns),
Bits: g.params.PowLimitBits, Bits: g.params.PowLimitBits,
Timestamp: ts, Timestamp: ts,
Nonce: 0, // To be solved. Nonce: 0, // To be solved.
}, },
Transactions: txns, Transactions: txns,
} }
// Perform any block munging just before solving. Only recalculate the // Perform any block munging just before solving. Only recalculate the
// merkle root if it wasn't manually changed by a munge function. // merkle root if it wasn't manually changed by a munge function.
curMerkleRoot := block.Header.MerkleRoot curMerkleRoot := block.Header.HashMerkleRoot
curNonce := block.Header.Nonce curNonce := block.Header.Nonce
for _, f := range mungers { for _, f := range mungers {
f(&block) f(&block)
} }
if block.Header.MerkleRoot == curMerkleRoot { if block.Header.HashMerkleRoot == curMerkleRoot {
block.Header.MerkleRoot = calcMerkleRoot(block.Transactions) block.Header.HashMerkleRoot = calcHashMerkleRoot(block.Transactions)
} }
// Only solve the block if the nonce wasn't manually changed by a munge // Only solve the block if the nonce wasn't manually changed by a munge
@ -747,7 +747,7 @@ func (g *testGenerator) assertTipBlockHash(expected daghash.Hash) {
// assertTipBlockMerkleRoot panics if the merkle root in header of the current // assertTipBlockMerkleRoot panics if the merkle root in header of the current
// tip block associated with the generator does not match the specified hash. // tip block associated with the generator does not match the specified hash.
func (g *testGenerator) assertTipBlockMerkleRoot(expected daghash.Hash) { func (g *testGenerator) assertTipBlockMerkleRoot(expected daghash.Hash) {
hash := g.tip.Header.MerkleRoot hash := g.tip.Header.HashMerkleRoot
if hash != expected { if hash != expected {
panic(fmt.Sprintf("merkle root of block %q (height %d) is %v "+ panic(fmt.Sprintf("merkle root of block %q (height %d) is %v "+
"instead of expected %v", g.tipName, g.tipHeight, hash, "instead of expected %v", g.tipName, g.tipHeight, hash,
@ -1470,7 +1470,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
// \-> b48(14) // \-> b48(14)
g.setTip("b43") g.setTip("b43")
g.nextBlock("b48", outs[14], func(b *wire.MsgBlock) { g.nextBlock("b48", outs[14], func(b *wire.MsgBlock) {
b.Header.MerkleRoot = daghash.Hash{} b.Header.HashMerkleRoot = daghash.Hash{}
}) })
rejected(blockdag.ErrBadMerkleRoot) rejected(blockdag.ErrBadMerkleRoot)
@ -1531,7 +1531,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
g.nextBlock("b52", outs[14], func(b *wire.MsgBlock) { g.nextBlock("b52", outs[14], func(b *wire.MsgBlock) {
hash := newHashFromStr("00000000000000000000000000000000" + hash := newHashFromStr("00000000000000000000000000000000" +
"00000000000000000123456789abcdef") "00000000000000000123456789abcdef")
b.Transactions[1].TxIn[0].PreviousOutPoint.Hash = *hash b.Transactions[1].TxIn[0].PreviousOutPoint.TxID = *hash
b.Transactions[1].TxIn[0].PreviousOutPoint.Index = 0 b.Transactions[1].TxIn[0].PreviousOutPoint.Index = 0
}) })
rejected(blockdag.ErrMissingTxOut) rejected(blockdag.ErrMissingTxOut)
@ -1629,7 +1629,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
}) })
g.assertTipBlockNumTxns(4) g.assertTipBlockNumTxns(4)
g.assertTipBlockHash(b57.BlockHash()) g.assertTipBlockHash(b57.BlockHash())
g.assertTipBlockMerkleRoot(b57.Header.MerkleRoot) g.assertTipBlockMerkleRoot(b57.Header.HashMerkleRoot)
rejected(blockdag.ErrDuplicateTx) rejected(blockdag.ErrDuplicateTx)
// Since the two blocks have the same hash and the generator state now // Since the two blocks have the same hash and the generator state now

14
blockdag/fullblocktests/params.go
View File

@ -54,18 +54,18 @@ var (
// as the public transaction ledger for the regression test network. // as the public transaction ledger for the regression test network.
regTestGenesisBlock = wire.MsgBlock{ regTestGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{}, ParentHashes: []daghash.Hash{},
MerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"), HashMerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
Timestamp: time.Unix(0x5b28c636, 0), // 2018-06-19 09:00:38 +0000 UTC Timestamp: time.Unix(0x5b28c636, 0), // 2018-06-19 09:00:38 +0000 UTC
Bits: 0x207fffff, // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000] Bits: 0x207fffff, // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
Nonce: 1, Nonce: 1,
}, },
Transactions: []*wire.MsgTx{{ Transactions: []*wire.MsgTx{{
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: fromHex("04ffff001d010445" + SignatureScript: fromHex("04ffff001d010445" +

6
blockdag/indexers/addrindex.go
View File

@ -811,13 +811,13 @@ func (idx *AddrIndex) indexUnconfirmedAddresses(pkScript []byte, tx *util.Tx) {
addrIndexEntry = make(map[daghash.Hash]*util.Tx) addrIndexEntry = make(map[daghash.Hash]*util.Tx)
idx.txnsByAddr[addrKey] = addrIndexEntry idx.txnsByAddr[addrKey] = addrIndexEntry
} }
addrIndexEntry[*tx.Hash()] = tx addrIndexEntry[*tx.ID()] = tx
// Add a mapping from the transaction to the address. // Add a mapping from the transaction to the address.
addrsByTxEntry := idx.addrsByTx[*tx.Hash()] addrsByTxEntry := idx.addrsByTx[*tx.ID()]
if addrsByTxEntry == nil { if addrsByTxEntry == nil {
addrsByTxEntry = make(map[[addrKeySize]byte]struct{}) addrsByTxEntry = make(map[[addrKeySize]byte]struct{})
idx.addrsByTx[*tx.Hash()] = addrsByTxEntry idx.addrsByTx[*tx.ID()] = addrsByTxEntry
} }
addrsByTxEntry[addrKey] = struct{}{} addrsByTxEntry[addrKey] = struct{}{}
idx.unconfirmedLock.Unlock() idx.unconfirmedLock.Unlock()

6
blockdag/indexers/cfindex.go
View File

@ -52,10 +52,6 @@ var (
} }
maxFilterType = uint8(len(cfHeaderKeys) - 1) maxFilterType = uint8(len(cfHeaderKeys) - 1)
// zeroHash is the daghash.Hash value of all zero bytes, defined here for
// convenience.
zeroHash daghash.Hash
) )
// dbFetchFilterIdxEntry retrieves a data blob from the filter index database. // dbFetchFilterIdxEntry retrieves a data blob from the filter index database.
@ -178,7 +174,7 @@ func storeFilter(dbTx database.Tx, block *util.Block, f *gcs.Filter,
var prevHeader *daghash.Hash var prevHeader *daghash.Hash
header := block.MsgBlock().Header header := block.MsgBlock().Header
if header.IsGenesis() { if header.IsGenesis() {
prevHeader = &zeroHash prevHeader = &daghash.Zero
} else { } else {
ph := header.SelectedParentHash() ph := header.SelectedParentHash()
pfh, err := dbFetchFilterIdxEntry(dbTx, hkey, ph) pfh, err := dbFetchFilterIdxEntry(dbTx, hkey, ph)

4
blockdag/indexers/txindex.go
View File

@ -270,7 +270,7 @@ func dbAddTxIndexEntries(dbTx database.Tx, block *util.Block, blockID uint32, ac
for i, tx := range block.Transactions() { for i, tx := range block.Transactions() {
putIncludingBlocksEntry(serializedIncludingBlocksValues[includingBlocksOffset:], txLocs[i]) putIncludingBlocksEntry(serializedIncludingBlocksValues[includingBlocksOffset:], txLocs[i])
endOffset := includingBlocksOffset + includingBlocksIndexKeyEntrySize endOffset := includingBlocksOffset + includingBlocksIndexKeyEntrySize
err := dbPutIncludingBlocksEntry(dbTx, tx.Hash(), blockID, err := dbPutIncludingBlocksEntry(dbTx, tx.ID(), blockID,
serializedIncludingBlocksValues[includingBlocksOffset:endOffset:endOffset]) serializedIncludingBlocksValues[includingBlocksOffset:endOffset:endOffset])
if err != nil { if err != nil {
return err return err
@ -299,7 +299,7 @@ func dbAddTxIndexEntries(dbTx database.Tx, block *util.Block, blockID uint32, ac
putAcceptingBlocksEntry(serializedAcceptingBlocksValues[acceptingBlocksOffset:], includingBlockID) putAcceptingBlocksEntry(serializedAcceptingBlocksValues[acceptingBlocksOffset:], includingBlockID)
endOffset := acceptingBlocksOffset + acceptingBlocksIndexKeyEntrySize endOffset := acceptingBlocksOffset + acceptingBlocksIndexKeyEntrySize
err = dbPutAcceptingBlocksEntry(dbTx, tx.Tx.Hash(), blockID, err = dbPutAcceptingBlocksEntry(dbTx, tx.Tx.ID(), blockID,
serializedAcceptingBlocksValues[acceptingBlocksOffset:endOffset:endOffset]) serializedAcceptingBlocksValues[acceptingBlocksOffset:endOffset:endOffset])
if err != nil { if err != nil {
return err return err

313
blockdag/indexers/txindex_test.go
View File

@ -53,8 +53,8 @@ func TestTxIndexConnectBlock(t *testing.T) {
processBlock(t, dag, &block2, "2") processBlock(t, dag, &block2, "2")
processBlock(t, dag, &block3, "3") processBlock(t, dag, &block3, "3")
block3TxHash := block3Tx.TxHash() block3TxID := block3Tx.TxID()
block3TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, &block3TxHash) block3TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, &block3TxID)
if err != nil { if err != nil {
t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err) t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
} }
@ -68,7 +68,7 @@ func TestTxIndexConnectBlock(t *testing.T) {
processBlock(t, dag, &block4, "4") processBlock(t, dag, &block4, "4")
processBlock(t, dag, &block5, "5") processBlock(t, dag, &block5, "5")
block3TxAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, &block3TxHash) block3TxAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, &block3TxID)
if err != nil { if err != nil {
t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err) t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
} }
@ -78,7 +78,7 @@ func TestTxIndexConnectBlock(t *testing.T) {
"been accepted in block %v but instead got accepted in block %v", block3AHash, block3TxAcceptedBlock) "been accepted in block %v but instead got accepted in block %v", block3AHash, block3TxAcceptedBlock)
} }
region, err := txIndex.TxFirstBlockRegion(&block3TxHash) region, err := txIndex.TxFirstBlockRegion(&block3TxID)
if err != nil { if err != nil {
t.Fatalf("TestTxIndexConnectBlock: no block region was found for block3Tx") t.Fatalf("TestTxIndexConnectBlock: no block region was found for block3Tx")
} }
@ -105,24 +105,30 @@ func TestTxIndexConnectBlock(t *testing.T) {
var block1 = wire.MsgBlock{ var block1 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0xca, 0xd9, 0x5f, 0x65, 0x44, 0xd4, 0x2f, 0x08, 0x53, 0xb8, 0xf9, 0x4b, 0xec, 0x3f, 0xae, 0x0a,
0x23, 0x22, 0x93, 0x4c, 0x07, 0xd9, 0xa4, 0xc0, 0x7c, 0x79, 0x7a, 0x8c, 0x87, 0xfb, 0x4c, 0x37,
0x1a, 0x51, 0x77, 0xf6, 0x13, 0x7c, 0x06, 0x8b, 0xff, 0x68, 0xed, 0xdb, 0x4a, 0x96, 0xd6, 0xbd,
0xd2, 0x6d, 0xe1, 0x38, 0xea, 0x12, 0xcd, 0x4a, 0x36, 0xf0, 0x28, 0x93, 0xe7, 0x09, 0xc3, 0xcc,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x80, 0x57, 0x44, 0xf9, 0xee, 0xb7, 0x14, 0x05, 0x71, 0x17, 0x72, 0x40, 0x46, 0x3e, 0x00, 0x87,
0x8c, 0x37, 0x2e, 0x41, 0x82, 0x98, 0xcd, 0x0d, 0x00, 0x55, 0x61, 0xbf, 0x85, 0x88, 0x16, 0x2d,
0xc8, 0xd1, 0xd1, 0x11, 0x9b, 0xe2, 0xc1, 0x4e, 0xe9, 0x75, 0x89, 0x10, 0x8f, 0x27, 0x7c, 0xb6,
0x4b, 0x7c, 0x02, 0xd1, 0x11, 0xe0, 0x50, 0x11, 0xad, 0xea, 0xf8, 0xa3, 0x7e, 0xf2, 0x73, 0x92,
}), }),
Timestamp: time.Unix(0x5c34c291, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x71, 0x17, 0x72, 0x40, 0x46, 0x3e, 0x00, 0x87,
0x00, 0x55, 0x61, 0xbf, 0x85, 0x88, 0x16, 0x2d,
0xe9, 0x75, 0x89, 0x10, 0x8f, 0x27, 0x7c, 0xb6,
0xad, 0xea, 0xf8, 0xa3, 0x7e, 0xf2, 0x73, 0x92,
}),
Timestamp: time.Unix(0x5c40a3d7, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9, Nonce: 0x3ffffffffffffffe,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -130,11 +136,12 @@ var block1 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x51, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x51, 0x08, 0xc1, 0x66, 0xe6, 0x29, 0x99, 0xe5,
0xbd, 0xc3, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -144,10 +151,7 @@ var block1 = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },
@ -159,24 +163,30 @@ var block1 = wire.MsgBlock{
var block2 = wire.MsgBlock{ var block2 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0xf1, 0x15, 0xa7, 0xd8, 0x0e, 0xb6, 0x88, 0x25, 0x8b, 0xdc, 0x78, 0x8d, 0xb8, 0x3f, 0xd1, 0x7d,
0x1a, 0x9b, 0xc8, 0x6f, 0x1f, 0x71, 0x79, 0xc9, 0x7c, 0x2f, 0x2c, 0x6f, 0x9c, 0xd1, 0xc5, 0xfc,
0x33, 0xca, 0xd7, 0x79, 0xe5, 0x40, 0x98, 0xd6, 0xf8, 0x81, 0x14, 0x32, 0xa7, 0x37, 0x12, 0x8a,
0x1b, 0x0b, 0x59, 0x3b, 0x98, 0x35, 0x7a, 0x1f, 0x18, 0x2d, 0x19, 0x25, 0x46, 0x9d, 0x02, 0x17,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x22, 0x71, 0xda, 0xba, 0x9d, 0x3c, 0xc8, 0xea, 0x11, 0xe9, 0xf8, 0xe0, 0xb2, 0x93, 0x5f, 0xb0,
0xc7, 0x54, 0x26, 0x11, 0x31, 0x1c, 0x1a, 0x09, 0x0d, 0xe0, 0xd2, 0x37, 0xb2, 0x56, 0x59, 0x0e,
0x70, 0xde, 0x53, 0x6d, 0xaa, 0x32, 0xa6, 0x00, 0xec, 0x85, 0x0f, 0x11, 0x48, 0xa5, 0x52, 0x7f,
0x7a, 0x6b, 0xc4, 0x61, 0x3b, 0xc7, 0x1e, 0x13, 0x89, 0x7a, 0x09, 0xe5, 0x32, 0xfc, 0x90, 0xe2,
}), }),
Timestamp: time.Unix(0x5c34c292, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x11, 0xe9, 0xf8, 0xe0, 0xb2, 0x93, 0x5f, 0xb0,
0x0d, 0xe0, 0xd2, 0x37, 0xb2, 0x56, 0x59, 0x0e,
0xec, 0x85, 0x0f, 0x11, 0x48, 0xa5, 0x52, 0x7f,
0x89, 0x7a, 0x09, 0xe5, 0x32, 0xfc, 0x90, 0xe2,
}),
Timestamp: time.Unix(0x5c40a3d8, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffffc, Nonce: 0x7fffffffffffffff,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -184,11 +194,12 @@ var block2 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x52, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x52, 0x08, 0x69, 0x5c, 0x41, 0x65, 0x19, 0xf7,
0xbb, 0xa5, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -198,10 +209,7 @@ var block2 = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },
@ -213,31 +221,16 @@ var block2 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{ TxID: daghash.Hash{
0x80, 0x57, 0x44, 0xf9, 0xee, 0xb7, 0x14, 0x05, 0x71, 0x17, 0x72, 0x40, 0x46, 0x3e, 0x00, 0x87,
0x8c, 0x37, 0x2e, 0x41, 0x82, 0x98, 0xcd, 0x0d, 0x00, 0x55, 0x61, 0xbf, 0x85, 0x88, 0x16, 0x2d,
0xc8, 0xd1, 0xd1, 0x11, 0x9b, 0xe2, 0xc1, 0x4e, 0xe9, 0x75, 0x89, 0x10, 0x8f, 0x27, 0x7c, 0xb6,
0x4b, 0x7c, 0x02, 0xd1, 0x11, 0xe0, 0x50, 0x11, 0xad, 0xea, 0xf8, 0xa3, 0x7e, 0xf2, 0x73, 0x92,
}, },
Index: 0, Index: 0,
}, },
SignatureScript: []byte{ SignatureScript: []byte{},
0x47, 0x30, 0x44, 0x02, 0x20, 0x08, 0x3e, 0x75, Sequence: math.MaxUint64,
0x3e, 0x0a, 0xbc, 0x0b, 0x39, 0x06, 0xf2, 0x2c,
0x99, 0x85, 0xf2, 0xde, 0xa7, 0x83, 0x3e, 0x6b,
0x5a, 0x69, 0x37, 0x51, 0x4c, 0xf8, 0x40, 0x59,
0x4c, 0x2f, 0x50, 0x1c, 0x04, 0x02, 0x20, 0x06,
0x21, 0xd9, 0xde, 0x0c, 0x10, 0xca, 0x9d, 0xa4,
0x5f, 0xe0, 0xfe, 0x3b, 0x33, 0x1d, 0x92, 0x6e,
0xc4, 0x02, 0xe4, 0x3c, 0xd4, 0x3c, 0xea, 0xf8,
0xd8, 0xe5, 0x14, 0x3f, 0x56, 0xe9, 0x5b, 0x01,
0x21, 0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9, 0x58,
0x7c, 0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6, 0x85,
0xc6, 0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3, 0xc6,
0xf2, 0xa7, 0xe9, 0xa4, 0x99, 0x9e, 0x6e, 0x4b,
0xfa, 0xf5,
},
Sequence: math.MaxUint64,
}, },
}, },
TxOut: []*wire.TxOut{ TxOut: []*wire.TxOut{
@ -262,24 +255,24 @@ var block3Tx = &wire.MsgTx{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{ TxID: daghash.Hash{
0x65, 0x63, 0x9f, 0x61, 0x7c, 0xaa, 0xc1, 0x4a, 0x54, 0x87, 0x57, 0x84, 0xed, 0x18, 0xc2, 0xde,
0x96, 0x7d, 0x8a, 0xc0, 0x4b, 0x97, 0xc5, 0xf3, 0x6c, 0xdb, 0x54, 0xfa, 0xab, 0x4f, 0x1f, 0x52,
0x86, 0xbe, 0x54, 0x03, 0x26, 0x00, 0x0c, 0xc5, 0x73, 0x4b, 0xbb, 0x62, 0x79, 0x84, 0x95, 0xbe,
0xd8, 0xbb, 0x75, 0x96, 0x1b, 0xdb, 0xa7, 0x5b, 0x97, 0x0c, 0x55, 0x71, 0xe1, 0x02, 0x24, 0x4c,
}, },
Index: 0, Index: 0,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x48, 0x30, 0x45, 0x02, 0x21, 0x00, 0x94, 0x6a, 0x48, 0x30, 0x45, 0x02, 0x21, 0x00, 0xa4, 0x2c,
0x03, 0xb4, 0xab, 0xc3, 0xce, 0x5f, 0xc9, 0x85, 0xbe, 0x5f, 0x17, 0x6a, 0xd0, 0x66, 0x37, 0xf7,
0xbd, 0xb1, 0xdf, 0x94, 0x26, 0xd0, 0x27, 0x20, 0xfc, 0x64, 0x09, 0x42, 0x51, 0x46, 0x9c, 0x3d,
0x63, 0xdd, 0xd6, 0xd6, 0xce, 0x29, 0xb5, 0xae, 0x86, 0x22, 0xca, 0x2f, 0x15, 0xe3, 0x45, 0xc6,
0x91, 0x50, 0x57, 0x18, 0xc3, 0x26, 0x02, 0x20, 0x1c, 0xeb, 0x73, 0xe5, 0x51, 0xbd, 0x02, 0x20,
0x56, 0x99, 0xa2, 0x8a, 0xbb, 0x2f, 0xfe, 0x09, 0x28, 0x56, 0xd5, 0xd6, 0x5b, 0x6f, 0x1f, 0x35,
0x11, 0x54, 0x42, 0xa7, 0xb3, 0x52, 0x35, 0xf8, 0xd2, 0x07, 0x94, 0x1e, 0x8f, 0x1b, 0x1a, 0x9e,
0xa4, 0x3e, 0x01, 0x61, 0xfa, 0xb9, 0x09, 0x6d, 0x03, 0x98, 0xcd, 0xa1, 0x23, 0x7c, 0x14, 0x51,
0x48, 0x38, 0xa7, 0xc1, 0xfd, 0x6f, 0x9e, 0x5b, 0x53, 0x33, 0xad, 0xec, 0x8b, 0xaa, 0x4f, 0x14,
0x01, 0x21, 0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9, 0x01, 0x21, 0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9,
0x58, 0x7c, 0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6, 0x58, 0x7c, 0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6,
0x85, 0xc6, 0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3, 0x85, 0xc6, 0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3,
@ -306,24 +299,30 @@ var block3Tx = &wire.MsgTx{
var block3 = wire.MsgBlock{ var block3 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0x41, 0x27, 0x85, 0x25, 0x0e, 0x8e, 0xdb, 0xf3, 0x33, 0x17, 0x9f, 0x65, 0x01, 0x21, 0x7e, 0x31,
0xb5, 0xdd, 0xfa, 0xb9, 0x75, 0xc0, 0x4f, 0xe8, 0x98, 0xbe, 0xf1, 0xc1, 0xdc, 0x07, 0xbe, 0xfc,
0x88, 0xff, 0x04, 0x08, 0xe9, 0x0a, 0x93, 0x8f, 0x18, 0xda, 0xe9, 0xbd, 0x21, 0xe5, 0x25, 0xca,
0x45, 0x04, 0x03, 0x73, 0xc6, 0x24, 0x08, 0x72, 0xd5, 0xd0, 0x80, 0x98, 0x7a, 0x18, 0x3d, 0x7d,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x93, 0x9b, 0x93, 0x78, 0x9f, 0xca, 0x8c, 0xab, 0xfa, 0xf7, 0xe5, 0x64, 0x92, 0x8e, 0x6d, 0x38,
0x73, 0x04, 0x64, 0x01, 0xc9, 0x4f, 0x67, 0xf4, 0xc7, 0xd6, 0x57, 0xd8, 0x61, 0x1a, 0x04, 0x7b,
0xb7, 0x6f, 0x0f, 0xd4, 0x0a, 0xe9, 0x77, 0x81, 0x94, 0x49, 0xfa, 0xca, 0x34, 0x36, 0xfc, 0x3b,
0xa7, 0x18, 0xf8, 0x60, 0xe8, 0x20, 0x45, 0xf2, 0x04, 0x7e, 0xf4, 0x2c, 0x14, 0x0a, 0x34, 0x12,
}), }),
Timestamp: time.Unix(0x5c34c293, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x5a, 0xdf, 0x78, 0x58, 0xb8, 0xb0, 0x3e, 0xe4,
0xd5, 0x8f, 0xee, 0xb7, 0xe1, 0xd8, 0x9f, 0xe5,
0xab, 0x1d, 0xb3, 0x82, 0xc8, 0xb4, 0xa7, 0xf9,
0xda, 0x3c, 0x11, 0xf5, 0xb2, 0xd2, 0x48, 0x91,
}),
Timestamp: time.Unix(0x5c40a3d9, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9, Nonce: 0x9ffffffffffffffb,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -331,11 +330,12 @@ var block3 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x53, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x53, 0x08, 0xde, 0x55, 0x3f, 0x10, 0x5c, 0x48,
0x05, 0xa6, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -345,10 +345,7 @@ var block3 = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },
@ -361,24 +358,30 @@ var block3 = wire.MsgBlock{
var block3A = wire.MsgBlock{ var block3A = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0x41, 0x27, 0x85, 0x25, 0x0e, 0x8e, 0xdb, 0xf3, 0x33, 0x17, 0x9f, 0x65, 0x01, 0x21, 0x7e, 0x31,
0xb5, 0xdd, 0xfa, 0xb9, 0x75, 0xc0, 0x4f, 0xe8, 0x98, 0xbe, 0xf1, 0xc1, 0xdc, 0x07, 0xbe, 0xfc,
0x88, 0xff, 0x04, 0x08, 0xe9, 0x0a, 0x93, 0x8f, 0x18, 0xda, 0xe9, 0xbd, 0x21, 0xe5, 0x25, 0xca,
0x45, 0x04, 0x03, 0x73, 0xc6, 0x24, 0x08, 0x72, 0xd5, 0xd0, 0x80, 0x98, 0x7a, 0x18, 0x3d, 0x7d,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x47, 0xb6, 0x23, 0x3a, 0x59, 0xf7, 0x51, 0x40, 0x6d, 0x9f, 0xe0, 0xda, 0xde, 0xb2, 0xec, 0x69,
0x41, 0x2e, 0xf1, 0xa3, 0x35, 0xa6, 0x19, 0xa1, 0x9a, 0x06, 0x79, 0x97, 0xf5, 0xed, 0x03, 0xde,
0x89, 0x33, 0x0b, 0x02, 0x29, 0x3f, 0x8f, 0x35, 0x47, 0x6c, 0x58, 0x4a, 0xc4, 0xdf, 0x9d, 0x00,
0x92, 0x75, 0x80, 0x61, 0x37, 0x3e, 0x6e, 0x54, 0x42, 0x79, 0xf9, 0x1f, 0xaa, 0xc0, 0xca, 0x36,
}), }),
Timestamp: time.Unix(0x5c34c293, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x5e, 0x0d, 0xbd, 0xaf, 0xaa, 0x46, 0x72, 0x13,
0xfa, 0xe2, 0x9a, 0x1b, 0x87, 0xd9, 0xf7, 0xe4,
0x3c, 0x23, 0xcd, 0x8b, 0x2f, 0xe5, 0xe4, 0x40,
0xb1, 0x6d, 0x24, 0x64, 0xa6, 0xbb, 0x70, 0x6b,
}),
Timestamp: time.Unix(0x5c40a3d9, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffffc, Nonce: 0x5fffffffffffffff,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -386,11 +389,12 @@ var block3A = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x53, 0x51, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x53, 0x08, 0x92, 0xd8, 0x47, 0x56, 0xe7, 0xa1,
0x62, 0x0c, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -400,10 +404,7 @@ var block3A = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },
@ -416,24 +417,30 @@ var block3A = wire.MsgBlock{
var block4 = wire.MsgBlock{ var block4 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0xf9, 0x3e, 0x6e, 0x3f, 0x22, 0x4b, 0x36, 0xfc, 0x13, 0xa4, 0x23, 0x8f, 0xd8, 0xb3, 0x6c, 0xd6,
0x9b, 0xb4, 0xd1, 0x44, 0xbc, 0x62, 0x78, 0xa0, 0x74, 0x01, 0x88, 0xa3, 0xa6, 0xee, 0x84, 0xa3,
0x2f, 0xef, 0xcc, 0x16, 0xc5, 0x42, 0xbe, 0x59, 0x12, 0x80, 0x34, 0x0e, 0x44, 0x33, 0x19, 0xac,
0x22, 0xfe, 0xec, 0x01, 0x55, 0x03, 0x34, 0x62, 0xad, 0xb1, 0x60, 0x9e, 0xda, 0x6d, 0xf5, 0x78,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x79, 0xa0, 0x0e, 0xd0, 0xaa, 0x17, 0x4e, 0xec, 0xd6, 0xb3, 0x42, 0x13, 0x0a, 0x6e, 0x7e, 0x9c,
0x73, 0xd3, 0xcf, 0x13, 0x7f, 0x0d, 0x1d, 0xee, 0x5d, 0xc4, 0xe5, 0x0e, 0x2c, 0x56, 0x5a, 0xc2,
0x63, 0x56, 0x3c, 0x2e, 0x17, 0x19, 0x5a, 0x3e, 0xc7, 0x60, 0x7d, 0x0c, 0x60, 0x4e, 0xb7, 0x73,
0x8b, 0xd2, 0x99, 0xa4, 0xaf, 0xf9, 0xe6, 0x1e, 0x74, 0x6b, 0x56, 0xba, 0xc8, 0x04, 0xa8, 0xc5,
}), }),
Timestamp: time.Unix(0x5c34c294, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xd6, 0xb3, 0x42, 0x13, 0x0a, 0x6e, 0x7e, 0x9c,
0x5d, 0xc4, 0xe5, 0x0e, 0x2c, 0x56, 0x5a, 0xc2,
0xc7, 0x60, 0x7d, 0x0c, 0x60, 0x4e, 0xb7, 0x73,
0x74, 0x6b, 0x56, 0xba, 0xc8, 0x04, 0xa8, 0xc5,
}),
Timestamp: time.Unix(0x5c40a3da, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffffa, Nonce: 0x00000000,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -441,11 +448,12 @@ var block4 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x54, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x54, 0x08, 0xb7, 0xec, 0xdb, 0xbe, 0xbc, 0xc0,
0x18, 0x8f, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -455,10 +463,7 @@ var block4 = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },
@ -470,30 +475,36 @@ var block4 = wire.MsgBlock{
var block5 = wire.MsgBlock{ var block5 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0xe6, 0x08, 0x3c, 0x96, 0x4f, 0x4c, 0xb5, 0x37, 0x7d, 0x9c, 0xc8, 0x5e, 0xa2, 0x47, 0x8c, 0x7d,
0x2d, 0xd6, 0xe0, 0xe0, 0x85, 0x1a, 0x97, 0x0b, 0x5c, 0x0a, 0x7c, 0x9c, 0x97, 0x56, 0x90, 0x17,
0x22, 0x91, 0x13, 0x80, 0x3b, 0xd1, 0xc8, 0x3d, 0xfe, 0x52, 0x6a, 0xc5, 0x37, 0x3c, 0x52, 0x20,
0x8f, 0x77, 0xd5, 0xd4, 0x39, 0xc4, 0x9a, 0x09, 0xdd, 0x3d, 0xe9, 0xc4, 0xd7, 0x0e, 0x26, 0x05,
}, },
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0xfd, 0x28, 0x66, 0x62, 0x56, 0x3e, 0xf0, 0x33, 0xfd, 0xe7, 0x8c, 0x81, 0x79, 0xe5, 0x2d, 0x6a,
0x85, 0xca, 0xf6, 0x96, 0x0d, 0x3a, 0x73, 0xd1, 0xea, 0x0a, 0x8e, 0x4c, 0xa2, 0xbb, 0xe5, 0x52,
0x3b, 0xb8, 0xa0, 0xda, 0xae, 0x4d, 0xdc, 0xa6, 0x19, 0x26, 0x2b, 0xdb, 0xf1, 0x0c, 0x7a, 0x69,
0x56, 0x82, 0xfd, 0x3b, 0xa0, 0x92, 0x27, 0x38, 0x29, 0x75, 0x4a, 0x45, 0x62, 0x53, 0x17, 0x16,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x29, 0xc6, 0xbc, 0xd9, 0xac, 0x1d, 0x4a, 0x5e, 0x8b, 0xb6, 0x91, 0xae, 0xb8, 0x46, 0xea, 0x5b,
0xb0, 0x71, 0xfd, 0xac, 0xde, 0x39, 0xc0, 0x9c, 0xb2, 0x7d, 0xec, 0xd7, 0x38, 0x47, 0xc3, 0xa4,
0x90, 0xb8, 0x22, 0xde, 0x2d, 0x76, 0x49, 0xab, 0x7e, 0xb0, 0x35, 0x02, 0x6a, 0x99, 0x6f, 0x3f,
0x80, 0xdc, 0x77, 0xa8, 0xd7, 0x75, 0x40, 0x18, 0xc3, 0xe3, 0x17, 0xfb, 0x4b, 0xe1, 0x1f, 0x54,
}), }),
Timestamp: time.Unix(0x5c34c295, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x8b, 0xb6, 0x91, 0xae, 0xb8, 0x46, 0xea, 0x5b,
0xb2, 0x7d, 0xec, 0xd7, 0x38, 0x47, 0xc3, 0xa4,
0x7e, 0xb0, 0x35, 0x02, 0x6a, 0x99, 0x6f, 0x3f,
0xc3, 0xe3, 0x17, 0xfb, 0x4b, 0xe1, 0x1f, 0x54,
}),
Timestamp: time.Unix(0x5c40a3db, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0xdffffffffffffffa, Nonce: 0x00000000,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -501,11 +512,12 @@ var block5 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x55, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x55, 0x08, 0xbf, 0x16, 0xe4, 0x0a, 0x63, 0x72,
0x11, 0xaf, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
@ -515,10 +527,7 @@ var block5 = wire.MsgBlock{
{ {
Value: 5000000000, Value: 5000000000,
PkScript: []byte{ PkScript: []byte{
0x76, 0xa9, 0x14, 0x3d, 0xee, 0x47, 0x71, 0x6e, 0x51,
0x3c, 0xfa, 0x57, 0xdf, 0x45, 0x11, 0x34, 0x73,
0xa6, 0x31, 0x2e, 0xbe, 0xae, 0xf3, 0x11, 0x88,
0xac,
}, },
}, },
}, },

40
blockdag/merkle.go
View File

@ -11,6 +11,14 @@ import (
"github.com/daglabs/btcd/util" "github.com/daglabs/btcd/util"
) )
// MerkleTree holds the hashes of a merkle tree
type MerkleTree []*daghash.Hash
// Root returns the root of the merkle tree
func (mt MerkleTree) Root() *daghash.Hash {
return mt[len(mt)-1]
}
// nextPowerOfTwo returns the next highest power of two from a given number if // nextPowerOfTwo returns the next highest power of two from a given number if
// it is not already a power of two. This is a helper function used during the // it is not already a power of two. This is a helper function used during the
// calculation of a merkle tree. // calculation of a merkle tree.
@ -38,7 +46,27 @@ func HashMerkleBranches(left *daghash.Hash, right *daghash.Hash) *daghash.Hash {
return &newHash return &newHash
} }
// BuildMerkleTreeStore creates a merkle tree from a slice of transactions, // BuildHashMerkleTreeStore creates a merkle tree from a slice of transactions, based
// on their hash. See `buildMerkleTreeStore` for more info.
func BuildHashMerkleTreeStore(transactions []*util.Tx) MerkleTree {
txHashes := make([]*daghash.Hash, len(transactions))
for i, tx := range transactions {
txHashes[i] = tx.Hash()
}
return buildMerkleTreeStore(txHashes)
}
// BuildIDMerkleTreeStore creates a merkle tree from a slice of transactions, based
// on their ID. See `buildMerkleTreeStore` for more info.
func BuildIDMerkleTreeStore(transactions []*util.Tx) MerkleTree {
txIDs := make([]*daghash.Hash, len(transactions))
for i, tx := range transactions {
txIDs[i] = tx.ID()
}
return buildMerkleTreeStore(txIDs)
}
// buildMerkleTreeStore creates a merkle tree from a slice of hashes,
// stores it using a linear array, and returns a slice of the backing array. A // stores it using a linear array, and returns a slice of the backing array. A
// linear array was chosen as opposed to an actual tree structure since it uses // linear array was chosen as opposed to an actual tree structure since it uses
// about half as much memory. The following describes a merkle tree and how it // about half as much memory. The following describes a merkle tree and how it
@ -66,16 +94,16 @@ func HashMerkleBranches(left *daghash.Hash, right *daghash.Hash) *daghash.Hash {
// are calculated by concatenating the left node with itself before hashing. // are calculated by concatenating the left node with itself before hashing.
// Since this function uses nodes that are pointers to the hashes, empty nodes // Since this function uses nodes that are pointers to the hashes, empty nodes
// will be nil. // will be nil.
func BuildMerkleTreeStore(transactions []*util.Tx) []*daghash.Hash { func buildMerkleTreeStore(hashes []*daghash.Hash) MerkleTree {
// Calculate how many entries are required to hold the binary merkle // Calculate how many entries are required to hold the binary merkle
// tree as a linear array and create an array of that size. // tree as a linear array and create an array of that size.
nextPoT := nextPowerOfTwo(len(transactions)) nextPoT := nextPowerOfTwo(len(hashes))
arraySize := nextPoT*2 - 1 arraySize := nextPoT*2 - 1
merkles := make([]*daghash.Hash, arraySize) merkles := make(MerkleTree, arraySize)
// Create the base transaction hashes and populate the array with them. // Create the base transaction hashes and populate the array with them.
for i, tx := range transactions { for i, hash := range hashes {
merkles[i] = tx.Hash() merkles[i] = hash
} }
// Start the array offset after the last transaction and adjusted to the // Start the array offset after the last transaction and adjusted to the

23
blockdag/merkle_test.go
View File

@ -10,14 +10,23 @@ import (
"github.com/daglabs/btcd/util" "github.com/daglabs/btcd/util"
) )
// TestMerkle tests the BuildMerkleTreeStore API. // TestMerkle tests the BuildHashMerkleTreeStore API.
func TestMerkle(t *testing.T) { func TestMerkle(t *testing.T) {
block := util.NewBlock(&Block100000) block := util.NewBlock(&Block100000)
merkles := BuildMerkleTreeStore(block.Transactions())
calculatedMerkleRoot := merkles[len(merkles)-1] hashMerkleTree := BuildHashMerkleTreeStore(block.Transactions())
wantMerkle := &Block100000.Header.MerkleRoot calculatedHashMerkleRoot := hashMerkleTree.Root()
if !wantMerkle.IsEqual(calculatedMerkleRoot) { wantHashMerkleRoot := &Block100000.Header.HashMerkleRoot
t.Errorf("BuildMerkleTreeStore: merkle root mismatch - "+ if !wantHashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
"got %v, want %v", calculatedMerkleRoot, wantMerkle) t.Errorf("BuildHashMerkleTreeStore: hash merkle root mismatch - "+
"got %v, want %v", calculatedHashMerkleRoot, wantHashMerkleRoot)
}
idMerkleTree := BuildIDMerkleTreeStore(block.Transactions())
calculatedIDMerkleRoot := idMerkleTree.Root()
wantIDMerkleRoot := &Block100000.Header.IDMerkleRoot
if !wantIDMerkleRoot.IsEqual(calculatedIDMerkleRoot) {
t.Errorf("BuildIDMerkleTreeStore: ID merkle root mismatch - "+
"got %v, want %v", calculatedIDMerkleRoot, wantIDMerkleRoot)
} }
} }

6
blockdag/scriptval.go
View File

@ -60,7 +60,7 @@ out:
str := fmt.Sprintf("unable to find unspent "+ str := fmt.Sprintf("unable to find unspent "+
"output %v referenced from "+ "output %v referenced from "+
"transaction %s:%d", "transaction %s:%d",
txIn.PreviousOutPoint, txVI.tx.Hash(), txIn.PreviousOutPoint, txVI.tx.ID(),
txVI.txInIndex) txVI.txInIndex)
err := ruleError(ErrMissingTxOut, str) err := ruleError(ErrMissingTxOut, str)
v.sendResult(err) v.sendResult(err)
@ -77,7 +77,7 @@ out:
"%s:%d which references output %v - "+ "%s:%d which references output %v - "+
"%v (input script bytes %x, prev "+ "%v (input script bytes %x, prev "+
"output script bytes %x)", "output script bytes %x)",
txVI.tx.Hash(), txVI.txInIndex, txVI.tx.ID(), txVI.txInIndex,
txIn.PreviousOutPoint, err, sigScript, pkScript) txIn.PreviousOutPoint, err, sigScript, pkScript)
err := ruleError(ErrScriptMalformed, str) err := ruleError(ErrScriptMalformed, str)
v.sendResult(err) v.sendResult(err)
@ -90,7 +90,7 @@ out:
"%s:%d which references output %v - "+ "%s:%d which references output %v - "+
"%v (input script bytes %x, prev output "+ "%v (input script bytes %x, prev output "+
"script bytes %x)", "script bytes %x)",
txVI.tx.Hash(), txVI.txInIndex, txVI.tx.ID(), txVI.txInIndex,
txIn.PreviousOutPoint, err, sigScript, pkScript) txIn.PreviousOutPoint, err, sigScript, pkScript)
err := ruleError(ErrScriptValidation, str) err := ruleError(ErrScriptValidation, str)
v.sendResult(err) v.sendResult(err)

1
blockdag/scriptval_test.go
View File

@ -15,6 +15,7 @@ import (
// TestCheckBlockScripts ensures that validating the all of the scripts in a // TestCheckBlockScripts ensures that validating the all of the scripts in a
// known-good block doesn't return an error. // known-good block doesn't return an error.
func TestCheckBlockScripts(t *testing.T) { func TestCheckBlockScripts(t *testing.T) {
t.Skip() // TODO: Reactivate this test once we have blocks from testnet.
runtime.GOMAXPROCS(runtime.NumCPU()) runtime.GOMAXPROCS(runtime.NumCPU())
testBlockNum := 277647 testBlockNum := 277647

BIN
blockdag/testdata/blk_0_to_4.dat vendored
View File

Binary file not shown.

BIN
blockdag/testdata/blk_3A.dat vendored
View File

Binary file not shown.

BIN
blockdag/testdata/blk_3B.dat vendored
View File

Binary file not shown.

BIN
blockdag/testdata/blk_3C.dat vendored
View File

Binary file not shown.

BIN
blockdag/testdata/blk_3D.dat vendored
View File

Binary file not shown.

26
blockdag/utxoset.go
View File

@ -83,7 +83,7 @@ func (uc utxoCollection) String() string {
i := 0 i := 0
for outPoint, utxoEntry := range uc { for outPoint, utxoEntry := range uc {
utxoStrings[i] = fmt.Sprintf("(%s, %d) => %d", outPoint.Hash, outPoint.Index, utxoEntry.amount) utxoStrings[i] = fmt.Sprintf("(%s, %d) => %d", outPoint.TxID, outPoint.Index, utxoEntry.amount)
i++ i++
} }
@ -304,7 +304,7 @@ func (d *UTXODiff) clone() *UTXODiff {
//RemoveTxOuts marks the transaction's outputs to removal //RemoveTxOuts marks the transaction's outputs to removal
func (d *UTXODiff) RemoveTxOuts(tx *wire.MsgTx) { func (d *UTXODiff) RemoveTxOuts(tx *wire.MsgTx) {
for idx := range tx.TxOut { for idx := range tx.TxOut {
hash := tx.TxHash() hash := tx.TxID()
d.toRemove.add(*wire.NewOutPoint(&hash, uint32(idx)), nil) d.toRemove.add(*wire.NewOutPoint(&hash, uint32(idx)), nil)
} }
} }
@ -361,7 +361,7 @@ type UTXOSet interface {
// or an error if provided transaction is not valid in the context of this UTXOSet // or an error if provided transaction is not valid in the context of this UTXOSet
func diffFromTx(u UTXOSet, tx *wire.MsgTx, containingNode *blockNode) (*UTXODiff, error) { func diffFromTx(u UTXOSet, tx *wire.MsgTx, containingNode *blockNode) (*UTXODiff, error) {
diff := NewUTXODiff() diff := NewUTXODiff()
isCoinbase := IsCoinBaseTx(tx) isCoinbase := tx.IsCoinBase()
if !isCoinbase { if !isCoinbase {
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
if entry, ok := u.Get(txIn.PreviousOutPoint); ok { if entry, ok := u.Get(txIn.PreviousOutPoint); ok {
@ -369,12 +369,12 @@ func diffFromTx(u UTXOSet, tx *wire.MsgTx, containingNode *blockNode) (*UTXODiff
} else { } else {
return nil, ruleError(ErrMissingTxOut, fmt.Sprintf( return nil, ruleError(ErrMissingTxOut, fmt.Sprintf(
"Transaction %s is invalid because spends outpoint %s that is not in utxo set", "Transaction %s is invalid because spends outpoint %s that is not in utxo set",
tx.TxHash(), txIn.PreviousOutPoint)) tx.TxID(), txIn.PreviousOutPoint))
} }
} }
} }
for i, txOut := range tx.TxOut { for i, txOut := range tx.TxOut {
hash := tx.TxHash() hash := tx.TxID()
entry := NewUTXOEntry(txOut, isCoinbase, containingNode.height) entry := NewUTXOEntry(txOut, isCoinbase, containingNode.height)
outPoint := *wire.NewOutPoint(&hash, uint32(i)) outPoint := *wire.NewOutPoint(&hash, uint32(i))
diff.toAdd.add(outPoint, entry) diff.toAdd.add(outPoint, entry)
@ -416,20 +416,20 @@ func (fus *FullUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
// AddTx adds a transaction to this utxoSet and returns true iff it's valid in this UTXO's context // AddTx adds a transaction to this utxoSet and returns true iff it's valid in this UTXO's context
func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool { func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool {
isCoinbase := IsCoinBaseTx(tx) isCoinbase := tx.IsCoinBase()
if !isCoinbase { if !isCoinbase {
if !fus.containsInputs(tx) { if !fus.containsInputs(tx) {
return false return false
} }
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.Hash, txIn.PreviousOutPoint.Index) outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.TxID, txIn.PreviousOutPoint.Index)
fus.remove(outPoint) fus.remove(outPoint)
} }
} }
for i, txOut := range tx.TxOut { for i, txOut := range tx.TxOut {
hash := tx.TxHash() hash := tx.TxID()
outPoint := *wire.NewOutPoint(&hash, uint32(i)) outPoint := *wire.NewOutPoint(&hash, uint32(i))
entry := NewUTXOEntry(txOut, isCoinbase, blockHeight) entry := NewUTXOEntry(txOut, isCoinbase, blockHeight)
@ -447,7 +447,7 @@ func (fus *FullUTXOSet) diffFromTx(tx *wire.MsgTx, node *blockNode) (*UTXODiff,
func (fus *FullUTXOSet) containsInputs(tx *wire.MsgTx) bool { func (fus *FullUTXOSet) containsInputs(tx *wire.MsgTx) bool {
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.Hash, txIn.PreviousOutPoint.Index) outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.TxID, txIn.PreviousOutPoint.Index)
if !fus.contains(outPoint) { if !fus.contains(outPoint) {
return false return false
} }
@ -508,7 +508,7 @@ func (dus *DiffUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
// AddTx adds a transaction to this utxoSet and returns true iff it's valid in this UTXO's context // AddTx adds a transaction to this utxoSet and returns true iff it's valid in this UTXO's context
func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool { func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool {
isCoinBase := IsCoinBaseTx(tx) isCoinBase := tx.IsCoinBase()
if !isCoinBase && !dus.containsInputs(tx) { if !isCoinBase && !dus.containsInputs(tx) {
return false return false
} }
@ -522,7 +522,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockHeight int32, isCoinBase b
if !isCoinBase { if !isCoinBase {
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.Hash, txIn.PreviousOutPoint.Index) outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.TxID, txIn.PreviousOutPoint.Index)
if dus.UTXODiff.toAdd.contains(outPoint) { if dus.UTXODiff.toAdd.contains(outPoint) {
dus.UTXODiff.toAdd.remove(outPoint) dus.UTXODiff.toAdd.remove(outPoint)
} else { } else {
@ -533,7 +533,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockHeight int32, isCoinBase b
} }
for i, txOut := range tx.TxOut { for i, txOut := range tx.TxOut {
hash := tx.TxHash() hash := tx.TxID()
outPoint := *wire.NewOutPoint(&hash, uint32(i)) outPoint := *wire.NewOutPoint(&hash, uint32(i))
entry := NewUTXOEntry(txOut, isCoinBase, blockHeight) entry := NewUTXOEntry(txOut, isCoinBase, blockHeight)
@ -547,7 +547,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockHeight int32, isCoinBase b
func (dus *DiffUTXOSet) containsInputs(tx *wire.MsgTx) bool { func (dus *DiffUTXOSet) containsInputs(tx *wire.MsgTx) bool {
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.Hash, txIn.PreviousOutPoint.Index) outPoint := *wire.NewOutPoint(&txIn.PreviousOutPoint.TxID, txIn.PreviousOutPoint.Index)
isInBase := dus.base.contains(outPoint) isInBase := dus.base.contains(outPoint)
isInDiffToAdd := dus.UTXODiff.toAdd.contains(outPoint) isInDiffToAdd := dus.UTXODiff.toAdd.contains(outPoint)
isInDiffToRemove := dus.UTXODiff.toRemove.contains(outPoint) isInDiffToRemove := dus.UTXODiff.toRemove.contains(outPoint)

34
blockdag/utxoset_test.go
View File

@ -360,7 +360,7 @@ func TestFullUTXOSet(t *testing.T) {
} }
// Test fullUTXOSet addTx // Test fullUTXOSet addTx
txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: *hash0, Index: 0}, Sequence: 0} txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *hash0, Index: 0}, Sequence: 0}
transaction0 := wire.NewMsgTx(1) transaction0 := wire.NewMsgTx(1)
transaction0.TxIn = []*wire.TxIn{txIn0} transaction0.TxIn = []*wire.TxIn{txIn0}
transaction0.TxOut = []*wire.TxOut{txOut0} transaction0.TxOut = []*wire.TxOut{txOut0}
@ -635,7 +635,7 @@ func TestUTXOSetDiffRules(t *testing.T) {
func TestDiffUTXOSet_addTx(t *testing.T) { func TestDiffUTXOSet_addTx(t *testing.T) {
// transaction0 is coinbase. As such, it has exactly one input with hash zero and MaxUInt32 index // transaction0 is coinbase. As such, it has exactly one input with hash zero and MaxUInt32 index
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: *hash0, Index: math.MaxUint32}, Sequence: 0} txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *hash0, Index: math.MaxUint32}, Sequence: 0}
txOut0 := &wire.TxOut{PkScript: []byte{0}, Value: 10} txOut0 := &wire.TxOut{PkScript: []byte{0}, Value: 10}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0) utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
transaction0 := wire.NewMsgTx(1) transaction0 := wire.NewMsgTx(1)
@ -643,9 +643,9 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction0.TxOut = []*wire.TxOut{txOut0} transaction0.TxOut = []*wire.TxOut{txOut0}
// transaction1 spends transaction0 // transaction1 spends transaction0
hash1 := transaction0.TxHash() id1 := transaction0.TxID()
outPoint1 := *wire.NewOutPoint(&hash1, 0) outPoint1 := *wire.NewOutPoint(&id1, 0)
txIn1 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: hash1, Index: 0}, Sequence: 0} txIn1 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: id1, Index: 0}, Sequence: 0}
txOut1 := &wire.TxOut{PkScript: []byte{1}, Value: 20} txOut1 := &wire.TxOut{PkScript: []byte{1}, Value: 20}
utxoEntry1 := NewUTXOEntry(txOut1, false, 1) utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
transaction1 := wire.NewMsgTx(1) transaction1 := wire.NewMsgTx(1)
@ -653,9 +653,9 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction1.TxOut = []*wire.TxOut{txOut1} transaction1.TxOut = []*wire.TxOut{txOut1}
// transaction2 spends transaction1 // transaction2 spends transaction1
hash2 := transaction1.TxHash() id2 := transaction1.TxID()
outPoint2 := *wire.NewOutPoint(&hash2, 0) outPoint2 := *wire.NewOutPoint(&id2, 0)
txIn2 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: hash2, Index: 0}, Sequence: 0} txIn2 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: id2, Index: 0}, Sequence: 0}
txOut2 := &wire.TxOut{PkScript: []byte{2}, Value: 30} txOut2 := &wire.TxOut{PkScript: []byte{2}, Value: 30}
utxoEntry2 := NewUTXOEntry(txOut2, false, 2) utxoEntry2 := NewUTXOEntry(txOut2, false, 2)
transaction2 := wire.NewMsgTx(1) transaction2 := wire.NewMsgTx(1)
@ -663,8 +663,8 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction2.TxOut = []*wire.TxOut{txOut2} transaction2.TxOut = []*wire.TxOut{txOut2}
// outpoint3 is the outpoint for transaction2 // outpoint3 is the outpoint for transaction2
hash3 := transaction2.TxHash() id3 := transaction2.TxID()
outPoint3 := *wire.NewOutPoint(&hash3, 0) outPoint3 := *wire.NewOutPoint(&id3, 0)
// For each of the following test cases, we will: // For each of the following test cases, we will:
// 1. startSet.addTx() all the transactions in toAdd, in order, with the initial block height startHeight // 1. startSet.addTx() all the transactions in toAdd, in order, with the initial block height startHeight
@ -822,7 +822,7 @@ func TestApplyUTXOChanges(t *testing.T) {
chainedTx := wire.NewMsgTx(wire.TxVersion) chainedTx := wire.NewMsgTx(wire.TxVersion)
chainedTx.AddTxIn(&wire.TxIn{ chainedTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{Hash: cbTx.TxHash(), Index: 0}, PreviousOutPoint: wire.OutPoint{TxID: cbTx.TxID(), Index: 0},
SignatureScript: nil, SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}) })
@ -832,7 +832,7 @@ func TestApplyUTXOChanges(t *testing.T) {
}) })
//Fake block header //Fake block header
blockHeader := wire.NewBlockHeader(1, []daghash.Hash{dag.genesis.hash}, &daghash.Hash{}, 0, 0) blockHeader := wire.NewBlockHeader(1, []daghash.Hash{dag.genesis.hash}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)
msgBlock1 := &wire.MsgBlock{ msgBlock1 := &wire.MsgBlock{
Header: *blockHeader, Header: *blockHeader,
@ -852,7 +852,7 @@ func TestApplyUTXOChanges(t *testing.T) {
nonChainedTx := wire.NewMsgTx(wire.TxVersion) nonChainedTx := wire.NewMsgTx(wire.TxVersion)
nonChainedTx.AddTxIn(&wire.TxIn{ nonChainedTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{Hash: dag.dagParams.GenesisBlock.Transactions[0].TxHash(), Index: 0}, PreviousOutPoint: wire.OutPoint{TxID: dag.dagParams.GenesisBlock.Transactions[0].TxID(), Index: 0},
SignatureScript: nil, //Fake SigScript, because we don't check scripts validity in this test SignatureScript: nil, //Fake SigScript, because we don't check scripts validity in this test
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}) })
@ -888,7 +888,7 @@ func TestDiffFromTx(t *testing.T) {
} }
fus.AddTx(cbTx, 1) fus.AddTx(cbTx, 1)
node := &blockNode{height: 2} //Fake node node := &blockNode{height: 2} //Fake node
cbOutpoint := wire.OutPoint{Hash: cbTx.TxHash(), Index: 0} cbOutpoint := wire.OutPoint{TxID: cbTx.TxID(), Index: 0}
tx := wire.NewMsgTx(wire.TxVersion) tx := wire.NewMsgTx(wire.TxVersion)
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
PreviousOutPoint: cbOutpoint, PreviousOutPoint: cbOutpoint,
@ -904,13 +904,13 @@ func TestDiffFromTx(t *testing.T) {
t.Errorf("diffFromTx: %v", err) t.Errorf("diffFromTx: %v", err)
} }
if !reflect.DeepEqual(diff.toAdd, utxoCollection{ if !reflect.DeepEqual(diff.toAdd, utxoCollection{
wire.OutPoint{Hash: tx.TxHash(), Index: 0}: NewUTXOEntry(tx.TxOut[0], false, 2), wire.OutPoint{TxID: tx.TxID(), Index: 0}: NewUTXOEntry(tx.TxOut[0], false, 2),
}) { }) {
t.Errorf("diff.toAdd doesn't have the expected values") t.Errorf("diff.toAdd doesn't have the expected values")
} }
if !reflect.DeepEqual(diff.toRemove, utxoCollection{ if !reflect.DeepEqual(diff.toRemove, utxoCollection{
wire.OutPoint{Hash: cbTx.TxHash(), Index: 0}: NewUTXOEntry(cbTx.TxOut[0], true, 1), wire.OutPoint{TxID: cbTx.TxID(), Index: 0}: NewUTXOEntry(cbTx.TxOut[0], true, 1),
}) { }) {
t.Errorf("diff.toRemove doesn't have the expected values") t.Errorf("diff.toRemove doesn't have the expected values")
} }
@ -918,7 +918,7 @@ func TestDiffFromTx(t *testing.T) {
//Test that we get an error if we don't have the outpoint inside the utxo set //Test that we get an error if we don't have the outpoint inside the utxo set
invalidTx := wire.NewMsgTx(wire.TxVersion) invalidTx := wire.NewMsgTx(wire.TxVersion)
invalidTx.AddTxIn(&wire.TxIn{ invalidTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0}, PreviousOutPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
SignatureScript: nil, SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}) })

73
blockdag/validate.go
View File

@ -59,36 +59,12 @@ var (
// isNullOutpoint determines whether or not a previous transaction output point // isNullOutpoint determines whether or not a previous transaction output point
// is set. // is set.
func isNullOutpoint(outpoint *wire.OutPoint) bool { func isNullOutpoint(outpoint *wire.OutPoint) bool {
if outpoint.Index == math.MaxUint32 && outpoint.Hash == zeroHash { if outpoint.Index == math.MaxUint32 && outpoint.TxID == zeroHash {
return true return true
} }
return false return false
} }
// IsCoinBaseTx determines whether or not a transaction is a coinbase. A coinbase
// is a special transaction created by miners that has no inputs. This is
// represented in the block dag by a transaction with a single input that has
// a previous output transaction index set to the maximum value along with a
// zero hash.
//
// This function only differs from IsCoinBase in that it works with a raw wire
// transaction as opposed to a higher level util transaction.
func IsCoinBaseTx(msgTx *wire.MsgTx) bool {
// A coin base must only have one transaction input.
if len(msgTx.TxIn) != 1 {
return false
}
// The previous output of a coin base must have a max value index and
// a zero hash.
prevOut := &msgTx.TxIn[0].PreviousOutPoint
if prevOut.Index != math.MaxUint32 || prevOut.Hash != zeroHash {
return false
}
return true
}
// IsCoinBase determines whether or not a transaction is a coinbase. A coinbase // IsCoinBase determines whether or not a transaction is a coinbase. A coinbase
// is a special transaction created by miners that has no inputs. This is // is a special transaction created by miners that has no inputs. This is
// represented in the block dag by a transaction with a single input that has // represented in the block dag by a transaction with a single input that has
@ -98,7 +74,7 @@ func IsCoinBaseTx(msgTx *wire.MsgTx) bool {
// This function only differs from IsCoinBaseTx in that it works with a higher // This function only differs from IsCoinBaseTx in that it works with a higher
// level util transaction as opposed to a raw wire transaction. // level util transaction as opposed to a raw wire transaction.
func IsCoinBase(tx *util.Tx) bool { func IsCoinBase(tx *util.Tx) bool {
return IsCoinBaseTx(tx.MsgTx()) return tx.MsgTx().IsCoinBase()
} }
// SequenceLockActive determines if a transaction's sequence locks have been // SequenceLockActive determines if a transaction's sequence locks have been
@ -385,7 +361,7 @@ func CountP2SHSigOps(tx *util.Tx, isCoinBaseTx bool, utxoSet UTXOSet) (int, erro
str := fmt.Sprintf("output %v referenced from "+ str := fmt.Sprintf("output %v referenced from "+
"transaction %s:%d either does not exist or "+ "transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint, "has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex) tx.ID(), txInIndex)
return 0, ruleError(ErrMissingTxOut, str) return 0, ruleError(ErrMissingTxOut, str)
} }
@ -548,27 +524,36 @@ func checkBlockSanity(block *util.Block, powLimit *big.Int, timeSource MedianTim
// checks. Bitcoind builds the tree here and checks the merkle root // checks. Bitcoind builds the tree here and checks the merkle root
// after the following checks, but there is no reason not to check the // after the following checks, but there is no reason not to check the
// merkle root matches here. // merkle root matches here.
merkles := BuildMerkleTreeStore(block.Transactions()) hashMerkleTree := BuildHashMerkleTreeStore(block.Transactions())
calculatedMerkleRoot := merkles[len(merkles)-1] calculatedHashMerkleRoot := hashMerkleTree.Root()
if !header.MerkleRoot.IsEqual(calculatedMerkleRoot) { if !header.HashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
str := fmt.Sprintf("block merkle root is invalid - block "+ str := fmt.Sprintf("block hash merkle root is invalid - block "+
"header indicates %v, but calculated value is %v", "header indicates %v, but calculated value is %v",
header.MerkleRoot, calculatedMerkleRoot) header.HashMerkleRoot, calculatedHashMerkleRoot)
return ruleError(ErrBadMerkleRoot, str)
}
idMerkleTree := BuildIDMerkleTreeStore(block.Transactions())
calculatedIDMerkleRoot := idMerkleTree.Root()
if !header.IDMerkleRoot.IsEqual(calculatedIDMerkleRoot) {
str := fmt.Sprintf("block ID merkle root is invalid - block "+
"header indicates %v, but calculated value is %v",
header.IDMerkleRoot, calculatedIDMerkleRoot)
return ruleError(ErrBadMerkleRoot, str) return ruleError(ErrBadMerkleRoot, str)
} }
// Check for duplicate transactions. This check will be fairly quick // Check for duplicate transactions. This check will be fairly quick
// since the transaction hashes are already cached due to building the // since the transaction IDs are already cached due to building the
// merkle tree above. // merkle tree above.
existingTxHashes := make(map[daghash.Hash]struct{}) existingTxIDs := make(map[daghash.Hash]struct{})
for _, tx := range transactions { for _, tx := range transactions {
hash := tx.Hash() id := tx.ID()
if _, exists := existingTxHashes[*hash]; exists { if _, exists := existingTxIDs[*id]; exists {
str := fmt.Sprintf("block contains duplicate "+ str := fmt.Sprintf("block contains duplicate "+
"transaction %v", hash) "transaction %v", id)
return ruleError(ErrDuplicateTx, str) return ruleError(ErrDuplicateTx, str)
} }
existingTxHashes[*hash] = struct{}{} existingTxIDs[*id] = struct{}{}
} }
// The number of signature operations must be less than the maximum // The number of signature operations must be less than the maximum
@ -785,7 +770,7 @@ func (dag *BlockDAG) checkBlockContext(block *util.Block, parents blockSet, blue
blockTime) { blockTime) {
str := fmt.Sprintf("block contains unfinalized "+ str := fmt.Sprintf("block contains unfinalized "+
"transaction %v", tx.Hash()) "transaction %v", tx.ID())
return ruleError(ErrUnfinalizedTx, str) return ruleError(ErrUnfinalizedTx, str)
} }
} }
@ -820,7 +805,7 @@ func ensureNoDuplicateTx(block *blockNode, utxoSet UTXOSet,
// Typically, there will not be any utxos for any of the outputs. // Typically, there will not be any utxos for any of the outputs.
fetchSet := make(map[wire.OutPoint]struct{}) fetchSet := make(map[wire.OutPoint]struct{})
for _, tx := range transactions { for _, tx := range transactions {
prevOut := wire.OutPoint{Hash: *tx.Hash()} prevOut := wire.OutPoint{TxID: *tx.ID()}
for txOutIdx := range tx.MsgTx().TxOut { for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx) prevOut.Index = uint32(txOutIdx)
fetchSet[prevOut] = struct{}{} fetchSet[prevOut] = struct{}{}
@ -834,7 +819,7 @@ func ensureNoDuplicateTx(block *blockNode, utxoSet UTXOSet,
if ok { if ok {
str := fmt.Sprintf("tried to overwrite transaction %v "+ str := fmt.Sprintf("tried to overwrite transaction %v "+
"at block height %d that is not fully spent", "at block height %d that is not fully spent",
outpoint.Hash, utxo.BlockHeight()) outpoint.TxID, utxo.BlockHeight())
return ruleError(ErrOverwriteTx, str) return ruleError(ErrOverwriteTx, str)
} }
} }
@ -859,7 +844,7 @@ func CheckTransactionInputs(tx *util.Tx, txHeight int32, utxoSet UTXOSet, dagPar
return 0, nil return 0, nil
} }
txHash := tx.Hash() txID := tx.ID()
var totalSatoshiIn uint64 var totalSatoshiIn uint64
for txInIndex, txIn := range tx.MsgTx().TxIn { for txInIndex, txIn := range tx.MsgTx().TxIn {
// Ensure the referenced input transaction is available. // Ensure the referenced input transaction is available.
@ -868,7 +853,7 @@ func CheckTransactionInputs(tx *util.Tx, txHeight int32, utxoSet UTXOSet, dagPar
str := fmt.Sprintf("output %v referenced from "+ str := fmt.Sprintf("output %v referenced from "+
"transaction %s:%d either does not exist or "+ "transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint, "has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex) tx.ID(), txInIndex)
return 0, ruleError(ErrMissingTxOut, str) return 0, ruleError(ErrMissingTxOut, str)
} }
@ -931,7 +916,7 @@ func CheckTransactionInputs(tx *util.Tx, txHeight int32, utxoSet UTXOSet, dagPar
if totalSatoshiIn < totalSatoshiOut { if totalSatoshiIn < totalSatoshiOut {
str := fmt.Sprintf("total value of all transaction inputs for "+ str := fmt.Sprintf("total value of all transaction inputs for "+
"transaction %v is %v which is less than the amount "+ "transaction %v is %v which is less than the amount "+
"spent of %v", txHash, totalSatoshiIn, totalSatoshiOut) "spent of %v", txID, totalSatoshiIn, totalSatoshiOut)
return 0, ruleError(ErrSpendTooHigh, str) return 0, ruleError(ErrSpendTooHigh, str)
} }

125
blockdag/validate_test.go
View File

@ -186,30 +186,36 @@ func TestCheckBlockSanity(t *testing.T) {
var invalidParentsOrderBlock = wire.MsgBlock{ var invalidParentsOrderBlock = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b, 0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87, 0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
0x2a, 0x04, 0x71, 0xbc, 0xf8, 0x30, 0x95, 0x52, 0x2a, 0x04, 0x71, 0xbc, 0xf8, 0x30, 0x95, 0x52,
0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00, 0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00,
}, // SimNet genesis },
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95, 0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3, 0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
0x46, 0x11, 0x89, 0x6b, 0x82, 0x1a, 0x68, 0x3b, 0x46, 0x11, 0x89, 0x6b, 0x82, 0x1a, 0x68, 0x3b,
0x7a, 0x4e, 0xde, 0xfe, 0x2c, 0x00, 0x00, 0x00, 0x7a, 0x4e, 0xde, 0xfe, 0x2c, 0x00, 0x00, 0x00,
}, // MainNet genesis },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xc0, 0x92, 0x53, 0x8f, 0x6f, 0xf7, 0xf5, 0x24, 0x2f, 0x4c, 0xc3, 0x0b, 0x0a, 0x84, 0xbb, 0x95,
0xd5, 0x33, 0xd4, 0x8b, 0xf3, 0xc0, 0xf8, 0xf9, 0x56, 0x9d, 0x77, 0xa2, 0xee, 0x3e, 0xb1, 0xac,
0x6f, 0xff, 0xfb, 0xb7, 0xdc, 0x39, 0x9d, 0x76, 0x48, 0x3e, 0x8b, 0xe1, 0xcf, 0xdc, 0x20, 0xba,
0x8d, 0xb0, 0xe1, 0x9c, 0x2e, 0x6d, 0x22, 0xd9, 0xae, 0xec, 0x0a, 0x2f, 0xe4, 0x85, 0x31, 0x30,
}), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766 }),
Timestamp: time.Unix(0x5bbe0435, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x4e, 0x06, 0xba, 0x64, 0xd7, 0x61, 0xda, 0x25,
0x1a, 0x0e, 0x21, 0xd4, 0x64, 0x49, 0x02, 0xa2,
0x80, 0xf7, 0x00, 0xe3, 0x16, 0x3d, 0x04, 0x95,
0x5b, 0x7e, 0xaf, 0x84, 0x7e, 0x1b, 0x6b, 0x06,
}),
Timestamp: time.Unix(0x5c40613a, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 0x9ffffffffffffffb, Nonce: 0x4000000000000001,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -217,11 +223,13 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x04, 0x4c, 0x86, 0x04, 0x1b, 0x02, 0x06, 0x02, 0x02, 0x10, 0x27, 0x08, 0xac, 0x29, 0x2f, 0x2f,
0xcf, 0x70, 0xb0, 0x7e, 0x0b, 0x2f, 0x50, 0x32,
0x53, 0x48, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
}, },
@ -230,28 +238,19 @@ func TestCheckBlockSanity(t *testing.T) {
{ {
Value: 0x12a05f200, // 5000000000 Value: 0x12a05f200, // 5000000000
PkScript: []byte{ PkScript: []byte{
0x41, // OP_DATA_65 0x51,
0x04, 0x1b, 0x0e, 0x8c, 0x25, 0x67, 0xc1, 0x25,
0x36, 0xaa, 0x13, 0x35, 0x7b, 0x79, 0xa0, 0x73,
0xdc, 0x44, 0x44, 0xac, 0xb8, 0x3c, 0x4e, 0xc7,
0xa0, 0xe2, 0xf9, 0x9d, 0xd7, 0x45, 0x75, 0x16,
0xc5, 0x81, 0x72, 0x42, 0xda, 0x79, 0x69, 0x24,
0xca, 0x4e, 0x99, 0x94, 0x7d, 0x08, 0x7f, 0xed,
0xf9, 0xce, 0x46, 0x7c, 0xb9, 0xf7, 0xc6, 0x28,
0x70, 0x78, 0xf8, 0x01, 0xdf, 0x27, 0x6f, 0xdf,
0x84, // 65-byte signature
0xac, // OP_CHECKSIG
}, },
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -313,14 +312,15 @@ func TestCheckBlockSanity(t *testing.T) {
}, },
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -381,14 +381,15 @@ func TestCheckBlockSanity(t *testing.T) {
}, },
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
@ -437,7 +438,8 @@ func TestCheckBlockSanity(t *testing.T) {
}, },
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
}, },
}, },
} }
@ -622,11 +624,11 @@ func TestValidateParents(t *testing.T) {
} }
} }
// Block100000 defines block 100,000 of the block chain. It is used to // Block100000 defines block 100,000 of the block DAG. It is used to
// test Block operations. // test Block operations.
var Block100000 = wire.MsgBlock{ var Block100000 = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 0x10000000,
ParentHashes: []daghash.Hash{ ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy. [32]byte{ // Make go vet happy.
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95, 0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
@ -641,15 +643,21 @@ var Block100000 = wire.MsgBlock{
0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00, 0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xe8, 0x09, 0xa1, 0x6c, 0xf2, 0xfb, 0xb1, 0x2d, 0x62, 0x0c, 0x88, 0xd3, 0xcb, 0x15, 0xc7, 0x8a,
0xff, 0xff, 0x7d, 0x0f, 0x5b, 0xdc, 0xaa, 0xfd, 0xe9, 0x62, 0x68, 0x4d, 0xc4, 0x2c, 0xe2, 0x14,
0xf1, 0xe4, 0x92, 0x23, 0x1b, 0x8c, 0xbf, 0x6a, 0xc2, 0x3c, 0x56, 0xf7, 0xc1, 0x65, 0xce, 0x07,
0x28, 0x52, 0x10, 0x9f, 0x93, 0x96, 0x1f, 0x25, 0x84, 0x02, 0x7a, 0x5f, 0x65, 0x0e, 0xeb, 0xc5,
}), }),
Timestamp: time.Unix(0x5c22330f, 0), IDMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xa7, 0x38, 0x15, 0xb6, 0x90, 0xa2, 0x17, 0xf3,
0x40, 0x25, 0x34, 0x7e, 0x82, 0x9e, 0xbb, 0xa2,
0x5c, 0x8b, 0x6e, 0x26, 0x3b, 0xea, 0xb2, 0x92,
0x0a, 0xc4, 0x8a, 0xda, 0x62, 0x8a, 0x76, 0xed,
}),
Timestamp: time.Unix(0x5c404bc3, 0),
Bits: 0x207fffff, Bits: 0x207fffff,
Nonce: 1, Nonce: 0xdffffffffffffff9,
}, },
Transactions: []*wire.MsgTx{ Transactions: []*wire.MsgTx{
{ {
@ -657,11 +665,13 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x04, 0x4c, 0x86, 0x04, 0x1b, 0x02, 0x06, 0x02, 0x02, 0x10, 0x27, 0x08, 0x8f, 0x22, 0xfb, 0x88,
0x45, 0x7b, 0xee, 0xeb, 0x0b, 0x2f, 0x50, 0x32,
0x53, 0x48, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
}, },
@ -670,28 +680,19 @@ var Block100000 = wire.MsgBlock{
{ {
Value: 0x12a05f200, // 5000000000 Value: 0x12a05f200, // 5000000000
PkScript: []byte{ PkScript: []byte{
0x41, // OP_DATA_65 0x51,
0x04, 0x1b, 0x0e, 0x8c, 0x25, 0x67, 0xc1, 0x25,
0x36, 0xaa, 0x13, 0x35, 0x7b, 0x79, 0xa0, 0x73,
0xdc, 0x44, 0x44, 0xac, 0xb8, 0x3c, 0x4e, 0xc7,
0xa0, 0xe2, 0xf9, 0x9d, 0xd7, 0x45, 0x75, 0x16,
0xc5, 0x81, 0x72, 0x42, 0xda, 0x79, 0x69, 0x24,
0xca, 0x4e, 0x99, 0x94, 0x7d, 0x08, 0x7f, 0xed,
0xf9, 0xce, 0x46, 0x7c, 0xb9, 0xf7, 0xc6, 0x28,
0x70, 0x78, 0xf8, 0x01, 0xdf, 0x27, 0x6f, 0xdf,
0x84, // 65-byte signature
0xac, // OP_CHECKSIG
}, },
}, },
}, },
LockTime: 0, LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
}, },
{ {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -761,7 +762,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -830,7 +831,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
@ -903,7 +904,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00, 0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00,
}, },
}, },
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x0b, 0x79, 0xf5, 0x29, 0x6d, 0x1c, 0xaa, 0x90, 0x0b, 0x79, 0xf5, 0x29, 0x6d, 0x1c, 0xaa, 0x90,
0x2f, 0x01, 0xd4, 0x83, 0x9b, 0x2a, 0x04, 0x5e, 0x2f, 0x01, 0xd4, 0x83, 0x9b, 0x2a, 0x04, 0x5e,
0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3, 0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3,
@ -919,7 +920,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -953,7 +954,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -1023,7 +1024,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -1092,7 +1093,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,

2
blockdag/versionbits.go
View File

@ -14,7 +14,7 @@ const (
// vbTopBits defines the bits to set in the version to signal that the // vbTopBits defines the bits to set in the version to signal that the
// version bits scheme is being used. // version bits scheme is being used.
vbTopBits = 0x20000000 vbTopBits = 0x10000000
// vbTopMask is the bitmask to use to determine whether or not the // vbTopMask is the bitmask to use to determine whether or not the
// version bits scheme is in use. // version bits scheme is in use.

2
btcjson/dagsvrresults.go
View File

@ -116,7 +116,7 @@ type GetBlockDAGInfoResult struct {
// getblocktemplate command. // getblocktemplate command.
type GetBlockTemplateResultTx struct { type GetBlockTemplateResultTx struct {
Data string `json:"data"` Data string `json:"data"`
Hash string `json:"hash"` ID string `json:"id"`
Depends []int64 `json:"depends"` Depends []int64 `json:"depends"`
Fee uint64 `json:"fee"` Fee uint64 `json:"fee"`
SigOps int64 `json:"sigOps"` SigOps int64 `json:"sigOps"`

5
dagconfig/daghash/hash.go
View File

@ -190,8 +190,13 @@ func JoinHashesStrings(hashes []Hash, separator string) string {
return strings.Join(Strings(hashes), separator) return strings.Join(Strings(hashes), separator)
} }
// Sort sorts a slice of hashes
func Sort(hashes []Hash) { func Sort(hashes []Hash) {
sort.Slice(hashes, func(i, j int) bool { sort.Slice(hashes, func(i, j int) bool {
return Less(&hashes[i], &hashes[j]) return Less(&hashes[i], &hashes[j])
}) })
} }
// Zero is the Hash value of all zero bytes, defined here for
// convenience.
var Zero Hash

110
dagconfig/genesis.go
View File

@ -19,20 +19,12 @@ var genesisCoinbaseTx = wire.MsgTx{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, 0x45, /* |.......E| */ 0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6d, 0x65, /* |The Time| */ 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
0x73, 0x20, 0x30, 0x33, 0x2f, 0x4a, 0x61, 0x6e, /* |s 03/Jan| */
0x2f, 0x32, 0x30, 0x30, 0x39, 0x20, 0x43, 0x68, /* |/2009 Ch| */
0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x6f, 0x72, /* |ancellor| */
0x20, 0x6f, 0x6e, 0x20, 0x62, 0x72, 0x69, 0x6e, /* | on brin| */
0x6b, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x65, 0x63, /* |k of sec|*/
0x6f, 0x6e, 0x64, 0x20, 0x62, 0x61, 0x69, 0x6c, /* |ond bail| */
0x6f, 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, /* |out for |*/
0x62, 0x61, 0x6e, 0x6b, 0x73, /* |banks| */
}, },
Sequence: math.MaxUint64, Sequence: math.MaxUint64,
}, },
@ -41,15 +33,7 @@ var genesisCoinbaseTx = wire.MsgTx{
{ {
Value: 0x12a05f200, Value: 0x12a05f200,
PkScript: []byte{ PkScript: []byte{
0x41, 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, /* |A.g....U| */ 0x51,
0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, /* |H'.g..q0| */
0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, /* |..\..(.9| */
0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, /* |..yb...a| */
0xde, 0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, /* |..I..?L.| */
0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, /* |8..U....| */
0x12, 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, /* |..\8M...| */
0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, /* |.W.Lp+k.| */
0x1d, 0x5f, 0xac, /* |._.| */
}, },
}, },
}, },
@ -60,43 +44,39 @@ var genesisCoinbaseTx = wire.MsgTx{
// genesisHash is the hash of the first block in the block chain for the main // genesisHash is the hash of the first block in the block chain for the main
// network (genesis block). // network (genesis block).
var genesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var genesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
0xca, 0xd9, 0x5f, 0x65, 0x44, 0xd4, 0x2f, 0x08, 0x53, 0xb8, 0xf9, 0x4b, 0xec, 0x3f, 0xae, 0x0a,
0x23, 0x22, 0x93, 0x4c, 0x07, 0xd9, 0xa4, 0xc0, 0x7c, 0x79, 0x7a, 0x8c, 0x87, 0xfb, 0x4c, 0x37,
0x1a, 0x51, 0x77, 0xf6, 0x13, 0x7c, 0x06, 0x8b, 0xff, 0x68, 0xed, 0xdb, 0x4a, 0x96, 0xd6, 0xbd,
0xd2, 0x6d, 0xe1, 0x38, 0xea, 0x12, 0xcd, 0x4a, 0x36, 0xf0, 0x28, 0x93, 0xe7, 0x09, 0xc3, 0xcc,
}) })
// genesisMerkleRoot is the hash of the first transaction in the genesis block // genesisMerkleRoot is the hash of the first transaction in the genesis block
// for the main network. // for the main network.
var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
0x5a, 0x7c, 0x26, 0x54, 0x0d, 0x46, 0x6b, 0x5f, 0x76, 0x2b, 0x33, 0xa9, 0x4c, 0xd4, 0x36, 0x13,
0x4a, 0x2c, 0x29, 0xff, 0x2f, 0xa5, 0xa0, 0xad, 0x29, 0x5e, 0x9b, 0x68, 0xb7, 0xad, 0x2b, 0x16,
0x9c, 0xd2, 0x4f, 0x6e, 0xa9, 0x16, 0xfa, 0xb5, 0x7c, 0x63, 0x89, 0xc3, 0x54, 0xc9, 0xa7, 0x06,
0x52, 0x5e, 0x40, 0xa2, 0x69, 0xb6, 0x8d, 0x5c, 0x8c, 0x23, 0x24, 0x3c, 0x53, 0x6d, 0x56, 0x23,
}) })
// genesisBlock defines the genesis block of the block chain which serves as the // genesisBlock defines the genesis block of the block chain which serves as the
// public transaction ledger for the main network. // public transaction ledger for the main network.
var genesisBlock = wire.MsgBlock{ var genesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{}, ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot, HashMerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0), IDMerkleRoot: genesisMerkleRoot,
Bits: 0x207fffff, Timestamp: time.Unix(0x5c3cafec, 0),
Nonce: 0xdffffffffffffff9, Bits: 0x207fffff,
Nonce: 0xbffffffffffffffa,
}, },
Transactions: []*wire.MsgTx{&genesisCoinbaseTx}, Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
} }
// regTestGenesisHash is the hash of the first block in the block chain for the // regTestGenesisHash is the hash of the first block in the block chain for the
// regression test network (genesis block). // regression test network (genesis block).
var regTestGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var regTestGenesisHash = genesisHash
0xca, 0xd9, 0x5f, 0x65, 0x44, 0xd4, 0x2f, 0x08,
0x23, 0x22, 0x93, 0x4c, 0x07, 0xd9, 0xa4, 0xc0,
0x1a, 0x51, 0x77, 0xf6, 0x13, 0x7c, 0x06, 0x8b,
0xd2, 0x6d, 0xe1, 0x38, 0xea, 0x12, 0xcd, 0x4a,
})
// regTestGenesisMerkleRoot is the hash of the first transaction in the genesis // regTestGenesisMerkleRoot is the hash of the first transaction in the genesis
// block for the regression test network. It is the same as the merkle root for // block for the regression test network. It is the same as the merkle root for
@ -105,26 +85,11 @@ var regTestGenesisMerkleRoot = genesisMerkleRoot
// regTestGenesisBlock defines the genesis block of the block chain which serves // regTestGenesisBlock defines the genesis block of the block chain which serves
// as the public transaction ledger for the regression test network. // as the public transaction ledger for the regression test network.
var regTestGenesisBlock = wire.MsgBlock{ var regTestGenesisBlock = genesisBlock
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
// testNet3GenesisHash is the hash of the first block in the block chain for the // testNet3GenesisHash is the hash of the first block in the block chain for the
// test network (version 3). // test network (version 3).
var testNet3GenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var testNet3GenesisHash = genesisHash
0xca, 0xd9, 0x5f, 0x65, 0x44, 0xd4, 0x2f, 0x08,
0x23, 0x22, 0x93, 0x4c, 0x07, 0xd9, 0xa4, 0xc0,
0x1a, 0x51, 0x77, 0xf6, 0x13, 0x7c, 0x06, 0x8b,
0xd2, 0x6d, 0xe1, 0x38, 0xea, 0x12, 0xcd, 0x4a,
})
// testNet3GenesisMerkleRoot is the hash of the first transaction in the genesis // testNet3GenesisMerkleRoot is the hash of the first transaction in the genesis
// block for the test network (version 3). It is the same as the merkle root // block for the test network (version 3). It is the same as the merkle root
@ -133,26 +98,11 @@ var testNet3GenesisMerkleRoot = genesisMerkleRoot
// testNet3GenesisBlock defines the genesis block of the block chain which // testNet3GenesisBlock defines the genesis block of the block chain which
// serves as the public transaction ledger for the test network (version 3). // serves as the public transaction ledger for the test network (version 3).
var testNet3GenesisBlock = wire.MsgBlock{ var testNet3GenesisBlock = genesisBlock
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
// simNetGenesisHash is the hash of the first block in the block chain for the // simNetGenesisHash is the hash of the first block in the block chain for the
// simulation test network. // simulation test network.
var simNetGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. var simNetGenesisHash = genesisHash
0xca, 0xd9, 0x5f, 0x65, 0x44, 0xd4, 0x2f, 0x08,
0x23, 0x22, 0x93, 0x4c, 0x07, 0xd9, 0xa4, 0xc0,
0x1a, 0x51, 0x77, 0xf6, 0x13, 0x7c, 0x06, 0x8b,
0xd2, 0x6d, 0xe1, 0x38, 0xea, 0x12, 0xcd, 0x4a,
})
// simNetGenesisMerkleRoot is the hash of the first transaction in the genesis // simNetGenesisMerkleRoot is the hash of the first transaction in the genesis
// block for the simulation test network. It is the same as the merkle root for // block for the simulation test network. It is the same as the merkle root for
@ -161,14 +111,4 @@ var simNetGenesisMerkleRoot = genesisMerkleRoot
// simNetGenesisBlock defines the genesis block of the block chain which serves // simNetGenesisBlock defines the genesis block of the block chain which serves
// as the public transaction ledger for the simulation test network. // as the public transaction ledger for the simulation test network.
var simNetGenesisBlock = wire.MsgBlock{ var simNetGenesisBlock = genesisBlock
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}

182
dagconfig/genesis_test.go
View File

@ -121,167 +121,41 @@ func TestSimNetGenesisBlock(t *testing.T) {
// genesisBlockBytes are the wire encoded bytes for the genesis block of the // genesisBlockBytes are the wire encoded bytes for the genesis block of the
// main network as of protocol version 60002. // main network as of protocol version 60002.
var genesisBlockBytes = []byte{ var genesisBlockBytes = []byte{
0x01, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x7c, 0x26, /* |.....Z|&| */ 0x01, 0x00, 0x00, 0x00, 0x00, 0x76, 0x2b, 0x33,
0x54, 0x0d, 0x46, 0x6b, 0x5f, 0x4a, 0x2c, 0x29, /* |T.Fk_J,)| */ 0xa9, 0x4c, 0xd4, 0x36, 0x13, 0x29, 0x5e, 0x9b,
0xff, 0x2f, 0xa5, 0xa0, 0xad, 0x9c, 0xd2, 0x4f, /* |./.....O| */ 0x68, 0xb7, 0xad, 0x2b, 0x16, 0x7c, 0x63, 0x89,
0x6e, 0xa9, 0x16, 0xfa, 0xb5, 0x52, 0x5e, 0x40, /* |n....R^@| */ 0xc3, 0x54, 0xc9, 0xa7, 0x06, 0x8c, 0x23, 0x24,
0xa2, 0x69, 0xb6, 0x8d, 0x5c, 0xba, 0xb3, 0x34, /* |.i..\..4| */ 0x3c, 0x53, 0x6d, 0x56, 0x23, 0x76, 0x2b, 0x33,
0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */ 0xa9, 0x4c, 0xd4, 0x36, 0x13, 0x29, 0x5e, 0x9b,
0x20, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* | .......| */ 0x68, 0xb7, 0xad, 0x2b, 0x16, 0x7c, 0x63, 0x89,
0xdf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */ 0xc3, 0x54, 0xc9, 0xa7, 0x06, 0x8c, 0x23, 0x24,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */ 0x3c, 0x53, 0x6d, 0x56, 0x23, 0xec, 0xaf, 0x3c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */ 0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */ 0x20, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */ 0xbf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */ 0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */ 0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */ 0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */ 0xff, 0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01,
0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */ 0x00, 0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x00,
0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */ 0x00,
0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, /* |..| */
} }
// regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of // regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of
// the regression test network as of protocol version 60002. // the regression test network as of protocol version 60002.
var regTestGenesisBlockBytes = []byte{ var regTestGenesisBlockBytes = genesisBlockBytes
0x01, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x7c, 0x26, /* |.....Z|&| */
0x54, 0x0d, 0x46, 0x6b, 0x5f, 0x4a, 0x2c, 0x29, /* |T.Fk_J,)| */
0xff, 0x2f, 0xa5, 0xa0, 0xad, 0x9c, 0xd2, 0x4f, /* |./.....O| */
0x6e, 0xa9, 0x16, 0xfa, 0xb5, 0x52, 0x5e, 0x40, /* |n....R^@| */
0xa2, 0x69, 0xb6, 0x8d, 0x5c, 0xba, 0xb3, 0x34, /* |.i..\..4| */
0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
0x20, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* | .......| */
0xdf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */
0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */
0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */
0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */
0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */
0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */
0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */
0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */
0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */
0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */
0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */
0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */
0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */
0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */
0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, /* |..| */
}
// testNet3GenesisBlockBytes are the wire encoded bytes for the genesis block of // testNet3GenesisBlockBytes are the wire encoded bytes for the genesis block of
// the test network (version 3) as of protocol version 60002. // the test network (version 3) as of protocol version 60002.
var testNet3GenesisBlockBytes = []byte{ var testNet3GenesisBlockBytes = genesisBlockBytes
0x01, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x7c, 0x26, /* |.....Z|&| */
0x54, 0x0d, 0x46, 0x6b, 0x5f, 0x4a, 0x2c, 0x29, /* |T.Fk_J,)| */
0xff, 0x2f, 0xa5, 0xa0, 0xad, 0x9c, 0xd2, 0x4f, /* |./.....O| */
0x6e, 0xa9, 0x16, 0xfa, 0xb5, 0x52, 0x5e, 0x40, /* |n....R^@| */
0xa2, 0x69, 0xb6, 0x8d, 0x5c, 0xba, 0xb3, 0x34, /* |.i..\..4| */
0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
0x20, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* | .......| */
0xdf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */
0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */
0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */
0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */
0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */
0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */
0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */
0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */
0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */
0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */
0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */
0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */
0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */
0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */
0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, /* |..| */
}
// simNetGenesisBlockBytes are the wire encoded bytes for the genesis block of // simNetGenesisBlockBytes are the wire encoded bytes for the genesis block of
// the simulation test network as of protocol version 70002. // the simulation test network as of protocol version 70002.
var simNetGenesisBlockBytes = []byte{ var simNetGenesisBlockBytes = genesisBlockBytes
0x01, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x7c, 0x26, /* |.....Z|&| */
0x54, 0x0d, 0x46, 0x6b, 0x5f, 0x4a, 0x2c, 0x29, /* |T.Fk_J,)| */
0xff, 0x2f, 0xa5, 0xa0, 0xad, 0x9c, 0xd2, 0x4f, /* |./.....O| */
0x6e, 0xa9, 0x16, 0xfa, 0xb5, 0x52, 0x5e, 0x40, /* |n....R^@| */
0xa2, 0x69, 0xb6, 0x8d, 0x5c, 0xba, 0xb3, 0x34, /* |.i..\..4| */
0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
0x20, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* | .......| */
0xdf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */
0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */
0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */
0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */
0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */
0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */
0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */
0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */
0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */
0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */
0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */
0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */
0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */
0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */
0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
0x00, 0x00, /* |..| */
}

2
dagconfig/params.go
View File

@ -224,7 +224,7 @@ var MainNetParams = Params{
{"seed.bitcoin.jonasschnelli.ch", true}, {"seed.bitcoin.jonasschnelli.ch", true},
}, },
// Chain parameters // DAG parameters
GenesisBlock: &genesisBlock, GenesisBlock: &genesisBlock,
GenesisHash: &genesisHash, GenesisHash: &genesisHash,
PowLimit: mainPowLimit, PowLimit: mainPowLimit,

2
database/example_test.go
View File

@ -175,5 +175,5 @@ func Example_blockStorageAndRetrieval() {
fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes)) fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes))
// Output: // Output:
// Serialized block size: 290 bytes // Serialized block size: 193 bytes
} }

4
database/ffldb/blockio_test.go
View File

@ -16,7 +16,7 @@ import (
func TestDeleteFile(t *testing.T) { func TestDeleteFile(t *testing.T) {
testBlock := util.NewBlock(wire.NewMsgBlock( testBlock := util.NewBlock(wire.NewMsgBlock(
wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, 0, 0))) wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
tests := []struct { tests := []struct {
fileNum uint32 fileNum uint32
@ -69,7 +69,7 @@ func TestDeleteFile(t *testing.T) {
// and makes sure no panic occurs, as well as ensures the writeCursor was updated correctly. // and makes sure no panic occurs, as well as ensures the writeCursor was updated correctly.
func TestHandleRollbackErrors(t *testing.T) { func TestHandleRollbackErrors(t *testing.T) {
testBlock := util.NewBlock(wire.NewMsgBlock( testBlock := util.NewBlock(wire.NewMsgBlock(
wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, 0, 0))) wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
testBlockSize := uint32(testBlock.MsgBlock().SerializeSize()) testBlockSize := uint32(testBlock.MsgBlock().SerializeSize())
tests := []struct { tests := []struct {

4
database/ffldb/db_test.go
View File

@ -553,7 +553,7 @@ func TestForEachBucket(t *testing.T) {
// TestStoreBlockErrors tests all error-cases in *tx.StoreBlock(). // TestStoreBlockErrors tests all error-cases in *tx.StoreBlock().
// The non-error-cases are tested in the more general tests. // The non-error-cases are tested in the more general tests.
func TestStoreBlockErrors(t *testing.T) { func TestStoreBlockErrors(t *testing.T) {
testBlock := util.NewBlock(wire.NewMsgBlock(wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, 0, 0))) testBlock := util.NewBlock(wire.NewMsgBlock(wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
tests := []struct { tests := []struct {
name string name string
@ -716,7 +716,7 @@ func TestWritePendingAndCommitErrors(t *testing.T) {
rollbackCalled = false rollbackCalled = false
err = pdb.Update(func(dbTx database.Tx) error { err = pdb.Update(func(dbTx database.Tx) error {
return dbTx.StoreBlock(util.NewBlock(wire.NewMsgBlock( return dbTx.StoreBlock(util.NewBlock(wire.NewMsgBlock(
wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, 0, 0)))) wire.NewBlockHeader(1, []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0))))
}) })
if err == nil { if err == nil {
t.Errorf("No error returned when blockIdx.Put() should have returned an error") t.Errorf("No error returned when blockIdx.Put() should have returned an error")

BIN
database/testdata/blocks1-256.bz2 vendored
View File

Binary file not shown.

14
database/testdata/generator.go vendored
View File

@ -44,12 +44,12 @@ func generateBlocks(out *os.File, numBlocks int) {
func generateBlock(parent *wire.MsgBlock) *wire.MsgBlock { func generateBlock(parent *wire.MsgBlock) *wire.MsgBlock {
return &wire.MsgBlock{ return &wire.MsgBlock{
Header: wire.BlockHeader{ Header: wire.BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{parent.BlockHash()}, ParentHashes: []daghash.Hash{parent.BlockHash()},
MerkleRoot: genesisMerkleRoot, HashMerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC Timestamp: time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC
Bits: 0x2e00ffff, // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000] Bits: 0x2e00ffff, // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
Nonce: 0xc0192550, // 2148484547 Nonce: 0xc0192550, // 2148484547
}, },
Transactions: []*wire.MsgTx{&genesisCoinbaseTx}, Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
} }
@ -108,7 +108,7 @@ var genesisCoinbaseTx = wire.MsgTx{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

8
integration/csv_test.go
View File

@ -77,7 +77,7 @@ func makeTestOutput(r *rpctest.Harness, t *testing.T,
} }
utxo := &wire.OutPoint{ utxo := &wire.OutPoint{
Hash: fundTx.TxHash(), Hash: fundTx.TxID(),
Index: outputIndex, Index: outputIndex,
} }
@ -282,7 +282,7 @@ func createCSVOutput(r *rpctest.Harness, t *testing.T,
} }
utxo := &wire.OutPoint{ utxo := &wire.OutPoint{
Hash: tx.TxHash(), Hash: tx.TxID(),
Index: outputIndex, Index: outputIndex,
} }
@ -330,8 +330,8 @@ func assertTxInBlock(r *rpctest.Harness, t *testing.T, blockHash *daghash.Hash,
} }
for _, txn := range block.Transactions { for _, txn := range block.Transactions {
txHash := txn.TxHash() txHash := txn.TxID()
if txn.TxHash() == txHash { if txn.TxID() == txHash {
return return
} }
} }

14
integration/rpctest/blockgen.go
View File

@ -181,14 +181,16 @@ func CreateBlock(parentBlock *util.Block, inclusionTxs []*util.Tx,
if inclusionTxs != nil { if inclusionTxs != nil {
blockTxns = append(blockTxns, inclusionTxs...) blockTxns = append(blockTxns, inclusionTxs...)
} }
merkles := blockdag.BuildMerkleTreeStore(blockTxns) hashMerkleTree := blockdag.BuildHashMerkleTreeStore(blockTxns)
idMerkleTree := blockdag.BuildIDMerkleTreeStore(blockTxns)
var block wire.MsgBlock var block wire.MsgBlock
block.Header = wire.BlockHeader{ block.Header = wire.BlockHeader{
Version: blockVersion, Version: blockVersion,
ParentHashes: []daghash.Hash{*parentHash}, ParentHashes: []daghash.Hash{*parentHash},
MerkleRoot: *merkles[len(merkles)-1], HashMerkleRoot: *hashMerkleTree.Root(),
Timestamp: ts, IDMerkleRoot: *idMerkleTree.Root(),
Bits: net.PowLimitBits, Timestamp: ts,
Bits: net.PowLimitBits,
} }
for _, tx := range blockTxns { for _, tx := range blockTxns {
if err := block.AddTransaction(tx.MsgTx()); err != nil { if err := block.AddTransaction(tx.MsgTx()); err != nil {

9
integration/rpctest/memwallet.go
View File

@ -10,7 +10,6 @@ import (
"fmt" "fmt"
"sync" "sync"
"github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/btcec" "github.com/daglabs/btcd/btcec"
"github.com/daglabs/btcd/dagconfig" "github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash" "github.com/daglabs/btcd/dagconfig/daghash"
@ -207,9 +206,9 @@ func (m *memWallet) ingestBlock(update *chainUpdate) {
} }
for _, tx := range update.filteredTxns { for _, tx := range update.filteredTxns {
mtx := tx.MsgTx() mtx := tx.MsgTx()
isCoinbase := blockdag.IsCoinBaseTx(mtx) isCoinbase := mtx.IsCoinBase()
txHash := mtx.TxHash() txID := mtx.TxID()
m.evalOutputs(mtx.TxOut, &txHash, isCoinbase, undo) m.evalOutputs(mtx.TxOut, &txID, isCoinbase, undo)
m.evalInputs(mtx.TxIn, undo) m.evalInputs(mtx.TxIn, undo)
} }
@ -269,7 +268,7 @@ func (m *memWallet) evalOutputs(outputs []*wire.TxOut, txHash *daghash.Hash,
maturityHeight = m.currentHeight + int32(m.net.CoinbaseMaturity) maturityHeight = m.currentHeight + int32(m.net.CoinbaseMaturity)
} }
op := wire.OutPoint{Hash: *txHash, Index: uint32(i)} op := wire.OutPoint{TxID: *txHash, Index: uint32(i)}
m.utxos[op] = &utxo{ m.utxos[op] = &utxo{
value: util.Amount(output.Value), value: util.Amount(output.Value),
keyIndex: keyIndex, keyIndex: keyIndex,

6
integration/rpctest/rpc_harness_test.go
View File

@ -55,9 +55,9 @@ func testSendOutputs(r *Harness, t *testing.T) {
} }
minedTx := block.Transactions[1] minedTx := block.Transactions[1]
txHash := minedTx.TxHash() minedTxID := minedTx.TxID()
if txHash != *txid { if minedTxID != *txid {
t.Fatalf("txid's don't match, %v vs %v", txHash, txid) t.Fatalf("txid's don't match, %v vs %v", minedTxID, txid)
} }
} }

2
mempool/estimatefee.go
View File

@ -206,7 +206,7 @@ func (ef *FeeEstimator) ObserveTransaction(t *TxDesc) {
return return
} }
hash := *t.Tx.Hash() hash := *t.Tx.ID()
if _, ok := ef.observed[hash]; !ok { if _, ok := ef.observed[hash]; !ok {
size := uint32(t.Tx.MsgTx().SerializeSize()) size := uint32(t.Tx.MsgTx().SerializeSize())

2
mempool/estimatefee_test.go
View File

@ -292,7 +292,7 @@ func (eft *estimateFeeTester) round(txHistory [][]*TxDesc,
mempool := make(map[*observedTransaction]*TxDesc) mempool := make(map[*observedTransaction]*TxDesc)
for _, h := range txHistory { for _, h := range txHistory {
for _, t := range h { for _, t := range h {
if o, exists := eft.ef.observed[*t.Tx.Hash()]; exists && o.mined == mining.UnminedHeight { if o, exists := eft.ef.observed[*t.Tx.ID()]; exists && o.mined == mining.UnminedHeight {
mempool[o] = t mempool[o] = t
} }
} }

88
mempool/mempool.go
View File

@ -192,8 +192,8 @@ var _ mining.TxSource = (*TxPool)(nil)
// This function MUST be called with the mempool lock held (for writes). // This function MUST be called with the mempool lock held (for writes).
func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) { func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
// Nothing to do if passed tx is not an orphan. // Nothing to do if passed tx is not an orphan.
txHash := tx.Hash() txID := tx.ID()
otx, exists := mp.orphans[*txHash] otx, exists := mp.orphans[*txID]
if !exists { if !exists {
return return
} }
@ -202,7 +202,7 @@ func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
for _, txIn := range otx.tx.MsgTx().TxIn { for _, txIn := range otx.tx.MsgTx().TxIn {
orphans, exists := mp.orphansByPrev[txIn.PreviousOutPoint] orphans, exists := mp.orphansByPrev[txIn.PreviousOutPoint]
if exists { if exists {
delete(orphans, *txHash) delete(orphans, *txID)
// Remove the map entry altogether if there are no // Remove the map entry altogether if there are no
// longer any orphans which depend on it. // longer any orphans which depend on it.
@ -214,7 +214,7 @@ func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
// Remove any orphans that redeem outputs from this one if requested. // Remove any orphans that redeem outputs from this one if requested.
if removeRedeemers { if removeRedeemers {
prevOut := wire.OutPoint{Hash: *txHash} prevOut := wire.OutPoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut { for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx) prevOut.Index = uint32(txOutIdx)
for _, orphan := range mp.orphansByPrev[prevOut] { for _, orphan := range mp.orphansByPrev[prevOut] {
@ -224,7 +224,7 @@ func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
} }
// Remove the transaction from the orphan pool. // Remove the transaction from the orphan pool.
delete(mp.orphans, *txHash) delete(mp.orphans, *txID)
} }
// RemoveOrphan removes the passed orphan transaction from the orphan pool and // RemoveOrphan removes the passed orphan transaction from the orphan pool and
@ -321,7 +321,7 @@ func (mp *TxPool) addOrphan(tx *util.Tx, tag Tag) {
// orphan if space is still needed. // orphan if space is still needed.
mp.limitNumOrphans() mp.limitNumOrphans()
mp.orphans[*tx.Hash()] = &orphanTx{ mp.orphans[*tx.ID()] = &orphanTx{
tx: tx, tx: tx,
tag: tag, tag: tag,
expiration: time.Now().Add(orphanTTL), expiration: time.Now().Add(orphanTTL),
@ -331,10 +331,10 @@ func (mp *TxPool) addOrphan(tx *util.Tx, tag Tag) {
mp.orphansByPrev[txIn.PreviousOutPoint] = mp.orphansByPrev[txIn.PreviousOutPoint] =
make(map[daghash.Hash]*util.Tx) make(map[daghash.Hash]*util.Tx)
} }
mp.orphansByPrev[txIn.PreviousOutPoint][*tx.Hash()] = tx mp.orphansByPrev[txIn.PreviousOutPoint][*tx.ID()] = tx
} }
log.Debugf("Stored orphan transaction %v (total: %d)", tx.Hash(), log.Debugf("Stored orphan transaction %v (total: %d)", tx.ID(),
len(mp.orphans)) len(mp.orphans))
} }
@ -458,11 +458,11 @@ func (mp *TxPool) HaveTransaction(hash *daghash.Hash) bool {
// //
// This function MUST be called with the mempool lock held (for writes). // This function MUST be called with the mempool lock held (for writes).
func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreInputs bool) error { func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreInputs bool) error {
txHash := tx.Hash() txID := tx.ID()
if removeRedeemers { if removeRedeemers {
// Remove any transactions which rely on this one. // Remove any transactions which rely on this one.
for i := uint32(0); i < uint32(len(tx.MsgTx().TxOut)); i++ { for i := uint32(0); i < uint32(len(tx.MsgTx().TxOut)); i++ {
prevOut := wire.OutPoint{Hash: *txHash, Index: i} prevOut := wire.OutPoint{TxID: *txID, Index: i}
if txRedeemer, exists := mp.outpoints[prevOut]; exists { if txRedeemer, exists := mp.outpoints[prevOut]; exists {
mp.removeTransaction(txRedeemer, true, false) mp.removeTransaction(txRedeemer, true, false)
} }
@ -470,11 +470,11 @@ func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreIn
} }
// Remove the transaction if needed. // Remove the transaction if needed.
if txDesc, exists := mp.pool[*txHash]; exists { if txDesc, exists := mp.pool[*txID]; exists {
// Remove unconfirmed address index entries associated with the // Remove unconfirmed address index entries associated with the
// transaction if enabled. // transaction if enabled.
if mp.cfg.AddrIndex != nil { if mp.cfg.AddrIndex != nil {
mp.cfg.AddrIndex.RemoveUnconfirmedTx(txHash) mp.cfg.AddrIndex.RemoveUnconfirmedTx(txID)
} }
diff := blockdag.NewUTXODiff() diff := blockdag.NewUTXODiff()
@ -483,7 +483,7 @@ func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreIn
// Mark the referenced outpoints as unspent by the pool. // Mark the referenced outpoints as unspent by the pool.
for _, txIn := range txDesc.Tx.MsgTx().TxIn { for _, txIn := range txDesc.Tx.MsgTx().TxIn {
if restoreInputs { if restoreInputs {
if prevTxDesc, exists := mp.pool[txIn.PreviousOutPoint.Hash]; exists { if prevTxDesc, exists := mp.pool[txIn.PreviousOutPoint.TxID]; exists {
prevOut := prevTxDesc.Tx.MsgTx().TxOut[txIn.PreviousOutPoint.Index] prevOut := prevTxDesc.Tx.MsgTx().TxOut[txIn.PreviousOutPoint.Index]
entry := blockdag.NewUTXOEntry(prevOut, false, mining.UnminedHeight) entry := blockdag.NewUTXOEntry(prevOut, false, mining.UnminedHeight)
diff.AddEntry(txIn.PreviousOutPoint, entry) diff.AddEntry(txIn.PreviousOutPoint, entry)
@ -491,7 +491,7 @@ func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreIn
} }
delete(mp.outpoints, txIn.PreviousOutPoint) delete(mp.outpoints, txIn.PreviousOutPoint)
} }
delete(mp.pool, *txHash) delete(mp.pool, *txID)
var err error var err error
mp.mpUTXOSet, err = mp.mpUTXOSet.WithDiff(diff) mp.mpUTXOSet, err = mp.mpUTXOSet.WithDiff(diff)
if err != nil { if err != nil {
@ -527,7 +527,7 @@ func (mp *TxPool) RemoveDoubleSpends(tx *util.Tx) {
mp.mtx.Lock() mp.mtx.Lock()
for _, txIn := range tx.MsgTx().TxIn { for _, txIn := range tx.MsgTx().TxIn {
if txRedeemer, ok := mp.outpoints[txIn.PreviousOutPoint]; ok { if txRedeemer, ok := mp.outpoints[txIn.PreviousOutPoint]; ok {
if !txRedeemer.Hash().IsEqual(tx.Hash()) { if !txRedeemer.ID().IsEqual(tx.ID()) {
mp.removeTransaction(txRedeemer, true, false) mp.removeTransaction(txRedeemer, true, false)
} }
} }
@ -556,7 +556,7 @@ func (mp *TxPool) addTransaction(tx *util.Tx, height int32, fee uint64) *TxDesc
StartingPriority: mining.CalcPriority(tx.MsgTx(), mp.mpUTXOSet, height), StartingPriority: mining.CalcPriority(tx.MsgTx(), mp.mpUTXOSet, height),
} }
mp.pool[*tx.Hash()] = txD mp.pool[*tx.ID()] = txD
for _, txIn := range tx.MsgTx().TxIn { for _, txIn := range tx.MsgTx().TxIn {
mp.outpoints[txIn.PreviousOutPoint] = tx mp.outpoints[txIn.PreviousOutPoint] = tx
} }
@ -612,10 +612,10 @@ func (mp *TxPool) CheckSpend(op wire.OutPoint) *util.Tx {
// orphans. // orphans.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) FetchTransaction(txHash *daghash.Hash) (*util.Tx, error) { func (mp *TxPool) FetchTransaction(txID *daghash.Hash) (*util.Tx, error) {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
txDesc, exists := mp.pool[*txHash] txDesc, exists := mp.pool[*txID]
mp.mtx.RUnlock() mp.mtx.RUnlock()
if exists { if exists {
@ -633,16 +633,16 @@ func (mp *TxPool) FetchTransaction(txHash *daghash.Hash) (*util.Tx, error) {
func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDupOrphans bool) ([]*daghash.Hash, *TxDesc, error) { func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDupOrphans bool) ([]*daghash.Hash, *TxDesc, error) {
mp.cfg.DAG.UTXORLock() mp.cfg.DAG.UTXORLock()
defer mp.cfg.DAG.UTXORUnlock() defer mp.cfg.DAG.UTXORUnlock()
txHash := tx.Hash() txID := tx.ID()
// Don't accept the transaction if it already exists in the pool. This // Don't accept the transaction if it already exists in the pool. This
// applies to orphan transactions as well when the reject duplicate // applies to orphan transactions as well when the reject duplicate
// orphans flag is set. This check is intended to be a quick check to // orphans flag is set. This check is intended to be a quick check to
// weed out duplicates. // weed out duplicates.
if mp.isTransactionInPool(txHash) || (rejectDupOrphans && if mp.isTransactionInPool(txID) || (rejectDupOrphans &&
mp.isOrphanInPool(txHash)) { mp.isOrphanInPool(txID)) {
str := fmt.Sprintf("already have transaction %v", txHash) str := fmt.Sprintf("already have transaction %v", txID)
return nil, nil, txRuleError(wire.RejectDuplicate, str) return nil, nil, txRuleError(wire.RejectDuplicate, str)
} }
@ -685,7 +685,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// A standalone transaction must not be a coinbase transaction. // A standalone transaction must not be a coinbase transaction.
if blockdag.IsCoinBase(tx) { if blockdag.IsCoinBase(tx) {
str := fmt.Sprintf("transaction %v is an individual coinbase", str := fmt.Sprintf("transaction %v is an individual coinbase",
txHash) txID)
return nil, nil, txRuleError(wire.RejectInvalid, str) return nil, nil, txRuleError(wire.RejectInvalid, str)
} }
@ -711,7 +711,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
rejectCode = wire.RejectNonstandard rejectCode = wire.RejectNonstandard
} }
str := fmt.Sprintf("transaction %v is not standard: %v", str := fmt.Sprintf("transaction %v is not standard: %v",
txHash, err) txID, err)
return nil, nil, txRuleError(rejectCode, str) return nil, nil, txRuleError(rejectCode, str)
} }
} }
@ -731,7 +731,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Don't allow the transaction if it exists in the DAG and is // Don't allow the transaction if it exists in the DAG and is
// not already fully spent. // not already fully spent.
prevOut := wire.OutPoint{Hash: *txHash} prevOut := wire.OutPoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut { for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx) prevOut.Index = uint32(txOutIdx)
_, ok := mp.mpUTXOSet.Get(prevOut) _, ok := mp.mpUTXOSet.Get(prevOut)
@ -752,7 +752,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// is replaced and taking its address directly would // is replaced and taking its address directly would
// result in all of the entries pointing to the same // result in all of the entries pointing to the same
// memory location and thus all be the final hash. // memory location and thus all be the final hash.
hashCopy := txIn.PreviousOutPoint.Hash hashCopy := txIn.PreviousOutPoint.TxID
missingParents = append(missingParents, &hashCopy) missingParents = append(missingParents, &hashCopy)
} }
} }
@ -802,7 +802,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
rejectCode = wire.RejectNonstandard rejectCode = wire.RejectNonstandard
} }
str := fmt.Sprintf("transaction %v has a non-standard "+ str := fmt.Sprintf("transaction %v has a non-standard "+
"input: %v", txHash, err) "input: %v", txID, err)
return nil, nil, txRuleError(rejectCode, str) return nil, nil, txRuleError(rejectCode, str)
} }
} }
@ -825,7 +825,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
} }
if sigOpCount > mp.cfg.Policy.MaxSigOpsPerTx { if sigOpCount > mp.cfg.Policy.MaxSigOpsPerTx {
str := fmt.Sprintf("transaction %v sigop count is too high: %d > %d", str := fmt.Sprintf("transaction %v sigop count is too high: %d > %d",
txHash, sigOpCount, mp.cfg.Policy.MaxSigOpsPerTx) txID, sigOpCount, mp.cfg.Policy.MaxSigOpsPerTx)
return nil, nil, txRuleError(wire.RejectNonstandard, str) return nil, nil, txRuleError(wire.RejectNonstandard, str)
} }
@ -845,7 +845,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
mp.cfg.Policy.MinRelayTxFee)) mp.cfg.Policy.MinRelayTxFee))
if serializedSize >= (DefaultBlockPrioritySize-1000) && txFee < minFee { if serializedSize >= (DefaultBlockPrioritySize-1000) && txFee < minFee {
str := fmt.Sprintf("transaction %v has %d fees which is under "+ str := fmt.Sprintf("transaction %v has %d fees which is under "+
"the required amount of %d", txHash, txFee, "the required amount of %d", txID, txFee,
minFee) minFee)
return nil, nil, txRuleError(wire.RejectInsufficientFee, str) return nil, nil, txRuleError(wire.RejectInsufficientFee, str)
} }
@ -859,7 +859,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
nextBlockHeight) nextBlockHeight)
if currentPriority <= mining.MinHighPriority { if currentPriority <= mining.MinHighPriority {
str := fmt.Sprintf("transaction %v has insufficient "+ str := fmt.Sprintf("transaction %v has insufficient "+
"priority (%g <= %g)", txHash, "priority (%g <= %g)", txID,
currentPriority, mining.MinHighPriority) currentPriority, mining.MinHighPriority)
return nil, nil, txRuleError(wire.RejectInsufficientFee, str) return nil, nil, txRuleError(wire.RejectInsufficientFee, str)
} }
@ -878,7 +878,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Are we still over the limit? // Are we still over the limit?
if mp.pennyTotal >= mp.cfg.Policy.FreeTxRelayLimit*10*1000 { if mp.pennyTotal >= mp.cfg.Policy.FreeTxRelayLimit*10*1000 {
str := fmt.Sprintf("transaction %v has been rejected "+ str := fmt.Sprintf("transaction %v has been rejected "+
"by the rate limiter due to low fees", txHash) "by the rate limiter due to low fees", txID)
return nil, nil, txRuleError(wire.RejectInsufficientFee, str) return nil, nil, txRuleError(wire.RejectInsufficientFee, str)
} }
oldTotal := mp.pennyTotal oldTotal := mp.pennyTotal
@ -903,7 +903,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Add to transaction pool. // Add to transaction pool.
txD := mp.addTransaction(tx, bestHeight, txFee) txD := mp.addTransaction(tx, bestHeight, txFee)
log.Debugf("Accepted transaction %v (pool size: %v)", txHash, log.Debugf("Accepted transaction %v (pool size: %v)", txID,
len(mp.pool)) len(mp.pool))
return nil, txD, nil return nil, txD, nil
@ -944,7 +944,7 @@ func (mp *TxPool) processOrphans(acceptedTx *util.Tx) []*TxDesc {
firstElement := processList.Remove(processList.Front()) firstElement := processList.Remove(processList.Front())
processItem := firstElement.(*util.Tx) processItem := firstElement.(*util.Tx)
prevOut := wire.OutPoint{Hash: *processItem.Hash()} prevOut := wire.OutPoint{TxID: *processItem.ID()}
for txOutIdx := range processItem.MsgTx().TxOut { for txOutIdx := range processItem.MsgTx().TxOut {
// Look up all orphans that redeem the output that is // Look up all orphans that redeem the output that is
// now available. This will typically only be one, but // now available. This will typically only be one, but
@ -1042,7 +1042,7 @@ func (mp *TxPool) ProcessOrphans(acceptedTx *util.Tx) []*TxDesc {
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) ProcessTransaction(tx *util.Tx, allowOrphan, rateLimit bool, tag Tag) ([]*TxDesc, error) { func (mp *TxPool) ProcessTransaction(tx *util.Tx, allowOrphan, rateLimit bool, tag Tag) ([]*TxDesc, error) {
log.Tracef("Processing transaction %v", tx.Hash()) log.Tracef("Processing transaction %v", tx.ID())
// Protect concurrent access. // Protect concurrent access.
mp.mtx.Lock() mp.mtx.Lock()
@ -1085,7 +1085,7 @@ func (mp *TxPool) ProcessTransaction(tx *util.Tx, allowOrphan, rateLimit bool, t
// which is not really always the case. // which is not really always the case.
str := fmt.Sprintf("orphan transaction %v references "+ str := fmt.Sprintf("orphan transaction %v references "+
"outputs of unknown or fully-spent "+ "outputs of unknown or fully-spent "+
"transaction %v", tx.Hash(), missingParents[0]) "transaction %v", tx.ID(), missingParents[0])
return nil, txRuleError(wire.RejectDuplicate, str) return nil, txRuleError(wire.RejectDuplicate, str)
} }
@ -1106,22 +1106,22 @@ func (mp *TxPool) Count() int {
return count return count
} }
// TxHashes returns a slice of hashes for all of the transactions in the memory // TxIDs returns a slice of IDs for all of the transactions in the memory
// pool. // pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) TxHashes() []*daghash.Hash { func (mp *TxPool) TxIDs() []*daghash.Hash {
mp.mtx.RLock() mp.mtx.RLock()
hashes := make([]*daghash.Hash, len(mp.pool)) ids := make([]*daghash.Hash, len(mp.pool))
i := 0 i := 0
for hash := range mp.pool { for txID := range mp.pool {
hashCopy := hash idCopy := txID
hashes[i] = &hashCopy ids[i] = &idCopy
i++ i++
} }
mp.mtx.RUnlock() mp.mtx.RUnlock()
return hashes return ids
} }
// TxDescs returns a slice of descriptors for all the transactions in the pool. // TxDescs returns a slice of descriptors for all the transactions in the pool.
@ -1189,14 +1189,14 @@ func (mp *TxPool) RawMempoolVerbose() map[string]*btcjson.GetRawMempoolVerboseRe
Depends: make([]string, 0), Depends: make([]string, 0),
} }
for _, txIn := range tx.MsgTx().TxIn { for _, txIn := range tx.MsgTx().TxIn {
hash := &txIn.PreviousOutPoint.Hash hash := &txIn.PreviousOutPoint.TxID
if mp.haveTransaction(hash) { if mp.haveTransaction(hash) {
mpd.Depends = append(mpd.Depends, mpd.Depends = append(mpd.Depends,
hash.String()) hash.String())
} }
} }
result[tx.Hash().String()] = mpd result[tx.ID().String()] = mpd
} }
return result return result

97
mempool/mempool_test.go
View File

@ -9,7 +9,6 @@ import (
"encoding/hex" "encoding/hex"
"errors" "errors"
"fmt" "fmt"
"github.com/daglabs/btcd/util/subnetworkid"
"math" "math"
"reflect" "reflect"
"runtime" "runtime"
@ -17,6 +16,8 @@ import (
"testing" "testing"
"time" "time"
"github.com/daglabs/btcd/util/subnetworkid"
"bou.ke/monkey" "bou.ke/monkey"
"github.com/daglabs/btcd/blockdag" "github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/blockdag/indexers" "github.com/daglabs/btcd/blockdag/indexers"
@ -91,7 +92,7 @@ type spendableOutpoint struct {
// transactions. // transactions.
func txOutToSpendableOutpoint(tx *util.Tx, outputNum uint32) spendableOutpoint { func txOutToSpendableOutpoint(tx *util.Tx, outputNum uint32) spendableOutpoint {
return spendableOutpoint{ return spendableOutpoint{
outPoint: wire.OutPoint{Hash: *tx.Hash(), Index: outputNum}, outPoint: wire.OutPoint{TxID: *tx.ID(), Index: outputNum},
amount: util.Amount(tx.MsgTx().TxOut[outputNum].Value), amount: util.Amount(tx.MsgTx().TxOut[outputNum].Value),
} }
} }
@ -248,7 +249,7 @@ func (p *poolHarness) CreateTxChain(firstOutput spendableOutpoint, numTxns uint3
txChain = append(txChain, util.NewTx(tx)) txChain = append(txChain, util.NewTx(tx))
// Next transaction uses outputs from this one. // Next transaction uses outputs from this one.
prevOutPoint = wire.OutPoint{Hash: tx.TxHash(), Index: 0} prevOutPoint = wire.OutPoint{TxID: tx.TxID(), Index: 0}
} }
return txChain, nil return txChain, nil
@ -358,22 +359,22 @@ type testContext struct {
// should be reported as available by the HaveTransaction function based upon // should be reported as available by the HaveTransaction function based upon
// the two flags and tests that condition as well. // the two flags and tests that condition as well.
func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool bool) { func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool bool) {
txHash := tx.Hash() txID := tx.ID()
gotOrphanPool := tc.harness.txPool.IsOrphanInPool(txHash) gotOrphanPool := tc.harness.txPool.IsOrphanInPool(txID)
if inOrphanPool != gotOrphanPool { if inOrphanPool != gotOrphanPool {
_, file, line, _ := runtime.Caller(1) _, file, line, _ := runtime.Caller(1)
tc.t.Fatalf("%s:%d -- IsOrphanInPool: want %v, got %v", file, tc.t.Fatalf("%s:%d -- IsOrphanInPool: want %v, got %v", file,
line, inOrphanPool, gotOrphanPool) line, inOrphanPool, gotOrphanPool)
} }
gotTxPool := tc.harness.txPool.IsTransactionInPool(txHash) gotTxPool := tc.harness.txPool.IsTransactionInPool(txID)
if inTxPool != gotTxPool { if inTxPool != gotTxPool {
_, file, line, _ := runtime.Caller(1) _, file, line, _ := runtime.Caller(1)
tc.t.Fatalf("%s:%d -- IsTransactionInPool: want %v, got %v", tc.t.Fatalf("%s:%d -- IsTransactionInPool: want %v, got %v",
file, line, inTxPool, gotTxPool) file, line, inTxPool, gotTxPool)
} }
gotHaveTx := tc.harness.txPool.HaveTransaction(txHash) gotHaveTx := tc.harness.txPool.HaveTransaction(txID)
wantHaveTx := inOrphanPool || inTxPool wantHaveTx := inOrphanPool || inTxPool
if wantHaveTx != gotHaveTx { if wantHaveTx != gotHaveTx {
_, file, line, _ := runtime.Caller(1) _, file, line, _ := runtime.Caller(1)
@ -382,27 +383,27 @@ func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool boo
} }
count := tc.harness.txPool.Count() count := tc.harness.txPool.Count()
txHashes := tc.harness.txPool.TxHashes() txIDs := tc.harness.txPool.TxIDs()
txDescs := tc.harness.txPool.TxDescs() txDescs := tc.harness.txPool.TxDescs()
txMiningDescs := tc.harness.txPool.MiningDescs() txMiningDescs := tc.harness.txPool.MiningDescs()
if count != len(txHashes) || count != len(txDescs) || count != len(txMiningDescs) { if count != len(txIDs) || count != len(txDescs) || count != len(txMiningDescs) {
tc.t.Error("mempool.TxHashes(), mempool.TxDescs() and mempool.MiningDescs() have different length") tc.t.Error("mempool.TxIDs(), mempool.TxDescs() and mempool.MiningDescs() have different length")
} }
if inTxPool { if inTxPool {
wasFound := false wasFound := false
for _, txh := range txHashes { for _, txI := range txIDs {
if *txHash == *txh { if *txID == *txI {
wasFound = true wasFound = true
break break
} }
} }
if !wasFound { if !wasFound {
tc.t.Error("Can not find transaction in mempool.TxHashes") tc.t.Error("Can not find transaction in mempool.TxIDs")
} }
wasFound = false wasFound = false
for _, txd := range txDescs { for _, txd := range txDescs {
if *txHash == *txd.Tx.Hash() { if *txID == *txd.Tx.ID() {
wasFound = true wasFound = true
break break
} }
@ -413,7 +414,7 @@ func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool boo
wasFound = false wasFound = false
for _, txd := range txMiningDescs { for _, txd := range txMiningDescs {
if *txHash == *txd.Tx.Hash() { if *txID == *txd.Tx.ID() {
wasFound = true wasFound = true
break break
} }
@ -476,7 +477,7 @@ func TestProcessTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -590,7 +591,7 @@ func TestProcessTransaction(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err) t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
} }
dummyPrevOut := wire.OutPoint{Hash: *dummyPrevOutHash, Index: 1} dummyPrevOut := wire.OutPoint{TxID: *dummyPrevOutHash, Index: 1}
dummySigScript := bytes.Repeat([]byte{0x00}, 65) dummySigScript := bytes.Repeat([]byte{0x00}, 65)
addrHash := [20]byte{0x01} addrHash := [20]byte{0x01}
@ -618,7 +619,7 @@ func TestProcessTransaction(t *testing.T) {
nonStdSigScriptTx := util.NewTx(&wire.MsgTx{ nonStdSigScriptTx := util.NewTx(&wire.MsgTx{
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{Hash: *p2shTx.Hash(), Index: 0}, PreviousOutPoint: wire.OutPoint{TxID: *p2shTx.ID(), Index: 0},
SignatureScript: wrappedP2SHNonStdSigScript, SignatureScript: wrappedP2SHNonStdSigScript,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}}, }},
@ -640,7 +641,7 @@ func TestProcessTransaction(t *testing.T) {
"transaction input #%d has "+ "transaction input #%d has "+
"%d signature operations which is more "+ "%d signature operations which is more "+
"than the allowed max amount of %d", "than the allowed max amount of %d",
nonStdSigScriptTx.Hash(), 0, 16, 15) nonStdSigScriptTx.ID(), 0, 16, 15)
if expectedErrStr != err.Error() { if expectedErrStr != err.Error() {
t.Errorf("Unexpected error message. Expected \"%s\" but got \"%s\"", expectedErrStr, err.Error()) t.Errorf("Unexpected error message. Expected \"%s\" but got \"%s\"", expectedErrStr, err.Error())
} }
@ -656,7 +657,7 @@ func TestProcessTransaction(t *testing.T) {
t.Errorf("Unexpected error code. Expected %v but got %v", wire.RejectNonstandard, code) t.Errorf("Unexpected error code. Expected %v but got %v", wire.RejectNonstandard, code)
} }
expectedErrStr = fmt.Sprintf("transaction %v sigop count is too high: %v > %v", expectedErrStr = fmt.Sprintf("transaction %v sigop count is too high: %v > %v",
nonStdSigScriptTx.Hash(), 16, 15) nonStdSigScriptTx.ID(), 16, 15)
if expectedErrStr != err.Error() { if expectedErrStr != err.Error() {
t.Errorf("Unexpected error message. Expected \"%s\" but got \"%s\"", expectedErrStr, err.Error()) t.Errorf("Unexpected error message. Expected \"%s\" but got \"%s\"", expectedErrStr, err.Error())
} }
@ -889,14 +890,14 @@ func TestFetchTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
} }
harness.txPool.ProcessTransaction(orphanedTx, true, false, 0) harness.txPool.ProcessTransaction(orphanedTx, true, false, 0)
testPoolMembership(tc, orphanedTx, true, false) testPoolMembership(tc, orphanedTx, true, false)
fetchedorphanedTx, err := harness.txPool.FetchTransaction(orphanedTx.Hash()) fetchedorphanedTx, err := harness.txPool.FetchTransaction(orphanedTx.ID())
if fetchedorphanedTx != nil { if fetchedorphanedTx != nil {
t.Fatalf("FetchTransaction: expected fetchedorphanedTx to be nil") t.Fatalf("FetchTransaction: expected fetchedorphanedTx to be nil")
} }
@ -910,7 +911,7 @@ func TestFetchTransaction(t *testing.T) {
} }
harness.txPool.ProcessTransaction(tx, true, false, 0) harness.txPool.ProcessTransaction(tx, true, false, 0)
testPoolMembership(tc, tx, false, true) testPoolMembership(tc, tx, false, true)
fetchedTx, err := harness.txPool.FetchTransaction(tx.Hash()) fetchedTx, err := harness.txPool.FetchTransaction(tx.ID())
if !reflect.DeepEqual(fetchedTx, tx) { if !reflect.DeepEqual(fetchedTx, tx) {
t.Fatalf("FetchTransaction: returned a transaction, but not the right one") t.Fatalf("FetchTransaction: returned a transaction, but not the right one")
} }
@ -1009,7 +1010,7 @@ func TestOrphanReject(t *testing.T) {
false, 0) false, 0)
if err == nil { if err == nil {
t.Fatalf("ProcessTransaction: did not fail on orphan "+ t.Fatalf("ProcessTransaction: did not fail on orphan "+
"%v when allow orphans flag is false", tx.Hash()) "%v when allow orphans flag is false", tx.ID())
} }
expectedErr := RuleError{} expectedErr := RuleError{}
if reflect.TypeOf(err) != reflect.TypeOf(expectedErr) { if reflect.TypeOf(err) != reflect.TypeOf(expectedErr) {
@ -1052,15 +1053,15 @@ func TestOrphanExpiration(t *testing.T) {
expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{ expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(expiredTx, true, harness.txPool.ProcessTransaction(expiredTx, true,
false, 0) false, 0)
harness.txPool.orphans[*expiredTx.Hash()].expiration = time.Unix(0, 0) harness.txPool.orphans[*expiredTx.ID()].expiration = time.Unix(0, 0)
tx1, err := harness.CreateSignedTx([]spendableOutpoint{{ tx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(tx1, true, harness.txPool.ProcessTransaction(tx1, true,
false, 0) false, 0)
@ -1075,7 +1076,7 @@ func TestOrphanExpiration(t *testing.T) {
tx2, err := harness.CreateSignedTx([]spendableOutpoint{{ tx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{2}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(tx2, true, harness.txPool.ProcessTransaction(tx2, true,
false, 0) false, 0)
@ -1098,7 +1099,7 @@ func TestMaxOrphanTxSize(t *testing.T) {
tx, err := harness.CreateSignedTx([]spendableOutpoint{{ tx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1204,7 +1205,7 @@ func TestOrphanEviction(t *testing.T) {
// evicted matches the expected number. // evicted matches the expected number.
var evictedTxns []*util.Tx var evictedTxns []*util.Tx
for _, tx := range chainedTxns[1:] { for _, tx := range chainedTxns[1:] {
if !harness.txPool.IsOrphanInPool(tx.Hash()) { if !harness.txPool.IsOrphanInPool(tx.ID()) {
evictedTxns = append(evictedTxns, tx) evictedTxns = append(evictedTxns, tx)
} }
} }
@ -1233,7 +1234,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1242,7 +1243,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1) false, 1)
orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{2}, Index: 2}, outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 2},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1251,7 +1252,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1) false, 1)
orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{3}, Index: 3}, outPoint: wire.OutPoint{TxID: daghash.Hash{3}, Index: 3},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1261,7 +1262,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{4}, Index: 4}, outPoint: wire.OutPoint{TxID: daghash.Hash{4}, Index: 4},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1322,7 +1323,7 @@ func TestBasicOrphanRemoval(t *testing.T) {
// and ensure the state of all other orphans are unaffected. // and ensure the state of all other orphans are unaffected.
nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{ nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1547,7 +1548,7 @@ func TestCheckSpend(t *testing.T) {
// Now all but the last tx should be spent by the next. // Now all but the last tx should be spent by the next.
for i := 0; i < len(chainedTxns)-1; i++ { for i := 0; i < len(chainedTxns)-1; i++ {
op = wire.OutPoint{ op = wire.OutPoint{
Hash: *chainedTxns[i].Hash(), TxID: *chainedTxns[i].ID(),
Index: 0, Index: 0,
} }
expSpend := chainedTxns[i+1] expSpend := chainedTxns[i+1]
@ -1560,7 +1561,7 @@ func TestCheckSpend(t *testing.T) {
// The last tx should have no spend. // The last tx should have no spend.
op = wire.OutPoint{ op = wire.OutPoint{
Hash: *chainedTxns[txChainLength-1].Hash(), TxID: *chainedTxns[txChainLength-1].ID(),
Index: 0, Index: 0,
} }
spend = harness.txPool.CheckSpend(op) spend = harness.txPool.CheckSpend(op)
@ -1694,10 +1695,10 @@ func TestHandleNewBlock(t *testing.T) {
} }
// Create orphan transaction and add it to UTXO set // Create orphan transaction and add it to UTXO set
hash := blockTx1.Hash() txID := blockTx1.ID()
orphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(2500000000), amount: util.Amount(2500000000),
outPoint: wire.OutPoint{Hash: *hash, Index: 0}, outPoint: wire.OutPoint{TxID: *txID, Index: 0},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1720,7 +1721,7 @@ func TestHandleNewBlock(t *testing.T) {
block := util.NewBlock(&dummyBlock) block := util.NewBlock(&dummyBlock)
for i, tx := range block.Transactions() { for i, tx := range block.Transactions() {
if !harness.txPool.mpUTXOSet.AddTx(tx.MsgTx(), 1) { if !harness.txPool.mpUTXOSet.AddTx(tx.MsgTx(), 1) {
t.Fatalf("Failed to add transaction %v to UTXO set: %v", i, tx.Hash()) t.Fatalf("Failed to add transaction %v to UTXO set: %v", i, tx.ID())
} }
} }
@ -1734,8 +1735,8 @@ func TestHandleNewBlock(t *testing.T) {
// process messages pushed by HandleNewBlock // process messages pushed by HandleNewBlock
blockTransnactions := make(map[daghash.Hash]int) blockTransnactions := make(map[daghash.Hash]int)
for msg := range ch { for msg := range ch {
blockTransnactions[*msg.Tx.Hash()] = 1 blockTransnactions[*msg.Tx.ID()] = 1
if *msg.Tx.Hash() != *blockTx1.Hash() { if *msg.Tx.ID() != *blockTx1.ID() {
if len(msg.AcceptedTxs) != 0 { if len(msg.AcceptedTxs) != 0 {
t.Fatalf("Expected amount of accepted transactions 0. Got: %v", len(msg.AcceptedTxs)) t.Fatalf("Expected amount of accepted transactions 0. Got: %v", len(msg.AcceptedTxs))
} }
@ -1743,8 +1744,8 @@ func TestHandleNewBlock(t *testing.T) {
if len(msg.AcceptedTxs) != 1 { if len(msg.AcceptedTxs) != 1 {
t.Fatalf("Wrong accepted transactions length") t.Fatalf("Wrong accepted transactions length")
} }
if *msg.AcceptedTxs[0].Tx.Hash() != *orphanTx.Hash() { if *msg.AcceptedTxs[0].Tx.ID() != *orphanTx.ID() {
t.Fatalf("Wrong accepted transaction hash") t.Fatalf("Wrong accepted transaction ID")
} }
} }
} }
@ -1758,11 +1759,11 @@ func TestHandleNewBlock(t *testing.T) {
t.Fatalf("Wrong size of blockTransnactions after new block handling") t.Fatalf("Wrong size of blockTransnactions after new block handling")
} }
if _, ok := blockTransnactions[*blockTx1.Hash()]; !ok { if _, ok := blockTransnactions[*blockTx1.ID()]; !ok {
t.Fatalf("Transaction 1 of new block is not handled") t.Fatalf("Transaction 1 of new block is not handled")
} }
if _, ok := blockTransnactions[*blockTx2.Hash()]; !ok { if _, ok := blockTransnactions[*blockTx2.ID()]; !ok {
t.Fatalf("Transaction 2 of new block is not handled") t.Fatalf("Transaction 2 of new block is not handled")
} }
@ -1787,7 +1788,7 @@ var dummyBlock = wire.MsgBlock{
0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03, 0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03,
0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11, 0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11,
}}, // SimNet genesis }}, // SimNet genesis
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0, 0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22, 0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85, 0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
@ -1803,7 +1804,7 @@ var dummyBlock = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

2
mempool/policy_test.go
View File

@ -283,7 +283,7 @@ func TestCheckTransactionStandard(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err) t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
} }
dummyPrevOut := wire.OutPoint{Hash: *prevOutHash, Index: 1} dummyPrevOut := wire.OutPoint{TxID: *prevOutHash, Index: 1}
dummySigScript := bytes.Repeat([]byte{0x00}, 65) dummySigScript := bytes.Repeat([]byte{0x00}, 65)
dummyTxIn := wire.TxIn{ dummyTxIn := wire.TxIn{
PreviousOutPoint: dummyPrevOut, PreviousOutPoint: dummyPrevOut,

50
mining/mining.go
View File

@ -7,6 +7,7 @@ package mining
import ( import (
"container/heap" "container/heap"
"fmt" "fmt"
"math/rand"
"sort" "sort"
"time" "time"
@ -395,7 +396,9 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
// ensure the transaction is not a duplicate transaction (paying the // ensure the transaction is not a duplicate transaction (paying the
// same value to the same public key address would otherwise be an // same value to the same public key address would otherwise be an
// identical transaction for block version 1). // identical transaction for block version 1).
extraNonce := uint64(0) seed := rand.NewSource(time.Now().UnixNano())
randomGenerator := rand.New(seed)
extraNonce := randomGenerator.Uint64()
coinbaseScript, err := standardCoinbaseScript(nextBlockHeight, extraNonce) coinbaseScript, err := standardCoinbaseScript(nextBlockHeight, extraNonce)
if err != nil { if err != nil {
return nil, err return nil, err
@ -444,13 +447,13 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
// non-finalized transactions. // non-finalized transactions.
tx := txDesc.Tx tx := txDesc.Tx
if blockdag.IsCoinBase(tx) { if blockdag.IsCoinBase(tx) {
log.Tracef("Skipping coinbase tx %s", tx.Hash()) log.Tracef("Skipping coinbase tx %s", tx.ID())
continue continue
} }
if !blockdag.IsFinalizedTransaction(tx, nextBlockHeight, if !blockdag.IsFinalizedTransaction(tx, nextBlockHeight,
g.timeSource.AdjustedTime()) { g.timeSource.AdjustedTime()) {
log.Tracef("Skipping non-finalized tx %s", tx.Hash()) log.Tracef("Skipping non-finalized tx %s", tx.ID())
continue continue
} }
@ -499,7 +502,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
txGas := tx.MsgTx().Gas txGas := tx.MsgTx().Gas
if gasLimit-gasUsage < txGas { if gasLimit-gasUsage < txGas {
log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subnetwork %v (GASLimit=%v)", log.Tracef("Transaction %v (GAS=%v) ignored because gas overusage (GASUsage=%v) in subnetwork %v (GASLimit=%v)",
tx.MsgTx().TxHash, txGas, gasUsage, subnetworkID, gasLimit) tx.MsgTx().TxID(), txGas, gasUsage, subnetworkID, gasLimit)
continue continue
} }
gasUsageMap[subnetworkID] = gasUsage + txGas gasUsageMap[subnetworkID] = gasUsage + txGas
@ -512,7 +515,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
blockPlusTxSize >= g.policy.BlockMaxSize { blockPlusTxSize >= g.policy.BlockMaxSize {
log.Tracef("Skipping tx %s because it would exceed "+ log.Tracef("Skipping tx %s because it would exceed "+
"the max block size", tx.Hash()) "the max block size", tx.ID())
continue continue
} }
@ -522,21 +525,21 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
if blockSigOps+numSigOps < blockSigOps || if blockSigOps+numSigOps < blockSigOps ||
blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock { blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock {
log.Tracef("Skipping tx %s because it would exceed "+ log.Tracef("Skipping tx %s because it would exceed "+
"the maximum sigops per block", tx.Hash()) "the maximum sigops per block", tx.ID())
continue continue
} }
numP2SHSigOps, err := blockdag.CountP2SHSigOps(tx, false, numP2SHSigOps, err := blockdag.CountP2SHSigOps(tx, false,
blockUtxos) blockUtxos)
if err != nil { if err != nil {
log.Tracef("Skipping tx %s due to error in "+ log.Tracef("Skipping tx %s due to error in "+
"GetSigOpCost: %v", tx.Hash(), err) "GetSigOpCost: %v", tx.ID(), err)
continue continue
} }
numSigOps += int64(numP2SHSigOps) numSigOps += int64(numP2SHSigOps)
if blockSigOps+numSigOps < blockSigOps || if blockSigOps+numSigOps < blockSigOps ||
blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock { blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock {
log.Tracef("Skipping tx %s because it would "+ log.Tracef("Skipping tx %s because it would "+
"exceed the maximum sigops per block", tx.Hash()) "exceed the maximum sigops per block", tx.ID())
continue continue
} }
@ -548,7 +551,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
log.Tracef("Skipping tx %s with feePerKB %.2f "+ log.Tracef("Skipping tx %s with feePerKB %.2f "+
"< TxMinFreeFee %d and block size %d >= "+ "< TxMinFreeFee %d and block size %d >= "+
"minBlockSize %d", tx.Hash(), prioItem.feePerKB, "minBlockSize %d", tx.ID(), prioItem.feePerKB,
g.policy.TxMinFreeFee, blockPlusTxSize, g.policy.TxMinFreeFee, blockPlusTxSize,
g.policy.BlockMinSize) g.policy.BlockMinSize)
continue continue
@ -589,14 +592,14 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
blockUtxos, g.chainParams) blockUtxos, g.chainParams)
if err != nil { if err != nil {
log.Tracef("Skipping tx %s due to error in "+ log.Tracef("Skipping tx %s due to error in "+
"CheckTransactionInputs: %v", tx.Hash(), err) "CheckTransactionInputs: %v", tx.ID(), err)
continue continue
} }
err = blockdag.ValidateTransactionScripts(tx, blockUtxos, err = blockdag.ValidateTransactionScripts(tx, blockUtxos,
txscript.StandardVerifyFlags, g.sigCache) txscript.StandardVerifyFlags, g.sigCache)
if err != nil { if err != nil {
log.Tracef("Skipping tx %s due to error in "+ log.Tracef("Skipping tx %s due to error in "+
"ValidateTransactionScripts: %v", tx.Hash(), err) "ValidateTransactionScripts: %v", tx.ID(), err)
continue continue
} }
@ -617,7 +620,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
txSigOpCounts = append(txSigOpCounts, numSigOps) txSigOpCounts = append(txSigOpCounts, numSigOps)
log.Tracef("Adding tx %s (priority %.2f, feePerKB %.2f)", log.Tracef("Adding tx %s (priority %.2f, feePerKB %.2f)",
prioItem.tx.Hash(), prioItem.priority, prioItem.feePerKB) prioItem.tx.ID(), prioItem.priority, prioItem.feePerKB)
} }
// Now that the actual transactions have been selected, update the // Now that the actual transactions have been selected, update the
@ -650,14 +653,16 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
}) })
// Create a new block ready to be solved. // Create a new block ready to be solved.
merkles := blockdag.BuildMerkleTreeStore(blockTxns) hashMerkleTree := blockdag.BuildHashMerkleTreeStore(blockTxns)
idMerkleTree := blockdag.BuildIDMerkleTreeStore(blockTxns)
var msgBlock wire.MsgBlock var msgBlock wire.MsgBlock
msgBlock.Header = wire.BlockHeader{ msgBlock.Header = wire.BlockHeader{
Version: nextBlockVersion, Version: nextBlockVersion,
ParentHashes: g.dag.TipHashes(), ParentHashes: g.dag.TipHashes(),
MerkleRoot: *merkles[len(merkles)-1], HashMerkleRoot: *hashMerkleTree.Root(),
Timestamp: ts, IDMerkleRoot: *idMerkleTree.Root(),
Bits: reqDifficulty, Timestamp: ts,
Bits: reqDifficulty,
} }
for _, tx := range blockTxns { for _, tx := range blockTxns {
if err := msgBlock.AddTransaction(tx.MsgTx()); err != nil { if err := msgBlock.AddTransaction(tx.MsgTx()); err != nil {
@ -735,10 +740,13 @@ func (g *BlkTmplGenerator) UpdateExtraNonce(msgBlock *wire.MsgBlock, blockHeight
// recalculating all of the other transaction hashes. // recalculating all of the other transaction hashes.
// block.Transactions[0].InvalidateCache() // block.Transactions[0].InvalidateCache()
// Recalculate the merkle root with the updated extra nonce. // Recalculate the merkle roots with the updated extra nonce.
block := util.NewBlock(msgBlock) block := util.NewBlock(msgBlock)
merkles := blockdag.BuildMerkleTreeStore(block.Transactions()) hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
msgBlock.Header.MerkleRoot = *merkles[len(merkles)-1] msgBlock.Header.HashMerkleRoot = *hashMerkleTree.Root()
idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
msgBlock.Header.IDMerkleRoot = *idMerkleTree.Root()
return nil return nil
} }

6
mining/policy_test.go
View File

@ -61,11 +61,11 @@ func newUTXOSet(sourceTxns []*wire.MsgTx, sourceTxHeights []int32) blockdag.UTXO
func createTxIn(originTx *wire.MsgTx, outputIndex uint32) *wire.TxIn { func createTxIn(originTx *wire.MsgTx, outputIndex uint32) *wire.TxIn {
var prevOut *wire.OutPoint var prevOut *wire.OutPoint
if originTx != nil { if originTx != nil {
originTxHash := originTx.TxHash() originTxID := originTx.TxID()
prevOut = wire.NewOutPoint(&originTxHash, 0) prevOut = wire.NewOutPoint(&originTxID, 0)
} else { } else {
prevOut = &wire.OutPoint{ prevOut = &wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xFFFFFFFF, Index: 0xFFFFFFFF,
} }
} }

20
netsync/manager.go
View File

@ -416,14 +416,14 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// spec to proliferate. While this is not ideal, there is no check here // spec to proliferate. While this is not ideal, there is no check here
// to disconnect peers for sending unsolicited transactions to provide // to disconnect peers for sending unsolicited transactions to provide
// interoperability. // interoperability.
txHash := tmsg.tx.Hash() txID := tmsg.tx.ID()
// Ignore transactions that we have already rejected. Do not // Ignore transactions that we have already rejected. Do not
// send a reject message here because if the transaction was already // send a reject message here because if the transaction was already
// rejected, the transaction was unsolicited. // rejected, the transaction was unsolicited.
if _, exists = sm.rejectedTxns[*txHash]; exists { if _, exists = sm.rejectedTxns[*txID]; exists {
log.Debugf("Ignoring unsolicited previously rejected "+ log.Debugf("Ignoring unsolicited previously rejected "+
"transaction %v from %s", txHash, peer) "transaction %v from %s", txID, peer)
return return
} }
@ -436,13 +436,13 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// already knows about it and as such we shouldn't have any more // already knows about it and as such we shouldn't have any more
// instances of trying to fetch it, or we failed to insert and thus // instances of trying to fetch it, or we failed to insert and thus
// we'll retry next time we get an inv. // we'll retry next time we get an inv.
delete(state.requestedTxns, *txHash) delete(state.requestedTxns, *txID)
delete(sm.requestedTxns, *txHash) delete(sm.requestedTxns, *txID)
if err != nil { if err != nil {
// Do not request this transaction again until a new block // Do not request this transaction again until a new block
// has been processed. // has been processed.
sm.rejectedTxns[*txHash] = struct{}{} sm.rejectedTxns[*txID] = struct{}{}
sm.limitMap(sm.rejectedTxns, maxRejectedTxns) sm.limitMap(sm.rejectedTxns, maxRejectedTxns)
// When the error is a rule error, it means the transaction was // When the error is a rule error, it means the transaction was
@ -451,16 +451,16 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// so log it as an actual error. // so log it as an actual error.
if _, ok := err.(mempool.RuleError); ok { if _, ok := err.(mempool.RuleError); ok {
log.Debugf("Rejected transaction %v from %s: %v", log.Debugf("Rejected transaction %v from %s: %v",
txHash, peer, err) txID, peer, err)
} else { } else {
log.Errorf("Failed to process transaction %v: %v", log.Errorf("Failed to process transaction %v: %v",
txHash, err) txID, err)
} }
// Convert the error into an appropriate reject message and // Convert the error into an appropriate reject message and
// send it. // send it.
code, reason := mempool.ErrToRejectErr(err) code, reason := mempool.ErrToRejectErr(err)
peer.PushRejectMsg(wire.CmdTx, code, reason, txHash, false) peer.PushRejectMsg(wire.CmdTx, code, reason, txID, false)
return return
} }
@ -869,7 +869,7 @@ func (sm *SyncManager) haveInventory(invVect *wire.InvVect) (bool, error) {
// checked because the vast majority of transactions consist of // checked because the vast majority of transactions consist of
// two outputs where one is some form of "pay-to-somebody-else" // two outputs where one is some form of "pay-to-somebody-else"
// and the other is a change output. // and the other is a change output.
prevOut := wire.OutPoint{Hash: invVect.Hash} prevOut := wire.OutPoint{TxID: invVect.Hash}
for i := uint32(0); i < 2; i++ { for i := uint32(0); i < 2; i++ {
prevOut.Index = i prevOut.Index = i
entry, ok := sm.dag.GetUTXOEntry(prevOut) entry, ok := sm.dag.GetUTXOEntry(prevOut)

2
peer/log.go
View File

@ -150,7 +150,7 @@ func messageSummary(msg wire.Message) string {
case *wire.MsgTx: case *wire.MsgTx:
return fmt.Sprintf("hash %s, %d inputs, %d outputs, lock %s", return fmt.Sprintf("hash %s, %d inputs, %d outputs, lock %s",
msg.TxHash(), len(msg.TxIn), len(msg.TxOut), msg.TxID(), len(msg.TxIn), len(msg.TxOut),
formatLockTime(msg.LockTime)) formatLockTime(msg.LockTime))
case *wire.MsgBlock: case *wire.MsgBlock:

4
peer/peer_test.go
View File

@ -505,7 +505,7 @@ func TestPeerListeners(t *testing.T) {
{ {
"OnBlock", "OnBlock",
wire.NewMsgBlock(wire.NewBlockHeader(1, wire.NewMsgBlock(wire.NewBlockHeader(1,
[]daghash.Hash{}, &daghash.Hash{}, 1, 1)), []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
}, },
{ {
"OnInv", "OnInv",
@ -571,7 +571,7 @@ func TestPeerListeners(t *testing.T) {
{ {
"OnMerkleBlock", "OnMerkleBlock",
wire.NewMsgMerkleBlock(wire.NewBlockHeader(1, wire.NewMsgMerkleBlock(wire.NewBlockHeader(1,
[]daghash.Hash{}, &daghash.Hash{}, 1, 1)), []daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
}, },
// only one version message is allowed // only one version message is allowed
// only one verack message is allowed // only one verack message is allowed

4
rpcclient/notify.go
View File

@ -938,7 +938,7 @@ func (c *Client) notifySpentInternal(outpoints []btcjson.OutPoint) FutureNotifyS
// outpoint from the wire type. // outpoint from the wire type.
func newOutPointFromWire(op *wire.OutPoint) btcjson.OutPoint { func newOutPointFromWire(op *wire.OutPoint) btcjson.OutPoint {
return btcjson.OutPoint{ return btcjson.OutPoint{
Hash: op.Hash.String(), Hash: op.TxID.String(),
Index: op.Index, Index: op.Index,
} }
} }
@ -1171,7 +1171,7 @@ func (c *Client) LoadTxFilterAsync(reload bool, addresses []util.Address,
outPointObjects := make([]btcjson.OutPoint, len(outPoints)) outPointObjects := make([]btcjson.OutPoint, len(outPoints))
for i := range outPoints { for i := range outPoints {
outPointObjects[i] = btcjson.OutPoint{ outPointObjects[i] = btcjson.OutPoint{
Hash: outPoints[i].Hash.String(), Hash: outPoints[i].TxID.String(),
Index: outPoints[i].Index, Index: outPoints[i].Index,
} }
} }

2
rpcclient/wallet.go
View File

@ -335,7 +335,7 @@ func (c *Client) LockUnspentAsync(unlock bool, ops []*wire.OutPoint) FutureLockU
outputs := make([]btcjson.TransactionInput, len(ops)) outputs := make([]btcjson.TransactionInput, len(ops))
for i, op := range ops { for i, op := range ops {
outputs[i] = btcjson.TransactionInput{ outputs[i] = btcjson.TransactionInput{
TxID: op.Hash.String(), TxID: op.TxID.String(),
Vout: op.Index, Vout: op.Index,
} }
} }

10
server/p2p/p2p.go
View File

@ -474,7 +474,7 @@ func (sp *Peer) OnMemPool(_ *peer.Peer, msg *wire.MsgMemPool) {
// or only the transactions that match the filter when there is // or only the transactions that match the filter when there is
// one. // one.
if !sp.filter.IsLoaded() || sp.filter.MatchTxAndUpdate(txDesc.Tx) { if !sp.filter.IsLoaded() || sp.filter.MatchTxAndUpdate(txDesc.Tx) {
iv := wire.NewInvVect(wire.InvTypeTx, txDesc.Tx.Hash()) iv := wire.NewInvVect(wire.InvTypeTx, txDesc.Tx.ID())
invMsg.AddInvVect(iv) invMsg.AddInvVect(iv)
if len(invMsg.InvList)+1 > wire.MaxInvPerMsg { if len(invMsg.InvList)+1 > wire.MaxInvPerMsg {
break break
@ -495,7 +495,7 @@ func (sp *Peer) OnMemPool(_ *peer.Peer, msg *wire.MsgMemPool) {
func (sp *Peer) OnTx(_ *peer.Peer, msg *wire.MsgTx) { func (sp *Peer) OnTx(_ *peer.Peer, msg *wire.MsgTx) {
if config.MainConfig().BlocksOnly { if config.MainConfig().BlocksOnly {
peerLog.Tracef("Ignoring tx %v from %v - blocksonly enabled", peerLog.Tracef("Ignoring tx %v from %v - blocksonly enabled",
msg.TxHash(), sp) msg.TxID(), sp)
return return
} }
@ -503,7 +503,7 @@ func (sp *Peer) OnTx(_ *peer.Peer, msg *wire.MsgTx) {
// Convert the raw MsgTx to a util.Tx which provides some convenience // Convert the raw MsgTx to a util.Tx which provides some convenience
// methods and things such as hash caching. // methods and things such as hash caching.
tx := util.NewTx(msg) tx := util.NewTx(msg)
iv := wire.NewInvVect(wire.InvTypeTx, tx.Hash()) iv := wire.NewInvVect(wire.InvTypeTx, tx.ID())
sp.AddKnownInventory(iv) sp.AddKnownInventory(iv)
// Queue the transaction up to be handled by the sync manager and // Queue the transaction up to be handled by the sync manager and
@ -1217,7 +1217,7 @@ func (s *Server) RemoveRebroadcastInventory(iv *wire.InvVect) {
// passed transactions to all connected peers. // passed transactions to all connected peers.
func (s *Server) RelayTransactions(txns []*mempool.TxDesc) { func (s *Server) RelayTransactions(txns []*mempool.TxDesc) {
for _, txD := range txns { for _, txD := range txns {
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.Hash()) iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.ID())
s.RelayInventory(iv, txD) s.RelayInventory(iv, txD)
} }
} }
@ -2852,6 +2852,6 @@ func (s *Server) TransactionConfirmed(tx *util.Tx) {
return return
} }
iv := wire.NewInvVect(wire.InvTypeTx, tx.Hash()) iv := wire.NewInvVect(wire.InvTypeTx, tx.ID())
s.RemoveRebroadcastInventory(iv) s.RemoveRebroadcastInventory(iv)
} }

78
server/rpc/rpcserver.go
View File

@ -659,7 +659,7 @@ func handleDebugLevel(s *Server, cmd interface{}, closeChan <-chan struct{}) (in
func createVinList(mtx *wire.MsgTx) []btcjson.Vin { func createVinList(mtx *wire.MsgTx) []btcjson.Vin {
// Coinbase transactions only have a single txin by definition. // Coinbase transactions only have a single txin by definition.
vinList := make([]btcjson.Vin, len(mtx.TxIn)) vinList := make([]btcjson.Vin, len(mtx.TxIn))
if blockdag.IsCoinBaseTx(mtx) { if mtx.IsCoinBase() {
txIn := mtx.TxIn[0] txIn := mtx.TxIn[0]
vinList[0].Coinbase = hex.EncodeToString(txIn.SignatureScript) vinList[0].Coinbase = hex.EncodeToString(txIn.SignatureScript)
vinList[0].Sequence = txIn.Sequence vinList[0].Sequence = txIn.Sequence
@ -673,7 +673,7 @@ func createVinList(mtx *wire.MsgTx) []btcjson.Vin {
disbuf, _ := txscript.DisasmString(txIn.SignatureScript) disbuf, _ := txscript.DisasmString(txIn.SignatureScript)
vinEntry := &vinList[i] vinEntry := &vinList[i]
vinEntry.TxID = txIn.PreviousOutPoint.Hash.String() vinEntry.TxID = txIn.PreviousOutPoint.TxID.String()
vinEntry.Vout = txIn.PreviousOutPoint.Index vinEntry.Vout = txIn.PreviousOutPoint.Index
vinEntry.Sequence = txIn.Sequence vinEntry.Sequence = txIn.Sequence
vinEntry.ScriptSig = &btcjson.ScriptSig{ vinEntry.ScriptSig = &btcjson.ScriptSig{
@ -739,8 +739,8 @@ func createVoutList(mtx *wire.MsgTx, chainParams *dagconfig.Params, filterAddrMa
// createTxRawResult converts the passed transaction and associated parameters // createTxRawResult converts the passed transaction and associated parameters
// to a raw transaction JSON object. // to a raw transaction JSON object.
func createTxRawResult(chainParams *dagconfig.Params, mtx *wire.MsgTx, func createTxRawResult(dagParams *dagconfig.Params, mtx *wire.MsgTx,
txHash string, blkHeader *wire.BlockHeader, blkHash string, txID string, blkHeader *wire.BlockHeader, blkHash string,
blkHeight int32, chainHeight int32, acceptedBy *daghash.Hash) (*btcjson.TxRawResult, error) { blkHeight int32, chainHeight int32, acceptedBy *daghash.Hash) (*btcjson.TxRawResult, error) {
mtxHex, err := messageToHex(mtx) mtxHex, err := messageToHex(mtx)
@ -750,11 +750,11 @@ func createTxRawResult(chainParams *dagconfig.Params, mtx *wire.MsgTx,
txReply := &btcjson.TxRawResult{ txReply := &btcjson.TxRawResult{
Hex: mtxHex, Hex: mtxHex,
TxID: txHash, TxID: txID,
Hash: mtx.TxHash().String(), Hash: mtx.TxHash().String(),
Size: int32(mtx.SerializeSize()), Size: int32(mtx.SerializeSize()),
Vin: createVinList(mtx), Vin: createVinList(mtx),
Vout: createVoutList(mtx, chainParams, nil), Vout: createVoutList(mtx, dagParams, nil),
Version: mtx.Version, Version: mtx.Version,
LockTime: mtx.LockTime, LockTime: mtx.LockTime,
} }
@ -798,7 +798,7 @@ func handleDecodeRawTransaction(s *Server, cmd interface{}, closeChan <-chan str
// Create and return the result. // Create and return the result.
txReply := btcjson.TxRawDecodeResult{ txReply := btcjson.TxRawDecodeResult{
TxID: mtx.TxHash().String(), TxID: mtx.TxID().String(),
Version: mtx.Version, Version: mtx.Version,
Locktime: mtx.LockTime, Locktime: mtx.LockTime,
Vin: createVinList(&mtx), Vin: createVinList(&mtx),
@ -1147,7 +1147,7 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
Hash: c.Hash, Hash: c.Hash,
Version: blockHeader.Version, Version: blockHeader.Version,
VersionHex: fmt.Sprintf("%08x", blockHeader.Version), VersionHex: fmt.Sprintf("%08x", blockHeader.Version),
MerkleRoot: blockHeader.MerkleRoot.String(), MerkleRoot: blockHeader.HashMerkleRoot.String(),
ParentHashes: daghash.Strings(blockHeader.ParentHashes), ParentHashes: daghash.Strings(blockHeader.ParentHashes),
Nonce: blockHeader.Nonce, Nonce: blockHeader.Nonce,
Time: blockHeader.Timestamp.Unix(), Time: blockHeader.Timestamp.Unix(),
@ -1163,7 +1163,7 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
transactions := blk.Transactions() transactions := blk.Transactions()
txNames := make([]string, len(transactions)) txNames := make([]string, len(transactions))
for i, tx := range transactions { for i, tx := range transactions {
txNames[i] = tx.Hash().String() txNames[i] = tx.ID().String()
} }
blockReply.Tx = txNames blockReply.Tx = txNames
@ -1173,13 +1173,13 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
for i, tx := range txns { for i, tx := range txns {
var acceptedBy *daghash.Hash var acceptedBy *daghash.Hash
if s.cfg.TxIndex != nil { if s.cfg.TxIndex != nil {
acceptedBy, err = s.cfg.TxIndex.BlockThatAcceptedTx(s.cfg.DAG, tx.Hash()) acceptedBy, err = s.cfg.TxIndex.BlockThatAcceptedTx(s.cfg.DAG, tx.ID())
if err != nil { if err != nil {
return nil, err return nil, err
} }
} }
rawTxn, err := createTxRawResult(params, tx.MsgTx(), rawTxn, err := createTxRawResult(params, tx.MsgTx(),
tx.Hash().String(), blockHeader, hash.String(), tx.ID().String(), blockHeader, hash.String(),
blockHeight, s.cfg.DAG.Height(), acceptedBy) //TODO: (Ori) This is probably wrong. Done only for compilation blockHeight, s.cfg.DAG.Height(), acceptedBy) //TODO: (Ori) This is probably wrong. Done only for compilation
if err != nil { if err != nil {
return nil, err return nil, err
@ -1348,7 +1348,7 @@ func handleGetBlockHeader(s *Server, cmd interface{}, closeChan <-chan struct{})
Height: blockHeight, Height: blockHeight,
Version: blockHeader.Version, Version: blockHeader.Version,
VersionHex: fmt.Sprintf("%08x", blockHeader.Version), VersionHex: fmt.Sprintf("%08x", blockHeader.Version),
MerkleRoot: blockHeader.MerkleRoot.String(), MerkleRoot: blockHeader.HashMerkleRoot.String(),
NextHashes: nextHashStrings, NextHashes: nextHashStrings,
ParentHashes: daghash.Strings(blockHeader.ParentHashes), ParentHashes: daghash.Strings(blockHeader.ParentHashes),
Nonce: uint64(blockHeader.Nonce), Nonce: uint64(blockHeader.Nonce),
@ -1590,7 +1590,7 @@ func (state *gbtWorkState) updateBlockTemplate(s *Server, useCoinbaseValue bool)
log.Debugf("Generated block template (timestamp %v, "+ log.Debugf("Generated block template (timestamp %v, "+
"target %s, merkle root %s)", "target %s, merkle root %s)",
msgBlock.Header.Timestamp, targetDifficulty, msgBlock.Header.Timestamp, targetDifficulty,
msgBlock.Header.MerkleRoot) msgBlock.Header.HashMerkleRoot)
// Notify any clients that are long polling about the new // Notify any clients that are long polling about the new
// template. // template.
@ -1624,8 +1624,10 @@ func (state *gbtWorkState) updateBlockTemplate(s *Server, useCoinbaseValue bool)
// Update the merkle root. // Update the merkle root.
block := util.NewBlock(template.Block) block := util.NewBlock(template.Block)
merkles := blockdag.BuildMerkleTreeStore(block.Transactions()) hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
template.Block.Header.MerkleRoot = *merkles[len(merkles)-1] template.Block.Header.HashMerkleRoot = *hashMerkleTree.Root()
idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
template.Block.Header.IDMerkleRoot = *idMerkleTree.Root()
} }
// Set locals for convenience. // Set locals for convenience.
@ -1679,8 +1681,8 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
transactions := make([]btcjson.GetBlockTemplateResultTx, 0, numTx-1) transactions := make([]btcjson.GetBlockTemplateResultTx, 0, numTx-1)
txIndex := make(map[daghash.Hash]int64, numTx) txIndex := make(map[daghash.Hash]int64, numTx)
for i, tx := range msgBlock.Transactions { for i, tx := range msgBlock.Transactions {
txHash := tx.TxHash() txID := tx.TxID()
txIndex[txHash] = int64(i) txIndex[txID] = int64(i)
// Skip the coinbase transaction. // Skip the coinbase transaction.
if i == 0 { if i == 0 {
@ -1695,7 +1697,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
// when multiple inputs reference the same transaction. // when multiple inputs reference the same transaction.
dependsMap := make(map[int64]struct{}) dependsMap := make(map[int64]struct{})
for _, txIn := range tx.TxIn { for _, txIn := range tx.TxIn {
if idx, ok := txIndex[txIn.PreviousOutPoint.Hash]; ok { if idx, ok := txIndex[txIn.PreviousOutPoint.TxID]; ok {
dependsMap[idx] = struct{}{} dependsMap[idx] = struct{}{}
} }
} }
@ -1713,7 +1715,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
resultTx := btcjson.GetBlockTemplateResultTx{ resultTx := btcjson.GetBlockTemplateResultTx{
Data: hex.EncodeToString(txBuf.Bytes()), Data: hex.EncodeToString(txBuf.Bytes()),
Hash: txHash.String(), ID: txID.String(),
Depends: depends, Depends: depends,
Fee: template.Fees[i], Fee: template.Fees[i],
SigOps: template.SigOpCounts[i], SigOps: template.SigOpCounts[i],
@ -1772,7 +1774,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
resultTx := btcjson.GetBlockTemplateResultTx{ resultTx := btcjson.GetBlockTemplateResultTx{
Data: hex.EncodeToString(txBuf.Bytes()), Data: hex.EncodeToString(txBuf.Bytes()),
Hash: tx.TxHash().String(), ID: tx.TxID().String(),
Depends: []int64{}, Depends: []int64{},
Fee: template.Fees[0], Fee: template.Fees[0],
SigOps: template.SigOpCounts[0], SigOps: template.SigOpCounts[0],
@ -2443,7 +2445,7 @@ func handleGetRawMempool(s *Server, cmd interface{}, closeChan <-chan struct{})
descs := mp.TxDescs() descs := mp.TxDescs()
hashStrings := make([]string, len(descs)) hashStrings := make([]string, len(descs))
for i := range hashStrings { for i := range hashStrings {
hashStrings[i] = descs[i].Tx.Hash().String() hashStrings[i] = descs[i].Tx.ID().String()
} }
return hashStrings, nil return hashStrings, nil
@ -2617,9 +2619,9 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
confirmations = 0 confirmations = 0
value = txOut.Value value = txOut.Value
pkScript = txOut.PkScript pkScript = txOut.PkScript
isCoinbase = blockdag.IsCoinBaseTx(mtx) isCoinbase = mtx.IsCoinBase()
} else { } else {
out := wire.OutPoint{Hash: *txHash, Index: c.Vout} out := wire.OutPoint{TxID: *txHash, Index: c.Vout}
entry, ok := s.cfg.DAG.GetUTXOEntry(out) entry, ok := s.cfg.DAG.GetUTXOEntry(out)
if !ok { if !ok {
return nil, rpcNoTxInfoError(txHash) return nil, rpcNoTxInfoError(txHash)
@ -2747,13 +2749,13 @@ func fetchInputTxos(s *Server, tx *wire.MsgTx) (map[wire.OutPoint]wire.TxOut, er
// Attempt to fetch and use the referenced transaction from the // Attempt to fetch and use the referenced transaction from the
// memory pool. // memory pool.
origin := &txIn.PreviousOutPoint origin := &txIn.PreviousOutPoint
originTx, err := mp.FetchTransaction(&origin.Hash) originTx, err := mp.FetchTransaction(&origin.TxID)
if err == nil { if err == nil {
txOuts := originTx.MsgTx().TxOut txOuts := originTx.MsgTx().TxOut
if origin.Index >= uint32(len(txOuts)) { if origin.Index >= uint32(len(txOuts)) {
errStr := fmt.Sprintf("unable to find output "+ errStr := fmt.Sprintf("unable to find output "+
"%v referenced from transaction %s:%d", "%v referenced from transaction %s:%d",
origin, tx.TxHash(), txInIndex) origin, tx.TxID(), txInIndex)
return nil, internalRPCError(errStr, "") return nil, internalRPCError(errStr, "")
} }
@ -2762,13 +2764,13 @@ func fetchInputTxos(s *Server, tx *wire.MsgTx) (map[wire.OutPoint]wire.TxOut, er
} }
// Look up the location of the transaction. // Look up the location of the transaction.
blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(&origin.Hash) blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(&origin.TxID)
if err != nil { if err != nil {
context := "Failed to retrieve transaction location" context := "Failed to retrieve transaction location"
return nil, internalRPCError(err.Error(), context) return nil, internalRPCError(err.Error(), context)
} }
if blockRegion == nil { if blockRegion == nil {
return nil, rpcNoTxInfoError(&origin.Hash) return nil, rpcNoTxInfoError(&origin.TxID)
} }
// Load the raw transaction bytes from the database. // Load the raw transaction bytes from the database.
@ -2779,7 +2781,7 @@ func fetchInputTxos(s *Server, tx *wire.MsgTx) (map[wire.OutPoint]wire.TxOut, er
return err return err
}) })
if err != nil { if err != nil {
return nil, rpcNoTxInfoError(&origin.Hash) return nil, rpcNoTxInfoError(&origin.TxID)
} }
// Deserialize the transaction // Deserialize the transaction
@ -2794,7 +2796,7 @@ func fetchInputTxos(s *Server, tx *wire.MsgTx) (map[wire.OutPoint]wire.TxOut, er
if origin.Index >= uint32(len(msgTx.TxOut)) { if origin.Index >= uint32(len(msgTx.TxOut)) {
errStr := fmt.Sprintf("unable to find output %v "+ errStr := fmt.Sprintf("unable to find output %v "+
"referenced from transaction %s:%d", origin, "referenced from transaction %s:%d", origin,
tx.TxHash(), txInIndex) tx.TxID(), txInIndex)
return nil, internalRPCError(errStr, "") return nil, internalRPCError(errStr, "")
} }
originOutputs[*origin] = *msgTx.TxOut[origin.Index] originOutputs[*origin] = *msgTx.TxOut[origin.Index]
@ -2807,7 +2809,7 @@ func fetchInputTxos(s *Server, tx *wire.MsgTx) (map[wire.OutPoint]wire.TxOut, er
// passed transaction. // passed transaction.
func createVinListPrevOut(s *Server, mtx *wire.MsgTx, chainParams *dagconfig.Params, vinExtra bool, filterAddrMap map[string]struct{}) ([]btcjson.VinPrevOut, error) { func createVinListPrevOut(s *Server, mtx *wire.MsgTx, chainParams *dagconfig.Params, vinExtra bool, filterAddrMap map[string]struct{}) ([]btcjson.VinPrevOut, error) {
// Coinbase transactions only have a single txin by definition. // Coinbase transactions only have a single txin by definition.
if blockdag.IsCoinBaseTx(mtx) { if mtx.IsCoinBase() {
// Only include the transaction if the filter map is empty // Only include the transaction if the filter map is empty
// because a coinbase input has no addresses and so would never // because a coinbase input has no addresses and so would never
// match a non-empty filter. // match a non-empty filter.
@ -2847,7 +2849,7 @@ func createVinListPrevOut(s *Server, mtx *wire.MsgTx, chainParams *dagconfig.Par
// requested and available. // requested and available.
prevOut := &txIn.PreviousOutPoint prevOut := &txIn.PreviousOutPoint
vinEntry := btcjson.VinPrevOut{ vinEntry := btcjson.VinPrevOut{
TxID: prevOut.Hash.String(), TxID: prevOut.TxID.String(),
Vout: prevOut.Index, Vout: prevOut.Index,
Sequence: txIn.Sequence, Sequence: txIn.Sequence,
ScriptSig: &btcjson.ScriptSig{ ScriptSig: &btcjson.ScriptSig{
@ -3151,7 +3153,7 @@ func handleSearchRawTransactions(s *Server, cmd interface{}, closeChan <-chan st
result := &srtList[i] result := &srtList[i]
result.Hex = hexTxns[i] result.Hex = hexTxns[i]
result.TxID = mtx.TxHash().String() result.TxID = mtx.TxID().String()
result.Vin, err = createVinListPrevOut(s, mtx, params, vinExtra, result.Vin, err = createVinListPrevOut(s, mtx, params, vinExtra,
filterAddrMap) filterAddrMap)
if err != nil { if err != nil {
@ -3236,11 +3238,11 @@ func handleSendRawTransaction(s *Server, cmd interface{}, closeChan <-chan struc
// error is returned to the client with the deserialization // error is returned to the client with the deserialization
// error code (to match bitcoind behavior). // error code (to match bitcoind behavior).
if _, ok := err.(mempool.RuleError); ok { if _, ok := err.(mempool.RuleError); ok {
log.Debugf("Rejected transaction %v: %v", tx.Hash(), log.Debugf("Rejected transaction %v: %v", tx.ID(),
err) err)
} else { } else {
log.Errorf("Failed to process transaction %v: %v", log.Errorf("Failed to process transaction %v: %v",
tx.Hash(), err) tx.ID(), err)
} }
return nil, &btcjson.RPCError{ return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCDeserialization, Code: btcjson.ErrRPCDeserialization,
@ -3255,14 +3257,14 @@ func handleSendRawTransaction(s *Server, cmd interface{}, closeChan <-chan struc
// //
// Also, since an error is being returned to the caller, ensure the // Also, since an error is being returned to the caller, ensure the
// transaction is removed from the memory pool. // transaction is removed from the memory pool.
if len(acceptedTxs) == 0 || !acceptedTxs[0].Tx.Hash().IsEqual(tx.Hash()) { if len(acceptedTxs) == 0 || !acceptedTxs[0].Tx.ID().IsEqual(tx.ID()) {
err := s.cfg.TxMemPool.RemoveTransaction(tx, true, true) err := s.cfg.TxMemPool.RemoveTransaction(tx, true, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
errStr := fmt.Sprintf("transaction %v is not in accepted list", errStr := fmt.Sprintf("transaction %v is not in accepted list",
tx.Hash()) tx.ID())
return nil, internalRPCError(errStr, "") return nil, internalRPCError(errStr, "")
} }
@ -3278,10 +3280,10 @@ func handleSendRawTransaction(s *Server, cmd interface{}, closeChan <-chan struc
// Keep track of all the sendRawTransaction request txns so that they // Keep track of all the sendRawTransaction request txns so that they
// can be rebroadcast if they don't make their way into a block. // can be rebroadcast if they don't make their way into a block.
txD := acceptedTxs[0] txD := acceptedTxs[0]
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.Hash()) iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.ID())
s.cfg.ConnMgr.AddRebroadcastInventory(iv, txD) s.cfg.ConnMgr.AddRebroadcastInventory(iv, txD)
return tx.Hash().String(), nil return tx.ID().String(), nil
} }
// handleSetGenerate implements the setGenerate command. // handleSetGenerate implements the setGenerate command.

1
server/rpc/rpcserverhelp.go
View File

@ -291,6 +291,7 @@ var helpDescsEnUS = map[string]string{
// GetBlockTemplateResultTx help. // GetBlockTemplateResultTx help.
"getBlockTemplateResultTx-data": "Hex-encoded transaction data (byte-for-byte)", "getBlockTemplateResultTx-data": "Hex-encoded transaction data (byte-for-byte)",
"getBlockTemplateResultTx-hash": "Hex-encoded transaction hash (little endian if treated as a 256-bit number)", "getBlockTemplateResultTx-hash": "Hex-encoded transaction hash (little endian if treated as a 256-bit number)",
"getBlockTemplateResultTx-id": "Hex-encoded transaction ID (little endian if treated as a 256-bit number)",
"getBlockTemplateResultTx-depends": "Other transactions before this one (by 1-based index in the 'transactions' list) that must be present in the final block if this one is", "getBlockTemplateResultTx-depends": "Other transactions before this one (by 1-based index in the 'transactions' list) that must be present in the final block if this one is",
"getBlockTemplateResultTx-fee": "Difference in value between transaction inputs and outputs (in Satoshi)", "getBlockTemplateResultTx-fee": "Difference in value between transaction inputs and outputs (in Satoshi)",
"getBlockTemplateResultTx-sigOps": "Total number of signature operations as counted for purposes of block limits", "getBlockTemplateResultTx-sigOps": "Total number of signature operations as counted for purposes of block limits",

17
server/rpc/rpcwebsocket.go
View File

@ -22,7 +22,6 @@ import (
"golang.org/x/crypto/ripemd160" "golang.org/x/crypto/ripemd160"
"github.com/btcsuite/websocket" "github.com/btcsuite/websocket"
"github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/btcjson" "github.com/daglabs/btcd/btcjson"
"github.com/daglabs/btcd/config" "github.com/daglabs/btcd/config"
"github.com/daglabs/btcd/dagconfig" "github.com/daglabs/btcd/dagconfig"
@ -673,7 +672,7 @@ func (m *wsNotificationManager) subscribedClients(tx *util.Tx,
if filter.existsAddress(a) { if filter.existsAddress(a) {
subscribed[quitChan] = struct{}{} subscribed[quitChan] = struct{}{}
op := wire.OutPoint{ op := wire.OutPoint{
Hash: *tx.Hash(), TxID: *tx.ID(),
Index: uint32(i), Index: uint32(i),
} }
filter.addUnspentOutPoint(&op) filter.addUnspentOutPoint(&op)
@ -821,7 +820,7 @@ func (m *wsNotificationManager) UnregisterNewMempoolTxsUpdates(wsc *wsClient) {
// notifyForNewTx notifies websocket clients that have registered for updates // notifyForNewTx notifies websocket clients that have registered for updates
// when a new transaction is added to the memory pool. // when a new transaction is added to the memory pool.
func (m *wsNotificationManager) notifyForNewTx(clients map[chan struct{}]*wsClient, tx *util.Tx) { func (m *wsNotificationManager) notifyForNewTx(clients map[chan struct{}]*wsClient, tx *util.Tx) {
txHashStr := tx.Hash().String() txIDStr := tx.ID().String()
mtx := tx.MsgTx() mtx := tx.MsgTx()
var amount uint64 var amount uint64
@ -829,7 +828,7 @@ func (m *wsNotificationManager) notifyForNewTx(clients map[chan struct{}]*wsClie
amount += txOut.Value amount += txOut.Value
} }
ntfn := btcjson.NewTxAcceptedNtfn(txHashStr, util.Amount(amount).ToBTC()) ntfn := btcjson.NewTxAcceptedNtfn(txIDStr, util.Amount(amount).ToBTC())
marshalledJSON, err := btcjson.MarshalCmd(nil, ntfn) marshalledJSON, err := btcjson.MarshalCmd(nil, ntfn)
if err != nil { if err != nil {
log.Errorf("Failed to marshal tx notification: %s", err.Error()) log.Errorf("Failed to marshal tx notification: %s", err.Error())
@ -846,7 +845,7 @@ func (m *wsNotificationManager) notifyForNewTx(clients map[chan struct{}]*wsClie
} }
net := m.server.cfg.DAGParams net := m.server.cfg.DAGParams
rawTx, err := createTxRawResult(net, mtx, txHashStr, nil, rawTx, err := createTxRawResult(net, mtx, txIDStr, nil,
"", 0, 0, nil) "", 0, 0, nil)
if err != nil { if err != nil {
return return
@ -1021,7 +1020,7 @@ func (m *wsNotificationManager) notifyForTxOuts(ops map[wire.OutPoint]map[chan s
continue continue
} }
op := []*wire.OutPoint{wire.NewOutPoint(tx.Hash(), uint32(i))} op := []*wire.OutPoint{wire.NewOutPoint(tx.ID(), uint32(i))}
for wscQuit, wsc := range cmap { for wscQuit, wsc := range cmap {
m.addSpentRequests(ops, wsc, op) m.addSpentRequests(ops, wsc, op)
@ -1796,7 +1795,7 @@ func handleLoadTxFilter(wsc *wsClient, icmd interface{}) (interface{}, error) {
} }
} }
outPoints[i] = wire.OutPoint{ outPoints[i] = wire.OutPoint{
Hash: *hash, TxID: *hash,
Index: cmd.OutPoints[i].Index, Index: cmd.OutPoints[i].Index,
} }
} }
@ -1992,7 +1991,7 @@ func rescanBlockFilter(filter *wsClientFilter, block *util.Block, params *dagcon
added := false added := false
// Scan inputs if not a coinbase transaction. // Scan inputs if not a coinbase transaction.
if !blockdag.IsCoinBaseTx(msgTx) { if !msgTx.IsCoinBase() {
for _, input := range msgTx.TxIn { for _, input := range msgTx.TxIn {
if !filter.existsUnspentOutPoint(&input.PreviousOutPoint) { if !filter.existsUnspentOutPoint(&input.PreviousOutPoint) {
continue continue
@ -2019,7 +2018,7 @@ func rescanBlockFilter(filter *wsClientFilter, block *util.Block, params *dagcon
} }
op := wire.OutPoint{ op := wire.OutPoint{
Hash: *tx.Hash(), TxID: *tx.ID(),
Index: uint32(i), Index: uint32(i),
} }
filter.addUnspentOutPoint(&op) filter.addUnspentOutPoint(&op)

8
txscript/engine_test.go
View File

@ -30,7 +30,7 @@ func TestBadPC(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ TxID: daghash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5, 0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02, 0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a, 0xfa, 0x20, 0x9c, 0x6a,
@ -105,7 +105,7 @@ func TestCheckErrorCondition(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ TxID: daghash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5, 0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02, 0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a, 0xfa, 0x20, 0x9c, 0x6a,
@ -402,7 +402,7 @@ func TestDisasmPC(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ TxID: daghash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5, 0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02, 0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a, 0xfa, 0x20, 0x9c, 0x6a,
@ -464,7 +464,7 @@ func TestDisasmScript(t *testing.T) {
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ TxID: daghash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5, 0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02, 0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a, 0xfa, 0x20, 0x9c, 0x6a,

4
txscript/example_test.go
View File

@ -111,7 +111,7 @@ func ExampleSignTxOutput() {
} }
txOut := wire.NewTxOut(100000000, pkScript) txOut := wire.NewTxOut(100000000, pkScript)
originTx.AddTxOut(txOut) originTx.AddTxOut(txOut)
originTxHash := originTx.TxHash() originTxID := originTx.TxID()
// Create the transaction to redeem the fake transaction. // Create the transaction to redeem the fake transaction.
redeemTx := wire.NewMsgTx(wire.TxVersion) redeemTx := wire.NewMsgTx(wire.TxVersion)
@ -119,7 +119,7 @@ func ExampleSignTxOutput() {
// Add the input(s) the redeeming transaction will spend. There is no // Add the input(s) the redeeming transaction will spend. There is no
// signature script at this point since it hasn't been created or signed // signature script at this point since it hasn't been created or signed
// yet, hence nil is provided for it. // yet, hence nil is provided for it.
prevOut = wire.NewOutPoint(&originTxHash, 0) prevOut = wire.NewOutPoint(&originTxID, 0)
txIn = wire.NewTxIn(prevOut, nil) txIn = wire.NewTxIn(prevOut, nil)
redeemTx.AddTxIn(txIn) redeemTx.AddTxIn(txIn)

4
txscript/reference_test.go
View File

@ -224,8 +224,8 @@ func createSpendingTx(sigScript, pkScript []byte) *wire.MsgTx {
coinbaseTx.AddTxOut(txOut) coinbaseTx.AddTxOut(txOut)
spendingTx := wire.NewMsgTx(wire.TxVersion) spendingTx := wire.NewMsgTx(wire.TxVersion)
coinbaseTxHash := coinbaseTx.TxHash() coinbaseTxID := coinbaseTx.TxID()
outPoint = wire.NewOutPoint(&coinbaseTxHash, 0) outPoint = wire.NewOutPoint(&coinbaseTxID, 0)
txIn = wire.NewTxIn(outPoint, sigScript) txIn = wire.NewTxIn(outPoint, sigScript)
txOut = wire.NewTxOut(0, nil) txOut = wire.NewTxOut(0, nil)

6
txscript/sign_test.go
View File

@ -104,21 +104,21 @@ func TestSignTxOutput(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0, Index: 0,
}, },
Sequence: 4294967295, Sequence: 4294967295,
}, },
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 1, Index: 1,
}, },
Sequence: 4294967295, Sequence: 4294967295,
}, },
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 2, Index: 2,
}, },
Sequence: 4294967295, Sequence: 4294967295,

22
util/block_test.go
View File

@ -37,7 +37,7 @@ func TestBlock(t *testing.T) {
} }
// Hash for block 100,000. // Hash for block 100,000.
wantHashStr := "b75e32d07046b5290e131686c2b98636483cc4119573926eebc9dc944496d53b" wantHashStr := "c076eb7a2c8cb2d8492a9a2a4221f7b031257e71acef37fd12a9967661f57693"
wantHash, err := daghash.NewHashFromStr(wantHashStr) wantHash, err := daghash.NewHashFromStr(wantHashStr)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewHashFromStr: %v", err)
@ -146,10 +146,10 @@ func TestBlock(t *testing.T) {
// Transaction offsets and length for the transaction in Block100000. // Transaction offsets and length for the transaction in Block100000.
wantTxLocs := []wire.TxLoc{ wantTxLocs := []wire.TxLoc{
{TxStart: 122, TxLen: 163}, {TxStart: 154, TxLen: 163},
{TxStart: 285, TxLen: 287}, {TxStart: 317, TxLen: 287},
{TxStart: 572, TxLen: 285}, {TxStart: 604, TxLen: 285},
{TxStart: 857, TxLen: 253}, {TxStart: 889, TxLen: 253},
} }
// Ensure the transaction location information is accurate. // Ensure the transaction location information is accurate.
@ -258,7 +258,7 @@ func TestBlockErrors(t *testing.T) {
} }
// Truncate the block byte buffer to force errors. // Truncate the block byte buffer to force errors.
shortBytes := block100000Bytes[:122] shortBytes := block100000Bytes[:154]
_, err = util.NewBlockFromBytes(shortBytes) _, err = util.NewBlockFromBytes(shortBytes)
if err != io.EOF { if err != io.EOF {
t.Errorf("NewBlockFromBytes: did not get expected error - "+ t.Errorf("NewBlockFromBytes: did not get expected error - "+
@ -318,7 +318,7 @@ var Block100000 = wire.MsgBlock{
0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03, 0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03,
0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11, 0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11,
}}, // SimNet genesis }}, // SimNet genesis
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0, 0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22, 0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85, 0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
@ -334,7 +334,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -369,7 +369,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -439,7 +439,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -508,7 +508,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.Hash([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,

10
util/bloom/filter.go
View File

@ -168,7 +168,7 @@ func (bf *Filter) Matches(data []byte) bool {
func (bf *Filter) matchesOutPoint(outpoint *wire.OutPoint) bool { func (bf *Filter) matchesOutPoint(outpoint *wire.OutPoint) bool {
// Serialize // Serialize
var buf [daghash.HashSize + 4]byte var buf [daghash.HashSize + 4]byte
copy(buf[:], outpoint.Hash[:]) copy(buf[:], outpoint.TxID[:])
binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index) binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index)
return bf.matches(buf[:]) return bf.matches(buf[:])
@ -230,7 +230,7 @@ func (bf *Filter) AddHash(hash *daghash.Hash) {
func (bf *Filter) addOutPoint(outpoint *wire.OutPoint) { func (bf *Filter) addOutPoint(outpoint *wire.OutPoint) {
// Serialize // Serialize
var buf [daghash.HashSize + 4]byte var buf [daghash.HashSize + 4]byte
copy(buf[:], outpoint.Hash[:]) copy(buf[:], outpoint.TxID[:])
binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index) binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index)
bf.add(buf[:]) bf.add(buf[:])
@ -271,9 +271,9 @@ func (bf *Filter) maybeAddOutpoint(pkScript []byte, outHash *daghash.Hash, outId
// //
// This function MUST be called with the filter lock held. // This function MUST be called with the filter lock held.
func (bf *Filter) matchTxAndUpdate(tx *util.Tx) bool { func (bf *Filter) matchTxAndUpdate(tx *util.Tx) bool {
// Check if the filter matches the hash of the transaction. // Check if the filter matches the ID of the transaction.
// This is useful for finding transactions when they appear in a block. // This is useful for finding transactions when they appear in a block.
matched := bf.matches(tx.Hash()[:]) matched := bf.matches(tx.ID()[:])
// Check if the filter matches any data elements in the public key // Check if the filter matches any data elements in the public key
// scripts of any of the outputs. When it does, add the outpoint that // scripts of any of the outputs. When it does, add the outpoint that
@ -295,7 +295,7 @@ func (bf *Filter) matchTxAndUpdate(tx *util.Tx) bool {
} }
matched = true matched = true
bf.maybeAddOutpoint(txOut.PkScript, tx.Hash(), uint32(i)) bf.maybeAddOutpoint(txOut.PkScript, tx.ID(), uint32(i))
break break
} }
} }

119
util/bloom/filter_test.go
View File

@ -244,50 +244,86 @@ func TestFilterInsertKey(t *testing.T) {
} }
func TestFilterBloomMatch(t *testing.T) { func TestFilterBloomMatch(t *testing.T) {
str := "01000000010B26E9B7735EB6AABDF358BAB62F9816A21BA9" + strBytes := []byte{
"EBDB719D5299E88607D722C190000000008B483045022007" + 0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x26, 0xe9,
"0ACA44506C5CEF3A16ED519D7C3C39F8AAB192C4E1C90D06" + 0xb7, 0x73, 0x5e, 0xb6, 0xaa, 0xbd, 0xf3, 0x58,
"5F37B8A4AF6141022100A8E160B856C2D43D27D8FBA71E5A" + 0xba, 0xb6, 0x2f, 0x98, 0x16, 0xa2, 0x1b, 0xa9,
"EF6405B8643AC4CB7CB3C462ACED7F14711A0141046D11FE" + 0xeb, 0xdb, 0x71, 0x9d, 0x52, 0x99, 0xe8, 0x86,
"E51B0E60666D5049A9101A72741DF480B96EE26488A4D346" + 0x07, 0xd7, 0x22, 0xc1, 0x90, 0x00, 0x00, 0x00,
"6B95C9A40AC5EEEF87E10A5CD336C19A84565F80FA6C5479" + 0x00, 0x8b, 0x48, 0x30, 0x45, 0x02, 0x20, 0x07,
"57B7700FF4DFBDEFE76036C339FFFFFFFFFFFFFFFF021BFF" + 0x0a, 0xca, 0x44, 0x50, 0x6c, 0x5c, 0xef, 0x3a,
"3D11000000001976A91404943FDD508053C75000106D3BC6" + 0x16, 0xed, 0x51, 0x9d, 0x7c, 0x3c, 0x39, 0xf8,
"E2754DBCFF1988AC2F15DE00000000001976A914A266436D" + 0xaa, 0xb1, 0x92, 0xc4, 0xe1, 0xc9, 0x0d, 0x06,
"2965547608B9E15D9032A7B9D64FA43188AC000000000000" + 0x5f, 0x37, 0xb8, 0xa4, 0xaf, 0x61, 0x41, 0x02,
"00000100000000000000000000000000000000000000" 0x21, 0x00, 0xa8, 0xe1, 0x60, 0xb8, 0x56, 0xc2,
strBytes, err := hex.DecodeString(str) 0xd4, 0x3d, 0x27, 0xd8, 0xfb, 0xa7, 0x1e, 0x5a,
if err != nil { 0xef, 0x64, 0x05, 0xb8, 0x64, 0x3a, 0xc4, 0xcb,
t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err) 0x7c, 0xb3, 0xc4, 0x62, 0xac, 0xed, 0x7f, 0x14,
return 0x71, 0x1a, 0x01, 0x41, 0x04, 0x6d, 0x11, 0xfe,
0xe5, 0x1b, 0x0e, 0x60, 0x66, 0x6d, 0x50, 0x49,
0xa9, 0x10, 0x1a, 0x72, 0x74, 0x1d, 0xf4, 0x80,
0xb9, 0x6e, 0xe2, 0x64, 0x88, 0xa4, 0xd3, 0x46,
0x6b, 0x95, 0xc9, 0xa4, 0x0a, 0xc5, 0xee, 0xef,
0x87, 0xe1, 0x0a, 0x5c, 0xd3, 0x36, 0xc1, 0x9a,
0x84, 0x56, 0x5f, 0x80, 0xfa, 0x6c, 0x54, 0x79,
0x57, 0xb7, 0x70, 0x0f, 0xf4, 0xdf, 0xbd, 0xef,
0xe7, 0x60, 0x36, 0xc3, 0x39, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0x02, 0x1b, 0xff,
0x3d, 0x11, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76,
0xa9, 0x14, 0x04, 0x94, 0x3f, 0xdd, 0x50, 0x80,
0x53, 0xc7, 0x50, 0x00, 0x10, 0x6d, 0x3b, 0xc6,
0xe2, 0x75, 0x4d, 0xbc, 0xff, 0x19, 0x88, 0xac,
0x2f, 0x15, 0xde, 0x00, 0x00, 0x00, 0x00, 0x00,
0x19, 0x76, 0xa9, 0x14, 0xa2, 0x66, 0x43, 0x6d,
0x29, 0x65, 0x54, 0x76, 0x08, 0xb9, 0xe1, 0x5d,
0x90, 0x32, 0xa7, 0xb9, 0xd6, 0x4f, 0xa4, 0x31,
0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
} }
tx, err := util.NewTxFromBytes(strBytes) tx, err := util.NewTxFromBytes(strBytes)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err) t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return return
} }
spendingTxStr := "0100000001D25EE298643F1793383A12" + spendingTxBytes := []byte{
"8F8E70FF33932B6532511CC6E7556D03" + 0x01, 0x00, 0x00, 0x00, 0x01, 0x4c, 0x55, 0x7d,
"3370AB7CB7000000008C493046022100" + 0x38, 0xc1, 0xde, 0x01, 0x1d, 0x08, 0x0d, 0x54,
"DA0DC6AECEFE1E06EFDF05773757DEB1" + 0x16, 0xd4, 0x8f, 0x67, 0xdb, 0xbd, 0x20, 0xf2,
"68820930E3B0D03F46F5FCF150BF990C" + 0x60, 0x68, 0x4a, 0x1b, 0x58, 0xb8, 0xbb, 0x9e,
"022100D25B5C87040076E4F253F8262E" + 0x8c, 0x65, 0x1c, 0xf0, 0xcb, 0x00, 0x00, 0x00,
"763E2DD51E7FF0BE157727C4BC42807F" + 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00,
"17BD39014104E6C26EF67DC610D2CD19" + 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06,
"2484789A6CF9AEA9930B944B7E2DB534" + 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1,
"2B9D9E5B9FF79AFF9A2EE1978DD7FD01" + 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f,
"DFC522EE02283D3B06A9D03ACF809696" + 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c,
"8D7DBB0F9178FFFFFFFFFFFFFFFF028B" + 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04,
"A7940E000000001976A914BADEECFDEF" + 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e,
"0507247FC8F74241D73BC039972D7B88" + 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe,
"AC4094A802000000001976A914C10932" + 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f,
"483FEC93ED51F5FE95E72559F2CC7043" + 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2,
"F988AC00000000000000000100000000" + 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19,
"000000000000000000000000000000" 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9,
spendingTxBytes, err := hex.DecodeString(spendingTxStr) 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34,
if err != nil { 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff,
t.Errorf("TestFilterBloomMatch DecodeString failed to decode spendingTxStr: %v", err) 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01,
return 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b,
0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96,
0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b,
0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19,
0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef,
0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41,
0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88,
0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00,
0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32,
0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe,
0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43,
0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
} }
spendingTx, err := util.NewTxFromBytes(spendingTxBytes) spendingTx, err := util.NewTxFromBytes(spendingTxBytes)
@ -297,7 +333,7 @@ func TestFilterBloomMatch(t *testing.T) {
} }
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll) f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr := "b77cab7033036d55e7c61c5132652b9333ff708e8f123a3893173f6498e25ed2" // byte-reversed tx hash inputStr := "cbf01c658c9ebbb8581b4a6860f220bddb678fd416540d081d01dec1387d554c" // byte-reversed tx id
hash, err := daghash.NewHashFromStr(inputStr) hash, err := daghash.NewHashFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err) t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
@ -309,7 +345,7 @@ func TestFilterBloomMatch(t *testing.T) {
} }
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll) f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "d25ee298643f1793383a128f8e70ff33932b6532511cc6e7556d033370ab7cb7" // non-reversed tx hash inputStr = "4c557d38c1de011d080d5416d48f67dbbd20f260684a1b58b8bb9e8c651cf0cb" // non-reversed tx id
hashBytes, err := hex.DecodeString(inputStr) hashBytes, err := hex.DecodeString(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err) t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
@ -500,6 +536,9 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // HashMerkleRoot 0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // HashMerkleRoot
0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87, 0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x76, 0x38, 0x1B, 0x4D, 0x00, 0x00, 0x00, 0x00, // Time 0x76, 0x38, 0x1B, 0x4D, 0x00, 0x00, 0x00, 0x00, // Time
0x4C, 0x86, 0x04, 0x1B, // Bits 0x4C, 0x86, 0x04, 0x1B, // Bits
0x55, 0x4B, 0x85, 0x29, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x55, 0x4B, 0x85, 0x29, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce

2
util/bloom/merkleblock.go
View File

@ -96,7 +96,7 @@ func NewMerkleBlock(block *util.Block, filter *Filter) (*wire.MsgMerkleBlock, []
} else { } else {
mBlock.matchedBits = append(mBlock.matchedBits, 0x00) mBlock.matchedBits = append(mBlock.matchedBits, 0x00)
} }
mBlock.allHashes = append(mBlock.allHashes, tx.Hash()) mBlock.allHashes = append(mBlock.allHashes, tx.ID())
} }
// Calculate the number of merkle branches (height) in the tree. // Calculate the number of merkle branches (height) in the tree.

39
util/bloom/merkleblock_test.go
View File

@ -25,6 +25,9 @@ func TestMerkleBlock3(t *testing.T) {
0xB5, 0x0C, 0xC0, 0x69, 0xD6, 0xA3, 0xE3, 0x3E, 0x3F, 0xF8, 0x4A, // HashMerkleRoot 0xB5, 0x0C, 0xC0, 0x69, 0xD6, 0xA3, 0xE3, 0x3E, 0x3F, 0xF8, 0x4A, // HashMerkleRoot
0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77, 0x0F, 0xDC, 0xC9, 0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77, 0x0F, 0xDC, 0xC9,
0x6B, 0x2C, 0x3F, 0xF6, 0x0A, 0xBE, 0x18, 0x4F, 0x19, 0x63, 0x6B, 0x2C, 0x3F, 0xF6, 0x0A, 0xBE, 0x18, 0x4F, 0x19, 0x63,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x67, 0x29, 0x1B, 0x4D, 0x00, 0x00, 0x00, 0x00, //Time 0x67, 0x29, 0x1B, 0x4D, 0x00, 0x00, 0x00, 0x00, //Time
0x4C, 0x86, 0x04, 0x1B, // Bits 0x4C, 0x86, 0x04, 0x1B, // Bits
0x8F, 0xA4, 0x5D, 0x63, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x8F, 0xA4, 0x5D, 0x63, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -66,22 +69,26 @@ func TestMerkleBlock3(t *testing.T) {
mBlock, _ := bloom.NewMerkleBlock(blk, f) mBlock, _ := bloom.NewMerkleBlock(blk, f)
want := []byte{ want := []byte{
0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xCD, 0xA8, 0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xcd, 0xa8,
0x56, 0xB1, 0x43, 0xD9, 0xDB, 0x2C, 0x1C, 0xAF, 0x56, 0xb1, 0x43, 0xd9, 0xdb, 0x2c, 0x1c, 0xaf,
0xF0, 0x1D, 0x1A, 0xEC, 0xC8, 0x63, 0x0D, 0x30, 0xf0, 0x1d, 0x1a, 0xec, 0xc8, 0x63, 0x0d, 0x30,
0x62, 0x5D, 0x10, 0xE8, 0xB4, 0xB8, 0xB0, 0x00, 0x62, 0x5d, 0x10, 0xe8, 0xb4, 0xb8, 0xb0, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0x0C, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x0c, 0xc0,
0x69, 0xD6, 0xA3, 0xE3, 0x3E, 0x3F, 0xF8, 0x4A, 0x69, 0xd6, 0xa3, 0xe3, 0x3e, 0x3f, 0xf8, 0x4a,
0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77, 0x5c, 0x41, 0xd9, 0xd3, 0xfe, 0xbe, 0x7c, 0x77,
0x0F, 0xDC, 0xC9, 0x6B, 0x2C, 0x3F, 0xF6, 0x0A, 0x0f, 0xdc, 0xc9, 0x6b, 0x2c, 0x3f, 0xf6, 0x0a,
0xBE, 0x18, 0x4F, 0x19, 0x63, 0x67, 0x29, 0x1B, 0xbe, 0x18, 0x4f, 0x19, 0x63, 0x7f, 0x16, 0xc5,
0x4D, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x86, 0x04, 0x96, 0x2e, 0x8b, 0xd9, 0x63, 0x65, 0x9c, 0x79,
0x1B, 0x8F, 0xA4, 0x5D, 0x63, 0x00, 0x00, 0x00, 0x3c, 0xe3, 0x70, 0xd9, 0x5f, 0x09, 0x3b, 0xc7,
0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x33, 0xB0, 0xe3, 0x67, 0x11, 0x7b, 0x3c, 0x30, 0xc1, 0xf8,
0x08, 0x73, 0xD7, 0xDE, 0x86, 0xF3, 0x9E, 0x37, 0xfd, 0xd0, 0xd9, 0x72, 0x87, 0x67, 0x29, 0x1b,
0x06, 0x03, 0xB4, 0x75, 0xB4, 0xAC, 0xB4, 0x67, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x86, 0x04,
0xD3, 0x98, 0x3D, 0x2B, 0x9E, 0xE5, 0x35, 0x83, 0x1b, 0x8f, 0xa4, 0x5d, 0x63, 0x00, 0x00, 0x00,
0x1A, 0xA4, 0xEC, 0xD5, 0x76, 0x18, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x33, 0xb0,
0x08, 0x73, 0xd7, 0xde, 0x86, 0xf3, 0x9e, 0x37,
0x06, 0x03, 0xb4, 0x75, 0xb4, 0xac, 0xb4, 0x67,
0xd3, 0x98, 0x3d, 0x2b, 0x9e, 0xe5, 0x35, 0x83,
0x1a, 0xa4, 0xec, 0xd5, 0x76, 0x18, 0x01, 0x00,
} }
t.Log(spew.Sdump(want)) t.Log(spew.Sdump(want))
if err != nil { if err != nil {

8
util/coinset/coins.go
View File

@ -17,6 +17,7 @@ import (
// Coin represents a spendable transaction outpoint // Coin represents a spendable transaction outpoint
type Coin interface { type Coin interface {
Hash() *daghash.Hash Hash() *daghash.Hash
ID() *daghash.Hash
Index() uint32 Index() uint32
Value() util.Amount Value() util.Amount
PkScript() []byte PkScript() []byte
@ -131,7 +132,7 @@ func NewMsgTxWithInputCoins(txVersion int32, inputCoins Coins) *wire.MsgTx {
for i, coin := range coins { for i, coin := range coins {
msgTx.TxIn[i] = &wire.TxIn{ msgTx.TxIn[i] = &wire.TxIn{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
Hash: *coin.Hash(), TxID: *coin.ID(),
Index: coin.Index(), Index: coin.Index(),
}, },
SignatureScript: nil, SignatureScript: nil,
@ -359,6 +360,11 @@ func (c *SimpleCoin) Hash() *daghash.Hash {
return c.Tx.Hash() return c.Tx.Hash()
} }
// ID returns the ID of the transaction on which the Coin is an output
func (c *SimpleCoin) ID() *daghash.Hash {
return c.Tx.ID()
}
// Index returns the index of the output on the transaction which the Coin represents // Index returns the index of the output on the transaction which the Coin represents
func (c *SimpleCoin) Index() uint32 { func (c *SimpleCoin) Index() uint32 {
return c.TxIndex return c.TxIndex

6
util/coinset/coins_test.go
View File

@ -19,12 +19,14 @@ import (
type TestCoin struct { type TestCoin struct {
TxHash *daghash.Hash TxHash *daghash.Hash
TxID *daghash.Hash
TxIndex uint32 TxIndex uint32
TxValue util.Amount TxValue util.Amount
TxNumConfs int64 TxNumConfs int64
} }
func (c *TestCoin) Hash() *daghash.Hash { return c.TxHash } func (c *TestCoin) Hash() *daghash.Hash { return c.TxHash }
func (c *TestCoin) ID() *daghash.Hash { return c.TxID }
func (c *TestCoin) Index() uint32 { return c.TxIndex } func (c *TestCoin) Index() uint32 { return c.TxIndex }
func (c *TestCoin) Value() util.Amount { return c.TxValue } func (c *TestCoin) Value() util.Amount { return c.TxValue }
func (c *TestCoin) PkScript() []byte { return nil } func (c *TestCoin) PkScript() []byte { return nil }
@ -35,8 +37,10 @@ func NewCoin(index int64, value util.Amount, numConfs int64) coinset.Coin {
h := sha256.New() h := sha256.New()
h.Write([]byte(fmt.Sprintf("%d", index))) h.Write([]byte(fmt.Sprintf("%d", index)))
hash, _ := daghash.NewHash(h.Sum(nil)) hash, _ := daghash.NewHash(h.Sum(nil))
id, _ := daghash.NewHash(h.Sum(nil))
c := &TestCoin{ c := &TestCoin{
TxHash: hash, TxHash: hash,
TxID: id,
TxIndex: 0, TxIndex: 0,
TxValue: value, TxValue: value,
TxNumConfs: numConfs, TxNumConfs: numConfs,
@ -115,7 +119,7 @@ func TestCoinSet(t *testing.T) {
t.Errorf("Expected only 1 TxIn, got %d", len(mtx.TxIn)) t.Errorf("Expected only 1 TxIn, got %d", len(mtx.TxIn))
} }
op := mtx.TxIn[0].PreviousOutPoint op := mtx.TxIn[0].PreviousOutPoint
if !op.Hash.IsEqual(coins[1].Hash()) || op.Index != coins[1].Index() { if !op.TxID.IsEqual(coins[1].Hash()) || op.Index != coins[1].Index() {
t.Errorf("Expected the second coin to be added as input to mtx") t.Errorf("Expected the second coin to be added as input to mtx")
} }
} }

6
util/gcs/builder/builder.go
View File

@ -63,7 +63,7 @@ func DeriveKey(keyHash *daghash.Hash) [gcs.KeySize]byte {
func OutPointToFilterEntry(outpoint wire.OutPoint) []byte { func OutPointToFilterEntry(outpoint wire.OutPoint) []byte {
// Size of the hash plus size of int32 index // Size of the hash plus size of int32 index
data := make([]byte, daghash.HashSize+4) data := make([]byte, daghash.HashSize+4)
copy(data[:], outpoint.Hash.CloneBytes()[:]) copy(data[:], outpoint.TxID.CloneBytes()[:])
binary.LittleEndian.PutUint32(data[daghash.HashSize:], outpoint.Index) binary.LittleEndian.PutUint32(data[daghash.HashSize:], outpoint.Index)
return data return data
} }
@ -305,8 +305,8 @@ func BuildBasicFilter(block *wire.MsgBlock) (*gcs.Filter, error) {
for i, tx := range block.Transactions { for i, tx := range block.Transactions {
// First we'll compute the bash of the transaction and add that // First we'll compute the bash of the transaction and add that
// directly to the filter. // directly to the filter.
txHash := tx.TxHash() txID := tx.TxID()
b.AddHash(&txHash) b.AddHash(&txID)
// Skip the inputs for the coinbase transaction // Skip the inputs for the coinbase transaction
if i != 0 { if i != 0 {

30
util/gcs/builder/builder_test.go
View File

@ -50,14 +50,14 @@ var (
// TestUseBlockHash tests using a block hash as a filter key. // TestUseBlockHash tests using a block hash as a filter key.
func TestUseBlockHash(t *testing.T) { func TestUseBlockHash(t *testing.T) {
// Block hash #448710, pretty high difficulty. // Block hash #448710, pretty high difficulty.
hash, err := daghash.NewHashFromStr(testHash) txID, err := daghash.NewHashFromStr(testHash)
if err != nil { if err != nil {
t.Fatalf("Hash from string failed: %s", err.Error()) t.Fatalf("Hash from string failed: %s", err.Error())
} }
// wire.OutPoint // wire.OutPoint
outPoint := wire.OutPoint{ outPoint := wire.OutPoint{
Hash: *hash, TxID: *txID,
Index: 4321, Index: 4321,
} }
@ -73,7 +73,7 @@ func TestUseBlockHash(t *testing.T) {
// Create a GCSBuilder with a key hash and check that the key is derived // Create a GCSBuilder with a key hash and check that the key is derived
// correctly, then test it. // correctly, then test it.
b := builder.WithKeyHash(hash) b := builder.WithKeyHash(txID)
key, err := b.Key() key, err := b.Key()
if err != nil { if err != nil {
t.Fatalf("Builder instantiation with key hash failed: %s", t.Fatalf("Builder instantiation with key hash failed: %s",
@ -84,16 +84,16 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]), hex.EncodeToString(key[:]),
hex.EncodeToString(testKey[:])) hex.EncodeToString(testKey[:]))
} }
BuilderTest(b, hash, builder.DefaultP, outPoint, addrBytes, t) BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t)
// Create a GCSBuilder with a key hash and non-default P and test it. // Create a GCSBuilder with a key hash and non-default P and test it.
b = builder.WithKeyHashP(hash, 30) b = builder.WithKeyHashP(txID, 30)
BuilderTest(b, hash, 30, outPoint, addrBytes, t) BuilderTest(b, txID, 30, outPoint, addrBytes, t)
// Create a GCSBuilder with a random key, set the key from a hash // Create a GCSBuilder with a random key, set the key from a hash
// manually, check that the key is correct, and test it. // manually, check that the key is correct, and test it.
b = builder.WithRandomKey() b = builder.WithRandomKey()
b.SetKeyFromHash(hash) b.SetKeyFromHash(txID)
key, err = b.Key() key, err = b.Key()
if err != nil { if err != nil {
t.Fatalf("Builder instantiation with known key failed: %s", t.Fatalf("Builder instantiation with known key failed: %s",
@ -104,7 +104,7 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]), hex.EncodeToString(key[:]),
hex.EncodeToString(testKey[:])) hex.EncodeToString(testKey[:]))
} }
BuilderTest(b, hash, builder.DefaultP, outPoint, addrBytes, t) BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t)
// Create a GCSBuilder with a random key and test it. // Create a GCSBuilder with a random key and test it.
b = builder.WithRandomKey() b = builder.WithRandomKey()
@ -114,7 +114,7 @@ func TestUseBlockHash(t *testing.T) {
err.Error()) err.Error())
} }
t.Logf("Random Key 1: %s", hex.EncodeToString(key1[:])) t.Logf("Random Key 1: %s", hex.EncodeToString(key1[:]))
BuilderTest(b, hash, builder.DefaultP, outPoint, addrBytes, t) BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t)
// Create a GCSBuilder with a random key and non-default P and test it. // Create a GCSBuilder with a random key and non-default P and test it.
b = builder.WithRandomKeyP(30) b = builder.WithRandomKeyP(30)
@ -127,7 +127,7 @@ func TestUseBlockHash(t *testing.T) {
if key2 == key1 { if key2 == key1 {
t.Fatalf("Random keys are the same!") t.Fatalf("Random keys are the same!")
} }
BuilderTest(b, hash, 30, outPoint, addrBytes, t) BuilderTest(b, txID, 30, outPoint, addrBytes, t)
// Create a GCSBuilder with a known key and test it. // Create a GCSBuilder with a known key and test it.
b = builder.WithKey(testKey) b = builder.WithKey(testKey)
@ -141,7 +141,7 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]), hex.EncodeToString(key[:]),
hex.EncodeToString(testKey[:])) hex.EncodeToString(testKey[:]))
} }
BuilderTest(b, hash, builder.DefaultP, outPoint, addrBytes, t) BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t)
// Create a GCSBuilder with a known key and non-default P and test it. // Create a GCSBuilder with a known key and non-default P and test it.
b = builder.WithKeyP(testKey, 30) b = builder.WithKeyP(testKey, 30)
@ -155,13 +155,13 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]), hex.EncodeToString(key[:]),
hex.EncodeToString(testKey[:])) hex.EncodeToString(testKey[:]))
} }
BuilderTest(b, hash, 30, outPoint, addrBytes, t) BuilderTest(b, txID, 30, outPoint, addrBytes, t)
// Create a GCSBuilder with a known key and too-high P and ensure error // Create a GCSBuilder with a known key and too-high P and ensure error
// works throughout all functions that use it. // works throughout all functions that use it.
b = builder.WithRandomKeyP(33).SetKeyFromHash(hash).SetKey(testKey) b = builder.WithRandomKeyP(33).SetKeyFromHash(txID).SetKey(testKey)
b.SetP(30).AddEntry(hash.CloneBytes()).AddEntries(contents) b.SetP(30).AddEntry(txID.CloneBytes()).AddEntries(contents)
b.AddOutPoint(outPoint).AddHash(hash).AddScript(addrBytes) b.AddOutPoint(outPoint).AddHash(txID).AddScript(addrBytes)
_, err = b.Key() _, err = b.Key()
if err != gcs.ErrPTooBig { if err != gcs.ErrPTooBig {
t.Fatalf("No error on P too big!") t.Fatalf("No error on P too big!")

16
util/tx.go
View File

@ -24,6 +24,7 @@ const TxIndexUnknown = -1
type Tx struct { type Tx struct {
msgTx *wire.MsgTx // Underlying MsgTx msgTx *wire.MsgTx // Underlying MsgTx
txHash *daghash.Hash // Cached transaction hash txHash *daghash.Hash // Cached transaction hash
txID *daghash.Hash // Cached transaction ID
txIndex int // Position within a block or TxIndexUnknown txIndex int // Position within a block or TxIndexUnknown
} }
@ -48,6 +49,21 @@ func (t *Tx) Hash() *daghash.Hash {
return &hash return &hash
} }
// ID returns the id of the transaction. This is equivalent to
// calling TxID on the underlying wire.MsgTx, however it caches the
// result so subsequent calls are more efficient.
func (t *Tx) ID() *daghash.Hash {
// Return the cached hash if it has already been generated.
if t.txID != nil {
return t.txID
}
// Cache the hash and return it.
id := t.msgTx.TxID()
t.txID = &id
return &id
}
// Index returns the saved index of the transaction within a block. This value // Index returns the saved index of the transaction within a block. This value
// will be TxIndexUnknown if it hasn't already explicitly been set. // will be TxIndexUnknown if it hasn't already explicitly been set.
func (t *Tx) Index() int { func (t *Tx) Index() int {

28
util/tx_test.go
View File

@ -17,19 +17,21 @@ import (
// TestTx tests the API for Tx. // TestTx tests the API for Tx.
func TestTx(t *testing.T) { func TestTx(t *testing.T) {
testTx := Block100000.Transactions[0] firstTestTx := Block100000.Transactions[0]
tx := util.NewTx(testTx) firstTx := util.NewTx(firstTestTx)
secondTestTx := Block100000.Transactions[1]
secondTx := util.NewTx(secondTestTx)
// Ensure we get the same data back out. // Ensure we get the same data back out.
if msgTx := tx.MsgTx(); !reflect.DeepEqual(msgTx, testTx) { if msgTx := firstTx.MsgTx(); !reflect.DeepEqual(msgTx, firstTestTx) {
t.Errorf("MsgTx: mismatched MsgTx - got %v, want %v", t.Errorf("MsgTx: mismatched MsgTx - got %v, want %v",
spew.Sdump(msgTx), spew.Sdump(testTx)) spew.Sdump(msgTx), spew.Sdump(firstTestTx))
} }
// Ensure transaction index set and get work properly. // Ensure transaction index set and get work properly.
wantIndex := 0 wantIndex := 0
tx.SetIndex(0) firstTx.SetIndex(0)
if gotIndex := tx.Index(); gotIndex != wantIndex { if gotIndex := firstTx.Index(); gotIndex != wantIndex {
t.Errorf("Index: mismatched index - got %v, want %v", t.Errorf("Index: mismatched index - got %v, want %v",
gotIndex, wantIndex) gotIndex, wantIndex)
} }
@ -43,12 +45,24 @@ func TestTx(t *testing.T) {
// Request the hash multiple times to test generation and caching. // Request the hash multiple times to test generation and caching.
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
hash := tx.Hash() hash := firstTx.Hash()
if !hash.IsEqual(wantHash) { if !hash.IsEqual(wantHash) {
t.Errorf("Hash #%d mismatched hash - got %v, want %v", i, t.Errorf("Hash #%d mismatched hash - got %v, want %v", i,
hash, wantHash) hash, wantHash)
} }
} }
// ID for block 100,000 transaction 1.
wantIDStr := "1742649144632997855e06650c1df5fd27cad915419a8f14f2f1b5a652257342"
wantID, err := daghash.NewHashFromStr(wantIDStr)
// Request the ID multiple times to test generation and caching.
for i := 0; i < 2; i++ {
id := secondTx.ID()
if !id.IsEqual(wantID) {
t.Errorf("Hash #%d mismatched hash - got %v, want %v", i,
id, wantID)
}
}
} }
// TestNewTxFromBytes tests creation of a Tx from serialized bytes. // TestNewTxFromBytes tests creation of a Tx from serialized bytes.

4
util/txsort/txsort.go
View File

@ -69,8 +69,8 @@ func (s sortableInputSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// First sort based on input hash (reversed / rpc-style), then index. // First sort based on input hash (reversed / rpc-style), then index.
func (s sortableInputSlice) Less(i, j int) bool { func (s sortableInputSlice) Less(i, j int) bool {
// Input hashes are the same, so compare the index. // Input hashes are the same, so compare the index.
ihash := s[i].PreviousOutPoint.Hash ihash := s[i].PreviousOutPoint.TxID
jhash := s[j].PreviousOutPoint.Hash jhash := s[j].PreviousOutPoint.TxID
if ihash == jhash { if ihash == jhash {
return s[i].PreviousOutPoint.Index < s[j].PreviousOutPoint.Index return s[i].PreviousOutPoint.Index < s[j].PreviousOutPoint.Index
} }

10
wire/bench_test.go
View File

@ -24,7 +24,7 @@ var genesisCoinbaseTx = MsgTx{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -197,7 +197,7 @@ func BenchmarkReadOutPoint(b *testing.B) {
// transaction output point. // transaction output point.
func BenchmarkWriteOutPoint(b *testing.B) { func BenchmarkWriteOutPoint(b *testing.B) {
op := &OutPoint{ op := &OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0, Index: 0,
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
@ -268,7 +268,7 @@ func BenchmarkReadTxIn(b *testing.B) {
func BenchmarkWriteTxIn(b *testing.B) { func BenchmarkWriteTxIn(b *testing.B) {
txIn := blockOne.Transactions[0].TxIn[0] txIn := blockOne.Transactions[0].TxIn[0]
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
writeTxIn(ioutil.Discard, 0, 0, txIn) writeTxIn(ioutil.Discard, 0, 0, txIn, txEncodingFull)
} }
} }
@ -429,7 +429,7 @@ func BenchmarkDecodeHeaders(b *testing.B) {
} }
parentHashes[i] = *hash parentHashes[i] = *hash
} }
m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, 0, uint64(i))) m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, hash, 0, uint64(i)))
} }
// Serialize it so the bytes are available to test the decode below. // Serialize it so the bytes are available to test the decode below.
@ -575,7 +575,7 @@ func BenchmarkDecodeMerkleBlock(b *testing.B) {
if err != nil { if err != nil {
b.Fatalf("NewHashFromStr: unexpected error: %v", err) b.Fatalf("NewHashFromStr: unexpected error: %v", err)
} }
m.Header = *NewBlockHeader(1, []daghash.Hash{*hash}, hash, 0, uint64(10000)) m.Header = *NewBlockHeader(1, []daghash.Hash{*hash}, hash, hash, 0, uint64(10000))
for i := 0; i < 105; i++ { for i := 0; i < 105; i++ {
hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i)) hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
if err != nil { if err != nil {

34
wire/blockheader.go
View File

@ -15,10 +15,10 @@ import (
// BaseBlockHeaderPayload is the base number of bytes a block header can be, // BaseBlockHeaderPayload is the base number of bytes a block header can be,
// not including the list of parent block headers. // not including the list of parent block headers.
// Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes + // Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes +
// + NumParentBlocks 1 byte + MerkleRoot hash. // + NumParentBlocks 1 byte + HashMerkleRoot hash + IDMerkleRoot hash.
// To get total size of block header len(ParentHashes) * daghash.HashSize should be // To get total size of block header len(ParentHashes) * daghash.HashSize should be
// added to this value // added to this value
const BaseBlockHeaderPayload = 25 + (daghash.HashSize) const BaseBlockHeaderPayload = 25 + 2*(daghash.HashSize)
// MaxNumParentBlocks is the maximum number of parent blocks a block can reference. // MaxNumParentBlocks is the maximum number of parent blocks a block can reference.
// Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte // Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte
@ -37,8 +37,11 @@ type BlockHeader struct {
// Hashes of the parent block headers in the blockDAG. // Hashes of the parent block headers in the blockDAG.
ParentHashes []daghash.Hash ParentHashes []daghash.Hash
// Merkle tree reference to hash of all transactions for the block. // HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
MerkleRoot daghash.Hash HashMerkleRoot daghash.Hash
// IDMerkleRoot is the merkle tree reference to hash of all transactions' IDs for the block.
IDMerkleRoot daghash.Hash
// Time the block was created. // Time the block was created.
Timestamp time.Time Timestamp time.Time
@ -124,20 +127,21 @@ func (h *BlockHeader) SerializeSize() int {
} }
// NewBlockHeader returns a new BlockHeader using the provided version, previous // NewBlockHeader returns a new BlockHeader using the provided version, previous
// block hash, merkle root hash, difficulty bits, and nonce used to generate the // block hash, hash merkle root, ID merkle root difficulty bits, and nonce used to generate the
// block with defaults or calclulated values for the remaining fields. // block with defaults or calclulated values for the remaining fields.
func NewBlockHeader(version int32, parentHashes []daghash.Hash, merkleRootHash *daghash.Hash, func NewBlockHeader(version int32, parentHashes []daghash.Hash, hashMerkleRoot *daghash.Hash,
bits uint32, nonce uint64) *BlockHeader { idMerkleRoot *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
// Limit the timestamp to one second precision since the protocol // Limit the timestamp to one second precision since the protocol
// doesn't support better. // doesn't support better.
return &BlockHeader{ return &BlockHeader{
Version: version, Version: version,
ParentHashes: parentHashes, ParentHashes: parentHashes,
MerkleRoot: *merkleRootHash, HashMerkleRoot: *hashMerkleRoot,
Timestamp: time.Unix(time.Now().Unix(), 0), IDMerkleRoot: *idMerkleRoot,
Bits: bits, Timestamp: time.Unix(time.Now().Unix(), 0),
Nonce: nonce, Bits: bits,
Nonce: nonce,
} }
} }
@ -158,7 +162,7 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
return err return err
} }
} }
return readElements(r, &bh.MerkleRoot, (*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce) return readElements(r, &bh.HashMerkleRoot, &bh.IDMerkleRoot, (*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
} }
// writeBlockHeader writes a bitcoin block header to w. See Serialize for // writeBlockHeader writes a bitcoin block header to w. See Serialize for
@ -166,6 +170,6 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
// opposed to encoding for the wire. // opposed to encoding for the wire.
func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error { func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
sec := int64(bh.Timestamp.Unix()) sec := int64(bh.Timestamp.Unix())
return writeElements(w, bh.Version, bh.NumParentBlocks(), &bh.ParentHashes, &bh.MerkleRoot, return writeElements(w, bh.Version, bh.NumParentBlocks(), &bh.ParentHashes, &bh.HashMerkleRoot, &bh.IDMerkleRoot,
sec, bh.Bits, bh.Nonce) sec, bh.Bits, bh.Nonce)
} }

101
wire/blockheader_test.go
View File

@ -24,17 +24,18 @@ func TestBlockHeader(t *testing.T) {
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash} hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := mainNetGenesisMerkleRoot merkleHash := mainNetGenesisMerkleRoot
idMerkleRoot := &exampleIDMerkleRoot
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
bh := NewBlockHeader(1, hashes, &merkleHash, bits, nonce) bh := NewBlockHeader(1, hashes, &merkleHash, idMerkleRoot, bits, nonce)
// Ensure we get the same data back out. // Ensure we get the same data back out.
if !reflect.DeepEqual(bh.ParentHashes, hashes) { if !reflect.DeepEqual(bh.ParentHashes, hashes) {
t.Errorf("NewBlockHeader: wrong prev hashes - got %v, want %v", t.Errorf("NewBlockHeader: wrong prev hashes - got %v, want %v",
spew.Sprint(bh.ParentHashes), spew.Sprint(hashes)) spew.Sprint(bh.ParentHashes), spew.Sprint(hashes))
} }
if !bh.MerkleRoot.IsEqual(&merkleHash) { if !bh.HashMerkleRoot.IsEqual(&merkleHash) {
t.Errorf("NewBlockHeader: wrong merkle root - got %v, want %v", t.Errorf("NewBlockHeader: wrong merkle root - got %v, want %v",
spew.Sprint(bh.MerkleRoot), spew.Sprint(merkleHash)) spew.Sprint(bh.HashMerkleRoot), spew.Sprint(merkleHash))
} }
if bh.Bits != bits { if bh.Bits != bits {
t.Errorf("NewBlockHeader: wrong bits - got %v, want %v", t.Errorf("NewBlockHeader: wrong bits - got %v, want %v",
@ -55,12 +56,13 @@ func TestBlockHeaderWire(t *testing.T) {
// baseBlockHdr is used in the various tests as a baseline BlockHeader. // baseBlockHdr is used in the various tests as a baseline BlockHeader.
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
baseBlockHdr := &BlockHeader{ baseBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST IDMerkleRoot: exampleIDMerkleRoot,
Bits: bits, Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Nonce: nonce, Bits: bits,
Nonce: nonce,
} }
// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr. // baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
@ -75,10 +77,14 @@ func TestBlockHeaderWire(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0, 0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91, 0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68, 0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot 0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // HashMerkleRoot
0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f, 0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a, 0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b, 0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -193,12 +199,13 @@ func TestBlockHeaderSerialize(t *testing.T) {
// baseBlockHdr is used in the various tests as a baseline BlockHeader. // baseBlockHdr is used in the various tests as a baseline BlockHeader.
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
baseBlockHdr := &BlockHeader{ baseBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST IDMerkleRoot: exampleIDMerkleRoot,
Bits: bits, Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Nonce: nonce, Bits: bits,
Nonce: nonce,
} }
// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr. // baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
@ -213,10 +220,14 @@ func TestBlockHeaderSerialize(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0, 0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91, 0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68, 0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot 0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // HashMerkleRoot
0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f, 0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a, 0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b, 0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -272,31 +283,33 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
baseBlockHdr := &BlockHeader{ baseBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp, IDMerkleRoot: mainNetGenesisMerkleRoot,
Bits: bits, Timestamp: timestamp,
Nonce: nonce, Bits: bits,
Nonce: nonce,
} }
genesisBlockHdr := &BlockHeader{ genesisBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{}, ParentHashes: []daghash.Hash{},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp, IDMerkleRoot: mainNetGenesisMerkleRoot,
Bits: bits, Timestamp: timestamp,
Nonce: nonce, Bits: bits,
Nonce: nonce,
} }
tests := []struct { tests := []struct {
in *BlockHeader // Block header to encode in *BlockHeader // Block header to encode
size int // Expected serialized size size int // Expected serialized size
}{ }{
// Block with no transactions. // Block with no transactions.
{genesisBlockHdr, 57}, {genesisBlockHdr, 89},
// First block in the mainnet block chain. // First block in the mainnet block DAG.
{baseBlockHdr, 121}, {baseBlockHdr, 153},
} }
t.Logf("Running %d tests", len(tests)) t.Logf("Running %d tests", len(tests))
@ -317,20 +330,20 @@ func TestIsGenesis(t *testing.T) {
timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
baseBlockHdr := &BlockHeader{ baseBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp, Timestamp: timestamp,
Bits: bits, Bits: bits,
Nonce: nonce, Nonce: nonce,
} }
genesisBlockHdr := &BlockHeader{ genesisBlockHdr := &BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{}, ParentHashes: []daghash.Hash{},
MerkleRoot: mainNetGenesisMerkleRoot, HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp, Timestamp: timestamp,
Bits: bits, Bits: bits,
Nonce: nonce, Nonce: nonce,
} }
tests := []struct { tests := []struct {

7
wire/common_test.go
View File

@ -43,6 +43,13 @@ var mainNetGenesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go v
0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b, 0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
}) })
var exampleIDMerkleRoot = daghash.Hash{
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
}
// fakeRandReader implements the io.Reader interface and is used to force // fakeRandReader implements the io.Reader interface and is used to force
// errors in the RandomUint64 function. // errors in the RandomUint64 function.
type fakeRandReader struct { type fakeRandReader struct {

6
wire/message_test.go
View File

@ -68,7 +68,7 @@ func TestMessage(t *testing.T) {
msgFilterAdd := NewMsgFilterAdd([]byte{0x01}) msgFilterAdd := NewMsgFilterAdd([]byte{0x01})
msgFilterClear := NewMsgFilterClear() msgFilterClear := NewMsgFilterClear()
msgFilterLoad := NewMsgFilterLoad([]byte{0x01}, 10, 0, BloomUpdateNone) msgFilterLoad := NewMsgFilterLoad([]byte{0x01}, 10, 0, BloomUpdateNone)
bh := NewBlockHeader(1, []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, &daghash.Hash{}, 0, 0) bh := NewBlockHeader(1, []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)
msgMerkleBlock := NewMsgMerkleBlock(bh) msgMerkleBlock := NewMsgMerkleBlock(bh)
msgReject := NewMsgReject("block", RejectDuplicate, "duplicate block") msgReject := NewMsgReject("block", RejectDuplicate, "duplicate block")
msgGetCFilters := NewMsgGetCFilters(GCSFilterExtended, 0, &daghash.Hash{}) msgGetCFilters := NewMsgGetCFilters(GCSFilterExtended, 0, &daghash.Hash{})
@ -91,7 +91,7 @@ func TestMessage(t *testing.T) {
{msgGetAddr, msgGetAddr, pver, MainNet, 24}, {msgGetAddr, msgGetAddr, pver, MainNet, 24},
{msgAddr, msgAddr, pver, MainNet, 25}, {msgAddr, msgAddr, pver, MainNet, 25},
{msgGetBlocks, msgGetBlocks, pver, MainNet, 61}, {msgGetBlocks, msgGetBlocks, pver, MainNet, 61},
{msgBlock, msgBlock, pver, MainNet, 308}, {msgBlock, msgBlock, pver, MainNet, 340},
{msgInv, msgInv, pver, MainNet, 25}, {msgInv, msgInv, pver, MainNet, 25},
{msgGetData, msgGetData, pver, MainNet, 25}, {msgGetData, msgGetData, pver, MainNet, 25},
{msgNotFound, msgNotFound, pver, MainNet, 25}, {msgNotFound, msgNotFound, pver, MainNet, 25},
@ -107,7 +107,7 @@ func TestMessage(t *testing.T) {
{msgFilterAdd, msgFilterAdd, pver, MainNet, 26}, {msgFilterAdd, msgFilterAdd, pver, MainNet, 26},
{msgFilterClear, msgFilterClear, pver, MainNet, 24}, {msgFilterClear, msgFilterClear, pver, MainNet, 24},
{msgFilterLoad, msgFilterLoad, pver, MainNet, 35}, {msgFilterLoad, msgFilterLoad, pver, MainNet, 35},
{msgMerkleBlock, msgMerkleBlock, pver, MainNet, 151}, {msgMerkleBlock, msgMerkleBlock, pver, MainNet, 183},
{msgReject, msgReject, pver, MainNet, 79}, {msgReject, msgReject, pver, MainNet, 79},
{msgGetCFilters, msgGetCFilters, pver, MainNet, 61}, {msgGetCFilters, msgGetCFilters, pver, MainNet, 61},
{msgGetCFHeaders, msgGetCFHeaders, pver, MainNet, 61}, {msgGetCFHeaders, msgGetCFHeaders, pver, MainNet, 61},

9
wire/msgblock.go
View File

@ -231,15 +231,6 @@ func (msg *MsgBlock) BlockHash() daghash.Hash {
return msg.Header.BlockHash() return msg.Header.BlockHash()
} }
// TxHashes returns a slice of hashes of all of transactions in this block.
func (msg *MsgBlock) TxHashes() ([]daghash.Hash, error) {
hashList := make([]daghash.Hash, 0, len(msg.Transactions))
for _, tx := range msg.Transactions {
hashList = append(hashList, tx.TxHash())
}
return hashList, nil
}
// NewMsgBlock returns a new bitcoin block message that conforms to the // NewMsgBlock returns a new bitcoin block message that conforms to the
// Message interface. See MsgBlock for details. // Message interface. See MsgBlock for details.
func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock { func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {

89
wire/msgblock_test.go
View File

@ -22,10 +22,11 @@ func TestBlock(t *testing.T) {
// Block 1 header. // Block 1 header.
parentHashes := blockOne.Header.ParentHashes parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits bits := blockOne.Header.Bits
nonce := blockOne.Header.Nonce nonce := blockOne.Header.Nonce
bh := NewBlockHeader(1, parentHashes, merkleHash, bits, nonce) bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot, bits, nonce)
// Ensure the command is expected value. // Ensure the command is expected value.
wantCmd := "block" wantCmd := "block"
@ -68,32 +69,10 @@ func TestBlock(t *testing.T) {
} }
} }
// TestBlockTxHashes tests the ability to generate a slice of all transaction
// hashes from a block accurately.
func TestBlockTxHashes(t *testing.T) {
// Block 1, transaction 1 hash.
hashStr := "f8f148865a0ecb895a2b8fffd37245b3d4f5e01213bdaaa38a52b74e2f3289b4"
wantHash, err := daghash.NewHashFromStr(hashStr)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
return
}
wantHashes := []daghash.Hash{*wantHash}
hashes, err := blockOne.TxHashes()
if err != nil {
t.Errorf("TxHashes: %v", err)
}
if !reflect.DeepEqual(hashes, wantHashes) {
t.Errorf("TxHashes: wrong transaction hashes - got %v, want %v",
spew.Sdump(hashes), spew.Sdump(wantHashes))
}
}
// TestBlockHash tests the ability to generate the hash of a block accurately. // TestBlockHash tests the ability to generate the hash of a block accurately.
func TestBlockHash(t *testing.T) { func TestBlockHash(t *testing.T) {
// Block 1 hash. // Block 1 hash.
hashStr := "f10122ba81929ca2bc907541ebb20302122ce83a24ff9124c9e36402ecd837b7" hashStr := "67ec32b619b4cda3255de5318c730e2e9f696d335427adfecae884aa41156b0f"
wantHash, err := daghash.NewHashFromStr(hashStr) wantHash, err := daghash.NewHashFromStr(hashStr)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewHashFromStr: %v", err)
@ -218,18 +197,20 @@ func TestBlockWireErrors(t *testing.T) {
{&blockOne, blockOneBytes, pver, 5, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2. // Force error in prev block hash #2.
{&blockOne, blockOneBytes, pver, 37, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
// Force error in merkle root. // Force error in hash merkle root.
{&blockOne, blockOneBytes, pver, 69, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
// Force error in timestamp. // Force error in ID merkle root.
{&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{&blockOne, blockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
// Force error in difficulty bits. // Force error in difficulty bits.
{&blockOne, blockOneBytes, pver, 109, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 141, io.ErrShortWrite, io.EOF},
// Force error in header nonce. // Force error in header nonce.
{&blockOne, blockOneBytes, pver, 113, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 145, io.ErrShortWrite, io.EOF},
// Force error in transaction count. // Force error in transaction count.
{&blockOne, blockOneBytes, pver, 121, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 153, io.ErrShortWrite, io.EOF},
// Force error in transactions. // Force error in transactions.
{&blockOne, blockOneBytes, pver, 122, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, pver, 154, io.ErrShortWrite, io.EOF},
} }
t.Logf("Running %d tests", len(tests)) t.Logf("Running %d tests", len(tests))
@ -340,18 +321,20 @@ func TestBlockSerializeErrors(t *testing.T) {
{&blockOne, blockOneBytes, 5, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2. // Force error in prev block hash #2.
{&blockOne, blockOneBytes, 37, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 37, io.ErrShortWrite, io.EOF},
// Force error in merkle root. // Force error in hash merkle root.
{&blockOne, blockOneBytes, 69, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 69, io.ErrShortWrite, io.EOF},
// Force error in timestamp. // Force error in ID merkle root.
{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
// Force error in difficulty bits. // Force error in difficulty bits.
{&blockOne, blockOneBytes, 109, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 141, io.ErrShortWrite, io.EOF},
// Force error in header nonce. // Force error in header nonce.
{&blockOne, blockOneBytes, 113, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 145, io.ErrShortWrite, io.EOF},
// Force error in transaction count. // Force error in transaction count.
{&blockOne, blockOneBytes, 121, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 153, io.ErrShortWrite, io.EOF},
// Force error in transactions. // Force error in transactions.
{&blockOne, blockOneBytes, 122, io.ErrShortWrite, io.EOF}, {&blockOne, blockOneBytes, 154, io.ErrShortWrite, io.EOF},
} }
t.Logf("Running %d tests", len(tests)) t.Logf("Running %d tests", len(tests))
@ -414,10 +397,14 @@ func TestBlockOverflowErrors(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0, 0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91, 0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68, 0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot 0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // HashMerkleRoot
0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61, 0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32, 0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, 0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -470,7 +457,7 @@ func TestBlockSerializeSize(t *testing.T) {
size int // Expected serialized size size int // Expected serialized size
}{ }{
// Block with no transactions. // Block with no transactions.
{noTxBlock, 122}, {noTxBlock, 154},
// First block in the mainnet block chain. // First block in the mainnet block chain.
{&blockOne, len(blockOneBytes)}, {&blockOne, len(blockOneBytes)},
@ -491,13 +478,13 @@ func TestBlockSerializeSize(t *testing.T) {
// blockOne is the first block in the mainnet block chain. // blockOne is the first block in the mainnet block chain.
var blockOne = MsgBlock{ var blockOne = MsgBlock{
Header: BlockHeader{ Header: BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: daghash.Hash(mainNetGenesisMerkleRoot), HashMerkleRoot: daghash.Hash(mainNetGenesisMerkleRoot),
IDMerkleRoot: exampleIDMerkleRoot,
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Bits: 0x1d00ffff, // 486604799 Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689 Nonce: 0x9962e301, // 2573394689
}, },
Transactions: []*MsgTx{ Transactions: []*MsgTx{
{ {
@ -505,7 +492,7 @@ var blockOne = MsgBlock{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -550,10 +537,14 @@ var blockOneBytes = []byte{
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0, 0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91, 0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68, 0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot 0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // HashMerkleRoot
0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f, 0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a, 0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b, 0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -590,5 +581,5 @@ var blockOneBytes = []byte{
// Transaction location information for block one transactions. // Transaction location information for block one transactions.
var blockOneTxLocs = []TxLoc{ var blockOneTxLocs = []TxLoc{
{TxStart: 122, TxLen: 162}, {TxStart: 154, TxLen: 162},
} }

30
wire/msgheaders_test.go
View File

@ -29,7 +29,7 @@ func TestHeaders(t *testing.T) {
// Ensure max payload is expected value for latest protocol version. // Ensure max payload is expected value for latest protocol version.
// Num headers (varInt) + max allowed headers (header length + 1 byte // Num headers (varInt) + max allowed headers (header length + 1 byte
// for the number of transactions which is always 0). // for the number of transactions which is always 0).
wantPayload := uint32(16436009) wantPayload := uint32(16500009)
maxPayload := msg.MaxPayloadLength(pver) maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload { if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+ t.Errorf("MaxPayloadLength: wrong max payload length for "+
@ -62,10 +62,11 @@ func TestHeaders(t *testing.T) {
// numbers of headers and protocol versions. // numbers of headers and protocol versions.
func TestHeadersWire(t *testing.T) { func TestHeadersWire(t *testing.T) {
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash} hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := blockOne.Header.MerkleRoot hashMerkleRoot := blockOne.Header.HashMerkleRoot
idMerkleRoot := blockOne.Header.IDMerkleRoot
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
nonce := uint64(0x9962e301) nonce := uint64(0x9962e301)
bh := NewBlockHeader(1, hashes, &merkleHash, bits, nonce) bh := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bh.Version = blockOne.Header.Version bh.Version = blockOne.Header.Version
bh.Timestamp = blockOne.Header.Timestamp bh.Timestamp = blockOne.Header.Timestamp
@ -94,6 +95,10 @@ func TestHeadersWire(t *testing.T) {
0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f, 0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a, 0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b, 0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -224,10 +229,11 @@ func TestHeadersWireErrors(t *testing.T) {
wireErr := &MessageError{} wireErr := &MessageError{}
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash} hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := blockOne.Header.MerkleRoot hashMerkleRoot := blockOne.Header.HashMerkleRoot
idMerkleRoot := blockOne.Header.IDMerkleRoot
bits := uint32(0x1d00ffff) bits := uint32(0x1d00ffff)
nonce := uint64(0x9962e301) nonce := uint64(0x9962e301)
bh := NewBlockHeader(1, hashes, &merkleHash, bits, nonce) bh := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bh.Version = blockOne.Header.Version bh.Version = blockOne.Header.Version
bh.Timestamp = blockOne.Header.Timestamp bh.Timestamp = blockOne.Header.Timestamp
@ -250,6 +256,10 @@ func TestHeadersWireErrors(t *testing.T) {
0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61, 0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32, 0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, 0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -269,7 +279,7 @@ func TestHeadersWireErrors(t *testing.T) {
// Intentionally invalid block header that has a transaction count used // Intentionally invalid block header that has a transaction count used
// to force errors. // to force errors.
bhTrans := NewBlockHeader(1, hashes, &merkleHash, bits, nonce) bhTrans := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bhTrans.Version = blockOne.Header.Version bhTrans.Version = blockOne.Header.Version
bhTrans.Timestamp = blockOne.Header.Timestamp bhTrans.Timestamp = blockOne.Header.Timestamp
@ -287,10 +297,14 @@ func TestHeadersWireErrors(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0, 0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91, 0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68, 0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot 0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // HashMerkleRoot
0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61, 0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32, 0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, 0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@ -313,7 +327,7 @@ func TestHeadersWireErrors(t *testing.T) {
// Force error with greater than max headers. // Force error with greater than max headers.
{maxHeaders, maxHeadersEncoded, pver, 3, wireErr, wireErr}, {maxHeaders, maxHeadersEncoded, pver, 3, wireErr, wireErr},
// Force error with number of transactions. // Force error with number of transactions.
{transHeader, transHeaderEncoded, pver, 114, io.ErrShortWrite, io.EOF}, {transHeader, transHeaderEncoded, pver, 146, io.ErrShortWrite, io.EOF},
// Force error with included transactions. // Force error with included transactions.
{transHeader, transHeaderEncoded, pver, len(transHeaderEncoded), nil, wireErr}, {transHeader, transHeaderEncoded, pver, len(transHeaderEncoded), nil, wireErr},
} }

51
wire/msgmerkleblock_test.go
View File

@ -22,10 +22,11 @@ func TestMerkleBlock(t *testing.T) {
// Block 1 header. // Block 1 header.
parentHashes := blockOne.Header.ParentHashes parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits bits := blockOne.Header.Bits
nonce := blockOne.Header.Nonce nonce := blockOne.Header.Nonce
bh := NewBlockHeader(1, parentHashes, merkleHash, bits, nonce) bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot, bits, nonce)
// Ensure the command is expected value. // Ensure the command is expected value.
wantCmd := "merkleblock" wantCmd := "merkleblock"
@ -114,10 +115,11 @@ func TestMerkleBlock(t *testing.T) {
func TestMerkleBlockCrossProtocol(t *testing.T) { func TestMerkleBlockCrossProtocol(t *testing.T) {
// Block 1 header. // Block 1 header.
parentHashes := blockOne.Header.ParentHashes parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits bits := blockOne.Header.Bits
nonce := blockOne.Header.Nonce nonce := blockOne.Header.Nonce
bh := NewBlockHeader(1, parentHashes, merkleHash, bits, nonce) bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot, bits, nonce)
msg := NewMsgMerkleBlock(bh) msg := NewMsgMerkleBlock(bh)
@ -215,26 +217,28 @@ func TestMerkleBlockWireErrors(t *testing.T) {
{&merkleBlockOne, merkleBlockOneBytes, pver, 5, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2. // Force error in prev block hash #2.
{&merkleBlockOne, merkleBlockOneBytes, pver, 37, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
// Force error in merkle root. // Force error in hash merkle root.
{&merkleBlockOne, merkleBlockOneBytes, pver, 69, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
// Force error in timestamp. // Force error in hash merkle root.
{&merkleBlockOne, merkleBlockOneBytes, pver, 101, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{&merkleBlockOne, merkleBlockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
// Force error in difficulty bits. // Force error in difficulty bits.
{&merkleBlockOne, merkleBlockOneBytes, pver, 109, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 141, io.ErrShortWrite, io.EOF},
// Force error in header nonce. // Force error in header nonce.
{&merkleBlockOne, merkleBlockOneBytes, pver, 113, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 145, io.ErrShortWrite, io.EOF},
// Force error in transaction count. // Force error in transaction count.
{&merkleBlockOne, merkleBlockOneBytes, pver, 121, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 153, io.ErrShortWrite, io.EOF},
// Force error in num hashes. // Force error in num hashes.
{&merkleBlockOne, merkleBlockOneBytes, pver, 125, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 157, io.ErrShortWrite, io.EOF},
// Force error in hashes. // Force error in hashes.
{&merkleBlockOne, merkleBlockOneBytes, pver, 126, io.ErrShortWrite, io.EOF},
// Force error in num flag bytes.
{&merkleBlockOne, merkleBlockOneBytes, pver, 158, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 158, io.ErrShortWrite, io.EOF},
// Force error in num flag bytes.
{&merkleBlockOne, merkleBlockOneBytes, pver, 190, io.ErrShortWrite, io.EOF},
// Force error in flag bytes. // Force error in flag bytes.
{&merkleBlockOne, merkleBlockOneBytes, pver, 159, io.ErrShortWrite, io.EOF}, {&merkleBlockOne, merkleBlockOneBytes, pver, 191, io.ErrShortWrite, io.EOF},
// Force error due to unsupported protocol version. // Force error due to unsupported protocol version.
{&merkleBlockOne, merkleBlockOneBytes, pverNoMerkleBlock, 159, wireErr, wireErr}, {&merkleBlockOne, merkleBlockOneBytes, pverNoMerkleBlock, 191, wireErr, wireErr},
} }
t.Logf("Running %d tests", len(tests)) t.Logf("Running %d tests", len(tests))
@ -294,7 +298,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
// allowed tx hashes. // allowed tx hashes.
var buf bytes.Buffer var buf bytes.Buffer
WriteVarInt(&buf, pver, maxTxPerBlock+1) WriteVarInt(&buf, pver, maxTxPerBlock+1)
numHashesOffset := 125 numHashesOffset := 157
exceedMaxHashes := make([]byte, numHashesOffset) exceedMaxHashes := make([]byte, numHashesOffset)
copy(exceedMaxHashes, merkleBlockOneBytes[:numHashesOffset]) copy(exceedMaxHashes, merkleBlockOneBytes[:numHashesOffset])
exceedMaxHashes = append(exceedMaxHashes, buf.Bytes()...) exceedMaxHashes = append(exceedMaxHashes, buf.Bytes()...)
@ -303,7 +307,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
// allowed flag bytes. // allowed flag bytes.
buf.Reset() buf.Reset()
WriteVarInt(&buf, pver, maxFlagsPerMerkleBlock+1) WriteVarInt(&buf, pver, maxFlagsPerMerkleBlock+1)
numFlagBytesOffset := 158 numFlagBytesOffset := 190
exceedMaxFlagBytes := make([]byte, numFlagBytesOffset) exceedMaxFlagBytes := make([]byte, numFlagBytesOffset)
copy(exceedMaxFlagBytes, merkleBlockOneBytes[:numFlagBytesOffset]) copy(exceedMaxFlagBytes, merkleBlockOneBytes[:numFlagBytesOffset])
exceedMaxFlagBytes = append(exceedMaxFlagBytes, buf.Bytes()...) exceedMaxFlagBytes = append(exceedMaxFlagBytes, buf.Bytes()...)
@ -339,15 +343,16 @@ var merkleBlockOne = MsgMerkleBlock{
Header: BlockHeader{ Header: BlockHeader{
Version: 1, Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: daghash.Hash([daghash.HashSize]byte{ // Make go vet happy. HashMerkleRoot: daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44, 0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44,
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67, 0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1, 0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e, 0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
}), }),
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST IDMerkleRoot: exampleIDMerkleRoot,
Bits: 0x1d00ffff, // 486604799 Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Nonce: 0x9962e301, // 2573394689 Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689
}, },
Transactions: 1, Transactions: 1,
Hashes: []*daghash.Hash{ Hashes: []*daghash.Hash{
@ -377,7 +382,11 @@ var merkleBlockOneBytes = []byte{
0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44, // MerkleRoot 0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44, // MerkleRoot
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67, 0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1, 0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e, // MerkleRoot 0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp 0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
0xff, 0xff, 0x00, 0x1d, // Bits 0xff, 0xff, 0x00, 0x1d, // Bits
0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce 0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce

127
wire/msgtx.go
View File

@ -98,6 +98,18 @@ const (
freeListMaxItems = 12500 freeListMaxItems = 12500
) )
// txEncoding is a bitmask defining which transaction fields we
// want to encode and which to ignore.
type txEncoding uint8
const (
txEncodingFull txEncoding = 0
txEncodingExcludeSubNetworkData txEncoding = 1 << iota
txEncodingExcludeSignatureScript
)
var ( var (
// SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks // SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks
SubnetworkIDSupportsAll = subnetworkid.SubnetworkID{} SubnetworkIDSupportsAll = subnetworkid.SubnetworkID{}
@ -169,7 +181,7 @@ var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)
// OutPoint defines a bitcoin data type that is used to track previous // OutPoint defines a bitcoin data type that is used to track previous
// transaction outputs. // transaction outputs.
type OutPoint struct { type OutPoint struct {
Hash daghash.Hash TxID daghash.Hash
Index uint32 Index uint32
} }
@ -177,7 +189,7 @@ type OutPoint struct {
// provided hash and index. // provided hash and index.
func NewOutPoint(hash *daghash.Hash, index uint32) *OutPoint { func NewOutPoint(hash *daghash.Hash, index uint32) *OutPoint {
return &OutPoint{ return &OutPoint{
Hash: *hash, TxID: *hash,
Index: index, Index: index,
} }
} }
@ -191,7 +203,7 @@ func (o OutPoint) String() string {
// optimization may go unnoticed, so allocate space for 10 decimal // optimization may go unnoticed, so allocate space for 10 decimal
// digits, which will fit any uint32. // digits, which will fit any uint32.
buf := make([]byte, 2*daghash.HashSize+1, 2*daghash.HashSize+1+10) buf := make([]byte, 2*daghash.HashSize+1, 2*daghash.HashSize+1+10)
copy(buf, o.Hash.String()) copy(buf, o.TxID.String())
buf[2*daghash.HashSize] = ':' buf[2*daghash.HashSize] = ':'
buf = strconv.AppendUint(buf, uint64(o.Index), 10) buf = strconv.AppendUint(buf, uint64(o.Index), 10)
return string(buf) return string(buf)
@ -207,11 +219,22 @@ type TxIn struct {
// SerializeSize returns the number of bytes it would take to serialize the // SerializeSize returns the number of bytes it would take to serialize the
// the transaction input. // the transaction input.
func (t *TxIn) SerializeSize() int { func (t *TxIn) SerializeSize() int {
return t.serializeSize(txEncodingFull)
}
func (t *TxIn) serializeSize(encodingFlags txEncoding) int {
// Outpoint Hash 32 bytes + Outpoint Index 4 bytes + Sequence 8 bytes + // Outpoint Hash 32 bytes + Outpoint Index 4 bytes + Sequence 8 bytes +
// serialized varint size for the length of SignatureScript + // serialized varint size for the length of SignatureScript +
// SignatureScript bytes. // SignatureScript bytes.
return 44 + VarIntSerializeSize(uint64(len(t.SignatureScript))) + return 44 + serializeSignatureScriptSize(t.SignatureScript, encodingFlags)
len(t.SignatureScript) }
func serializeSignatureScriptSize(signatureScript []byte, encodingFlags txEncoding) int {
if encodingFlags&txEncodingExcludeSignatureScript != txEncodingExcludeSignatureScript {
return VarIntSerializeSize(uint64(len(signatureScript))) +
len(signatureScript)
}
return VarIntSerializeSize(0)
} }
// NewTxIn returns a new bitcoin transaction input with the provided // NewTxIn returns a new bitcoin transaction input with the provided
@ -274,6 +297,23 @@ func (msg *MsgTx) AddTxOut(to *TxOut) {
msg.TxOut = append(msg.TxOut, to) msg.TxOut = append(msg.TxOut, to)
} }
// IsCoinBase determines whether or not a transaction is a coinbase. A coinbase
// is a special transaction created by miners that has no inputs. This is
// represented in the block dag by a transaction with a single input that has
// a previous output transaction index set to the maximum value along with a
// zero hash.
func (msg *MsgTx) IsCoinBase() bool {
// A coin base must only have one transaction input.
if len(msg.TxIn) != 1 {
return false
}
// The previous output of a coinbase must have a max value index and
// a zero hash.
prevOut := &msg.TxIn[0].PreviousOutPoint
return prevOut.Index == math.MaxUint32 && prevOut.TxID == daghash.Zero
}
// TxHash generates the Hash for the transaction. // TxHash generates the Hash for the transaction.
func (msg *MsgTx) TxHash() daghash.Hash { func (msg *MsgTx) TxHash() daghash.Hash {
// Encode the transaction and calculate double sha256 on the result. // Encode the transaction and calculate double sha256 on the result.
@ -285,6 +325,22 @@ func (msg *MsgTx) TxHash() daghash.Hash {
return daghash.DoubleHashH(buf.Bytes()) return daghash.DoubleHashH(buf.Bytes())
} }
// TxID generates the Hash for the transaction without the signature script, gas and payload fields.
func (msg *MsgTx) TxID() daghash.Hash {
// Encode the transaction, replace signature script, payload and gas with
// zeroes, and calculate double sha256 on the result.
// Ignore the error returns since the only way the encode could fail
// is being out of memory or due to nil pointers, both of which would
// cause a run-time panic.
var encodingFlags txEncoding
if !msg.IsCoinBase() {
encodingFlags = txEncodingExcludeSignatureScript | txEncodingExcludeSubNetworkData
}
buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(encodingFlags)))
_ = msg.serialize(buf, encodingFlags)
return daghash.DoubleHashH(buf.Bytes())
}
// Copy creates a deep copy of a transaction so that the original does not get // Copy creates a deep copy of a transaction so that the original does not get
// modified when the copy is manipulated. // modified when the copy is manipulated.
func (msg *MsgTx) Copy() *MsgTx { func (msg *MsgTx) Copy() *MsgTx {
@ -309,7 +365,7 @@ func (msg *MsgTx) Copy() *MsgTx {
// Deep copy the old previous outpoint. // Deep copy the old previous outpoint.
oldOutPoint := oldTxIn.PreviousOutPoint oldOutPoint := oldTxIn.PreviousOutPoint
newOutPoint := OutPoint{} newOutPoint := OutPoint{}
newOutPoint.Hash.SetBytes(oldOutPoint.Hash[:]) newOutPoint.TxID.SetBytes(oldOutPoint.TxID[:])
newOutPoint.Index = oldOutPoint.Index newOutPoint.Index = oldOutPoint.Index
// Deep copy the old signature script. // Deep copy the old signature script.
@ -560,6 +616,10 @@ func (msg *MsgTx) Deserialize(r io.Reader) error {
// See Serialize for encoding transactions to be stored to disk, such as in a // See Serialize for encoding transactions to be stored to disk, such as in a
// database, as opposed to encoding transactions for the wire. // database, as opposed to encoding transactions for the wire.
func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error { func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
return msg.encode(w, pver, txEncodingFull)
}
func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) error {
err := binarySerializer.PutUint32(w, littleEndian, uint32(msg.Version)) err := binarySerializer.PutUint32(w, littleEndian, uint32(msg.Version))
if err != nil { if err != nil {
return err return err
@ -572,7 +632,7 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
} }
for _, ti := range msg.TxIn { for _, ti := range msg.TxIn {
err = writeTxIn(w, pver, msg.Version, ti) err = writeTxIn(w, pver, msg.Version, ti, encodingFlags)
if err != nil { if err != nil {
return err return err
} }
@ -612,11 +672,12 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
return err return err
} }
err = WriteVarInt(w, pver, uint64(len(msg.Payload))) if encodingFlags&txEncodingExcludeSubNetworkData != txEncodingExcludeSubNetworkData {
if err != nil { err = WriteVarInt(w, pver, uint64(len(msg.Payload)))
return err w.Write(msg.Payload)
} else {
err = WriteVarInt(w, pver, 0)
} }
_, err := w.Write(msg.Payload)
if err != nil { if err != nil {
return err return err
} }
@ -648,9 +709,22 @@ func (msg *MsgTx) Serialize(w io.Writer) error {
return msg.BtcEncode(w, 0) return msg.BtcEncode(w, 0)
} }
// SerializeSize returns the number of bytes it would take to serialize the func (msg *MsgTx) serialize(w io.Writer, encodingFlags txEncoding) error {
// At the current time, there is no difference between the wire encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of `encode`.
return msg.encode(w, 0, encodingFlags)
}
// SerializeSize returns the number of bytes it would take to serialize
// the transaction. // the transaction.
func (msg *MsgTx) SerializeSize() int { func (msg *MsgTx) SerializeSize() int {
return msg.serializeSize(txEncodingFull)
}
// SerializeSize returns the number of bytes it would take to serialize
// the transaction.
func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
// Version 4 bytes + LockTime 8 bytes + SubnetworkID 20 // Version 4 bytes + LockTime 8 bytes + SubnetworkID 20
// bytes + Serialized varint size for the number of transaction // bytes + Serialized varint size for the number of transaction
// inputs and outputs. // inputs and outputs.
@ -658,19 +732,28 @@ func (msg *MsgTx) SerializeSize() int {
VarIntSerializeSize(uint64(len(msg.TxOut))) VarIntSerializeSize(uint64(len(msg.TxOut)))
if msg.SubnetworkID != SubnetworkIDNative { if msg.SubnetworkID != SubnetworkIDNative {
// Gas 8 bytes + Serialized varint size for the length of the payload // Gas 8 bytes
n += 8 + VarIntSerializeSize(uint64(len(msg.Payload))) n += 8
// Serialized varint size for the length of the payload
if encodingFlags&txEncodingExcludeSubNetworkData != txEncodingExcludeSubNetworkData {
n += VarIntSerializeSize(uint64(len(msg.Payload)))
} else {
n += VarIntSerializeSize(0)
}
} }
for _, txIn := range msg.TxIn { for _, txIn := range msg.TxIn {
n += txIn.SerializeSize() n += txIn.serializeSize(encodingFlags)
} }
for _, txOut := range msg.TxOut { for _, txOut := range msg.TxOut {
n += txOut.SerializeSize() n += txOut.SerializeSize()
} }
n += len(msg.Payload) if encodingFlags&txEncodingExcludeSubNetworkData != txEncodingExcludeSubNetworkData {
n += len(msg.Payload)
}
return n return n
} }
@ -759,7 +842,7 @@ func newRegistryMsgTx(version int32, gasLimit uint64) *MsgTx {
// readOutPoint reads the next sequence of bytes from r as an OutPoint. // readOutPoint reads the next sequence of bytes from r as an OutPoint.
func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error { func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
_, err := io.ReadFull(r, op.Hash[:]) _, err := io.ReadFull(r, op.TxID[:])
if err != nil { if err != nil {
return err return err
} }
@ -771,7 +854,7 @@ func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
// writeOutPoint encodes op to the bitcoin protocol encoding for an OutPoint // writeOutPoint encodes op to the bitcoin protocol encoding for an OutPoint
// to w. // to w.
func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error { func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
_, err := w.Write(op.Hash[:]) _, err := w.Write(op.TxID[:])
if err != nil { if err != nil {
return err return err
} }
@ -829,13 +912,17 @@ func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
// writeTxIn encodes ti to the bitcoin protocol encoding for a transaction // writeTxIn encodes ti to the bitcoin protocol encoding for a transaction
// input (TxIn) to w. // input (TxIn) to w.
func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn) error { func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn, encodingFlags txEncoding) error {
err := writeOutPoint(w, pver, version, &ti.PreviousOutPoint) err := writeOutPoint(w, pver, version, &ti.PreviousOutPoint)
if err != nil { if err != nil {
return err return err
} }
err = WriteVarBytes(w, pver, ti.SignatureScript) if encodingFlags&txEncodingExcludeSignatureScript != txEncodingExcludeSignatureScript {
err = WriteVarBytes(w, pver, ti.SignatureScript)
} else {
err = WriteVarBytes(w, pver, []byte{})
}
if err != nil { if err != nil {
return err return err
} }

117
wire/msgtx_test.go
View File

@ -51,9 +51,9 @@ func TestTx(t *testing.T) {
// testing package functionality. // testing package functionality.
prevOutIndex := uint32(1) prevOutIndex := uint32(1)
prevOut := NewOutPoint(hash, prevOutIndex) prevOut := NewOutPoint(hash, prevOutIndex)
if !prevOut.Hash.IsEqual(hash) { if !prevOut.TxID.IsEqual(hash) {
t.Errorf("NewOutPoint: wrong hash - got %v, want %v", t.Errorf("NewOutPoint: wrong hash - got %v, want %v",
spew.Sprint(&prevOut.Hash), spew.Sprint(hash)) spew.Sprint(&prevOut.TxID), spew.Sprint(hash))
} }
if prevOut.Index != prevOutIndex { if prevOut.Index != prevOutIndex {
t.Errorf("NewOutPoint: wrong index - got %v, want %v", t.Errorf("NewOutPoint: wrong index - got %v, want %v",
@ -129,20 +129,19 @@ func TestTx(t *testing.T) {
} }
// TestTxHash tests the ability to generate the hash of a transaction accurately. // TestTxHash tests the ability to generate the hash of a transaction accurately.
func TestTxHash(t *testing.T) { func TestTxHashAndID(t *testing.T) {
// Hash of first transaction from block 113875. hash1Str := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa"
hashStr := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa" wantHash1, err := daghash.NewHashFromStr(hash1Str)
wantHash, err := daghash.NewHashFromStr(hashStr)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewHashFromStr: %v", err)
return return
} }
// First transaction from block 113875. // First transaction from block 113875.
msgTx := NewMsgTx(1) tx1 := NewMsgTx(1)
txIn := TxIn{ txIn := TxIn{
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}, SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
@ -164,15 +163,103 @@ func TestTxHash(t *testing.T) {
0xac, // OP_CHECKSIG 0xac, // OP_CHECKSIG
}, },
} }
msgTx.AddTxIn(&txIn) tx1.AddTxIn(&txIn)
msgTx.AddTxOut(&txOut) tx1.AddTxOut(&txOut)
msgTx.LockTime = 0 tx1.LockTime = 0
// Ensure the hash produced is expected. // Ensure the hash produced is expected.
txHash := msgTx.TxHash() tx1Hash := tx1.TxHash()
if !txHash.IsEqual(wantHash) { if !tx1Hash.IsEqual(wantHash1) {
t.Errorf("TxHash: wrong hash - got %v, want %v", t.Errorf("TxHash: wrong hash - got %v, want %v",
spew.Sprint(txHash), spew.Sprint(wantHash)) spew.Sprint(tx1Hash), spew.Sprint(wantHash1))
}
// Ensure the TxID for coinbase transaction is the same as TxHash.
tx1ID := tx1.TxID()
if !tx1ID.IsEqual(wantHash1) {
t.Errorf("TxID: wrong ID - got %v, want %v",
spew.Sprint(tx1ID), spew.Sprint(wantHash1))
}
hash2Str := "ef55c85be28615b699bef1470d0d041982a6f3af5f900c978c3837b967b168b3"
wantHash2, err := daghash.NewHashFromStr(hash2Str)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
return
}
id2Str := "12063f97b5fbbf441bd7962f88631a36a4b4a67649045c02ed840bedc97e88ea"
wantID2, err := daghash.NewHashFromStr(id2Str)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
return
}
tx2 := &MsgTx{
Version: 1,
TxIn: []*TxIn{
{
PreviousOutPoint: OutPoint{
Index: 0,
TxID: daghash.Hash{1, 2, 3},
},
SignatureScript: []byte{
0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF,
0x05, 0x77, 0x37, 0x57, 0xDE, 0xB1, 0x68, 0x82, 0x09, 0x30, 0xE3, 0xB0, 0xD0, 0x3F, 0x46, 0xF5,
0xFC, 0xF1, 0x50, 0xBF, 0x99, 0x0C, 0x02, 0x21, 0x00, 0xD2, 0x5B, 0x5C, 0x87, 0x04, 0x00, 0x76,
0xE4, 0xF2, 0x53, 0xF8, 0x26, 0x2E, 0x76, 0x3E, 0x2D, 0xD5, 0x1E, 0x7F, 0xF0, 0xBE, 0x15, 0x77,
0x27, 0xC4, 0xBC, 0x42, 0x80, 0x7F, 0x17, 0xBD, 0x39, 0x01, 0x41, 0x04, 0xE6, 0xC2, 0x6E, 0xF6,
0x7D, 0xC6, 0x10, 0xD2, 0xCD, 0x19, 0x24, 0x84, 0x78, 0x9A, 0x6C, 0xF9, 0xAE, 0xA9, 0x93, 0x0B,
0x94, 0x4B, 0x7E, 0x2D, 0xB5, 0x34, 0x2B, 0x9D, 0x9E, 0x5B, 0x9F, 0xF7, 0x9A, 0xFF, 0x9A, 0x2E,
0xE1, 0x97, 0x8D, 0xD7, 0xFD, 0x01, 0xDF, 0xC5, 0x22, 0xEE, 0x02, 0x28, 0x3D, 0x3B, 0x06, 0xA9,
0xD0, 0x3A, 0xCF, 0x80, 0x96, 0x96, 0x8D, 0x7D, 0xBB, 0x0F, 0x91, 0x78,
},
Sequence: math.MaxUint64,
},
},
TxOut: []*TxOut{
{
Value: 244623243,
PkScript: []byte{
0x76, 0xA9, 0x14, 0xBA, 0xDE, 0xEC, 0xFD, 0xEF, 0x05, 0x07, 0x24, 0x7F, 0xC8, 0xF7, 0x42, 0x41,
0xD7, 0x3B, 0xC0, 0x39, 0x97, 0x2D, 0x7B, 0x88, 0xAC,
},
},
{
Value: 44602432,
PkScript: []byte{
0x76, 0xA9, 0x14, 0xC1, 0x09, 0x32, 0x48, 0x3F, 0xEC, 0x93, 0xED, 0x51, 0xF5, 0xFE, 0x95, 0xE7,
0x25, 0x59, 0xF2, 0xCC, 0x70, 0x43, 0xF9, 0x88, 0xAC,
},
},
},
LockTime: 0,
SubnetworkID: subnetworkid.SubnetworkID{1, 2, 3},
Payload: []byte{1, 2, 3},
}
// Ensure the hash produced is expected.
tx2Hash := tx2.TxHash()
if !tx2Hash.IsEqual(wantHash2) {
t.Errorf("TxHash: wrong hash - got %v, want %v",
spew.Sprint(tx2Hash), spew.Sprint(wantHash2))
}
// Ensure the TxID for coinbase transaction is the same as TxHash.
tx2ID := tx2.TxID()
if !tx2ID.IsEqual(wantID2) {
t.Errorf("TxID: wrong ID - got %v, want %v",
spew.Sprint(tx2ID), spew.Sprint(wantID2))
}
if tx2ID.IsEqual(&tx2Hash) {
t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload")
}
tx2.Payload = []byte{}
tx2.TxIn[0].SignatureScript = []byte{}
newTx2Hash := tx2.TxHash()
if !tx2ID.IsEqual(&newTx2Hash) {
t.Errorf("tx2ID and newTx2Hash should be the same for transaction without empty signature and payload")
} }
} }
@ -864,7 +951,7 @@ var multiTx = &MsgTx{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
Hash: daghash.Hash{}, TxID: daghash.Hash{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{