Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-06-05 05:36:54 +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"
loadedBlocks, err := loadBlocks(orphanBlockFile)
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)
}
block := loadedBlocks[0]
@ -52,7 +52,7 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
blocksFile := "blk_0_to_4.dat"
blocks, err := loadBlocks(blocksFile)
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)
}

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
// immutable and are intentionally ordered to avoid padding on 64-bit
// platforms.
version int32
bits uint32
nonce uint64
timestamp int64
merkleRoot daghash.Hash
version int32
bits uint32
nonce uint64
timestamp int64
hashMerkleRoot daghash.Hash
idMerkleRoot daghash.Hash
// 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
@ -134,7 +135,8 @@ func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, parents block
node.bits = blockHeader.Bits
node.nonce = blockHeader.Nonce
node.timestamp = blockHeader.Timestamp.Unix()
node.merkleRoot = blockHeader.MerkleRoot
node.hashMerkleRoot = blockHeader.HashMerkleRoot
node.idMerkleRoot = blockHeader.IDMerkleRoot
// update parents to point to new node
for _, p := range parents {
@ -185,12 +187,13 @@ func (node *blockNode) detachFromParents() {
func (node *blockNode) Header() *wire.BlockHeader {
// No lock is needed because all accessed fields are immutable.
return &wire.BlockHeader{
Version: node.version,
ParentHashes: node.ParentHashes(),
MerkleRoot: node.merkleRoot,
Timestamp: time.Unix(node.timestamp, 0),
Bits: node.bits,
Nonce: node.nonce,
Version: node.version,
ParentHashes: node.ParentHashes(),
HashMerkleRoot: node.hashMerkleRoot,
IDMerkleRoot: node.idMerkleRoot,
Timestamp: time.Unix(node.timestamp, 0),
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()
for {
// Hash of the utxo entry.
var hash daghash.Hash
_, err := io.ReadAtLeast(r, hash[:], len(hash[:]))
// Tx ID of the utxo entry.
var txID daghash.Hash
_, err := io.ReadAtLeast(r, txID[:], len(txID[:]))
if err != nil {
// Expected EOF at the right offset.
if err == io.EOF {
@ -143,7 +143,7 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
if err != nil {
return nil, err
}
utxoSet.utxoCollection[wire.OutPoint{Hash: hash, Index: index}] = entry
utxoSet.utxoCollection[wire.OutPoint{TxID: txID, Index: index}] = entry
}
return utxoSet, nil

6
blockdag/dag.go
View File

@ -7,11 +7,12 @@ package blockdag
import (
"errors"
"fmt"
"github.com/daglabs/btcd/util/subnetworkid"
"math"
"sync"
"time"
"github.com/daglabs/btcd/util/subnetworkid"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash"
"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 "+
"transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex)
tx.ID(), txInIndex)
return sequenceLock, ruleError(ErrMissingTxOut, str)
}
@ -1343,6 +1344,7 @@ func (dag *BlockDAG) LocateHeaders(locator BlockLocator, hashStop *daghash.Hash)
return headers
}
// SubnetworkID returns the node's subnetwork ID
func (dag *BlockDAG) SubnetworkID() *subnetworkid.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.
dag, teardownFunc, err := DAGSetup("haveblock", Config{
dag, teardownFunc, err := DAGSetup("TestBlockCount", Config{
DAGParams: &dagconfig.SimNetParams,
SubnetworkID: &wire.SubnetworkIDSupportsAll,
})
@ -158,7 +158,7 @@ func TestHaveBlock(t *testing.T) {
}
rErr, ok := err.(RuleError)
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 {
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},
// 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).
{hash: "66965d8ebcdccae2b3791f652326ef1063fa0a7e506c66f68e0c7bbb59104711", want: true},
{hash: "22accd0c0281c0776dc3b5d5957bae3f61290e1075f97c99cd347c38cc26555a", want: true},
// Random hashes should not be available.
{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
// utxo. That is to say, the height prior to it.
utxo := wire.OutPoint{
Hash: *targetTx.Hash(),
TxID: *targetTx.ID(),
Index: 0,
}
prevUtxoHeight := int32(numBlocksToGenerate) - 4
@ -278,7 +278,7 @@ func TestCalcSequenceLock(t *testing.T) {
}},
}
unConfUtxo := wire.OutPoint{
Hash: unConfTx.TxHash(),
TxID: unConfTx.TxID(),
Index: 0,
}

4
blockdag/dagio.go
View File

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

10
blockdag/dagio_test.go
View File

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

36
blockdag/fullblocktests/generate.go
View File

@ -161,7 +161,7 @@ type spendableOut struct {
func makeSpendableOutForTx(tx *wire.MsgTx, txOutIndex uint32) spendableOut {
return spendableOut{
prevOut: wire.OutPoint{
Hash: tx.TxHash(),
TxID: tx.TxID(),
Index: txOutIndex,
},
amount: util.Amount(tx.TxOut[txOutIndex].Value),
@ -297,9 +297,9 @@ func (g *testGenerator) createCoinbaseTx(blockHeight int32) *wire.MsgTx {
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.
func calcMerkleRoot(txns []*wire.MsgTx) daghash.Hash {
func calcHashMerkleRoot(txns []*wire.MsgTx) daghash.Hash {
if len(txns) == 0 {
return daghash.Hash{}
}
@ -308,8 +308,8 @@ func calcMerkleRoot(txns []*wire.MsgTx) daghash.Hash {
for _, tx := range txns {
utilTxns = append(utilTxns, util.NewTx(tx))
}
merkles := blockdag.BuildMerkleTreeStore(utilTxns)
return *merkles[len(merkles)-1]
merkleTree := blockdag.BuildHashMerkleTreeStore(utilTxns)
return *merkleTree.Root()
}
// 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{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{g.tip.BlockHash()}, // TODO: (Stas) This is wrong. Modified only to satisfy compilation.
MerkleRoot: calcMerkleRoot(txns),
Bits: g.params.PowLimitBits,
Timestamp: ts,
Nonce: 0, // To be solved.
Version: 1,
ParentHashes: []daghash.Hash{g.tip.BlockHash()}, // TODO: (Stas) This is wrong. Modified only to satisfy compilation.
HashMerkleRoot: calcHashMerkleRoot(txns),
Bits: g.params.PowLimitBits,
Timestamp: ts,
Nonce: 0, // To be solved.
},
Transactions: txns,
}
// Perform any block munging just before solving. Only recalculate the
// merkle root if it wasn't manually changed by a munge function.
curMerkleRoot := block.Header.MerkleRoot
curMerkleRoot := block.Header.HashMerkleRoot
curNonce := block.Header.Nonce
for _, f := range mungers {
f(&block)
}
if block.Header.MerkleRoot == curMerkleRoot {
block.Header.MerkleRoot = calcMerkleRoot(block.Transactions)
if block.Header.HashMerkleRoot == curMerkleRoot {
block.Header.HashMerkleRoot = calcHashMerkleRoot(block.Transactions)
}
// 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
// tip block associated with the generator does not match the specified hash.
func (g *testGenerator) assertTipBlockMerkleRoot(expected daghash.Hash) {
hash := g.tip.Header.MerkleRoot
hash := g.tip.Header.HashMerkleRoot
if hash != expected {
panic(fmt.Sprintf("merkle root of block %q (height %d) is %v "+
"instead of expected %v", g.tipName, g.tipHeight, hash,
@ -1470,7 +1470,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
// \-> b48(14)
g.setTip("b43")
g.nextBlock("b48", outs[14], func(b *wire.MsgBlock) {
b.Header.MerkleRoot = daghash.Hash{}
b.Header.HashMerkleRoot = daghash.Hash{}
})
rejected(blockdag.ErrBadMerkleRoot)
@ -1531,7 +1531,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
g.nextBlock("b52", outs[14], func(b *wire.MsgBlock) {
hash := newHashFromStr("00000000000000000000000000000000" +
"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
})
rejected(blockdag.ErrMissingTxOut)
@ -1629,7 +1629,7 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
})
g.assertTipBlockNumTxns(4)
g.assertTipBlockHash(b57.BlockHash())
g.assertTipBlockMerkleRoot(b57.Header.MerkleRoot)
g.assertTipBlockMerkleRoot(b57.Header.HashMerkleRoot)
rejected(blockdag.ErrDuplicateTx)
// 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.
regTestGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
Timestamp: time.Unix(0x5b28c636, 0), // 2018-06-19 09:00:38 +0000 UTC
Bits: 0x207fffff, // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
Nonce: 1,
Version: 1,
ParentHashes: []daghash.Hash{},
HashMerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
Timestamp: time.Unix(0x5b28c636, 0), // 2018-06-19 09:00:38 +0000 UTC
Bits: 0x207fffff, // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
Nonce: 1,
},
Transactions: []*wire.MsgTx{{
Version: 1,
TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
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)
idx.txnsByAddr[addrKey] = addrIndexEntry
}
addrIndexEntry[*tx.Hash()] = tx
addrIndexEntry[*tx.ID()] = tx
// Add a mapping from the transaction to the address.
addrsByTxEntry := idx.addrsByTx[*tx.Hash()]
addrsByTxEntry := idx.addrsByTx[*tx.ID()]
if addrsByTxEntry == nil {
addrsByTxEntry = make(map[[addrKeySize]byte]struct{})
idx.addrsByTx[*tx.Hash()] = addrsByTxEntry
idx.addrsByTx[*tx.ID()] = addrsByTxEntry
}
addrsByTxEntry[addrKey] = struct{}{}
idx.unconfirmedLock.Unlock()

6
blockdag/indexers/cfindex.go
View File

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

40
blockdag/merkle.go
View File

@ -11,6 +11,14 @@ import (
"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
// it is not already a power of two. This is a helper function used during the
// calculation of a merkle tree.
@ -38,7 +46,27 @@ func HashMerkleBranches(left *daghash.Hash, right *daghash.Hash) *daghash.Hash {
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
// 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
@ -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.
// Since this function uses nodes that are pointers to the hashes, empty nodes
// 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
// tree as a linear array and create an array of that size.
nextPoT := nextPowerOfTwo(len(transactions))
nextPoT := nextPowerOfTwo(len(hashes))
arraySize := nextPoT*2 - 1
merkles := make([]*daghash.Hash, arraySize)
merkles := make(MerkleTree, arraySize)
// Create the base transaction hashes and populate the array with them.
for i, tx := range transactions {
merkles[i] = tx.Hash()
for i, hash := range hashes {
merkles[i] = hash
}
// 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"
)
// TestMerkle tests the BuildMerkleTreeStore API.
// TestMerkle tests the BuildHashMerkleTreeStore API.
func TestMerkle(t *testing.T) {
block := util.NewBlock(&Block100000)
merkles := BuildMerkleTreeStore(block.Transactions())
calculatedMerkleRoot := merkles[len(merkles)-1]
wantMerkle := &Block100000.Header.MerkleRoot
if !wantMerkle.IsEqual(calculatedMerkleRoot) {
t.Errorf("BuildMerkleTreeStore: merkle root mismatch - "+
"got %v, want %v", calculatedMerkleRoot, wantMerkle)
hashMerkleTree := BuildHashMerkleTreeStore(block.Transactions())
calculatedHashMerkleRoot := hashMerkleTree.Root()
wantHashMerkleRoot := &Block100000.Header.HashMerkleRoot
if !wantHashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
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 "+
"output %v referenced from "+
"transaction %s:%d",
txIn.PreviousOutPoint, txVI.tx.Hash(),
txIn.PreviousOutPoint, txVI.tx.ID(),
txVI.txInIndex)
err := ruleError(ErrMissingTxOut, str)
v.sendResult(err)
@ -77,7 +77,7 @@ out:
"%s:%d which references output %v - "+
"%v (input script bytes %x, prev "+
"output script bytes %x)",
txVI.tx.Hash(), txVI.txInIndex,
txVI.tx.ID(), txVI.txInIndex,
txIn.PreviousOutPoint, err, sigScript, pkScript)
err := ruleError(ErrScriptMalformed, str)
v.sendResult(err)
@ -90,7 +90,7 @@ out:
"%s:%d which references output %v - "+
"%v (input script bytes %x, prev output "+
"script bytes %x)",
txVI.tx.Hash(), txVI.txInIndex,
txVI.tx.ID(), txVI.txInIndex,
txIn.PreviousOutPoint, err, sigScript, pkScript)
err := ruleError(ErrScriptValidation, str)
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
// known-good block doesn't return an error.
func TestCheckBlockScripts(t *testing.T) {
t.Skip() // TODO: Reactivate this test once we have blocks from testnet.
runtime.GOMAXPROCS(runtime.NumCPU())
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
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++
}
@ -304,7 +304,7 @@ func (d *UTXODiff) clone() *UTXODiff {
//RemoveTxOuts marks the transaction's outputs to removal
func (d *UTXODiff) RemoveTxOuts(tx *wire.MsgTx) {
for idx := range tx.TxOut {
hash := tx.TxHash()
hash := tx.TxID()
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
func diffFromTx(u UTXOSet, tx *wire.MsgTx, containingNode *blockNode) (*UTXODiff, error) {
diff := NewUTXODiff()
isCoinbase := IsCoinBaseTx(tx)
isCoinbase := tx.IsCoinBase()
if !isCoinbase {
for _, txIn := range tx.TxIn {
if entry, ok := u.Get(txIn.PreviousOutPoint); ok {
@ -369,12 +369,12 @@ func diffFromTx(u UTXOSet, tx *wire.MsgTx, containingNode *blockNode) (*UTXODiff
} else {
return nil, ruleError(ErrMissingTxOut, fmt.Sprintf(
"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 {
hash := tx.TxHash()
hash := tx.TxID()
entry := NewUTXOEntry(txOut, isCoinbase, containingNode.height)
outPoint := *wire.NewOutPoint(&hash, uint32(i))
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
func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool {
isCoinbase := IsCoinBaseTx(tx)
isCoinbase := tx.IsCoinBase()
if !isCoinbase {
if !fus.containsInputs(tx) {
return false
}
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)
}
}
for i, txOut := range tx.TxOut {
hash := tx.TxHash()
hash := tx.TxID()
outPoint := *wire.NewOutPoint(&hash, uint32(i))
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 {
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) {
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
func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockHeight int32) bool {
isCoinBase := IsCoinBaseTx(tx)
isCoinBase := tx.IsCoinBase()
if !isCoinBase && !dus.containsInputs(tx) {
return false
}
@ -522,7 +522,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockHeight int32, isCoinBase b
if !isCoinBase {
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) {
dus.UTXODiff.toAdd.remove(outPoint)
} else {
@ -533,7 +533,7 @@ func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockHeight int32, isCoinBase b
}
for i, txOut := range tx.TxOut {
hash := tx.TxHash()
hash := tx.TxID()
outPoint := *wire.NewOutPoint(&hash, uint32(i))
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 {
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)
isInDiffToAdd := dus.UTXODiff.toAdd.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
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.TxIn = []*wire.TxIn{txIn0}
transaction0.TxOut = []*wire.TxOut{txOut0}
@ -635,7 +635,7 @@ func TestUTXOSetDiffRules(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
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}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
transaction0 := wire.NewMsgTx(1)
@ -643,9 +643,9 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction0.TxOut = []*wire.TxOut{txOut0}
// transaction1 spends transaction0
hash1 := transaction0.TxHash()
outPoint1 := *wire.NewOutPoint(&hash1, 0)
txIn1 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: hash1, Index: 0}, Sequence: 0}
id1 := transaction0.TxID()
outPoint1 := *wire.NewOutPoint(&id1, 0)
txIn1 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: id1, Index: 0}, Sequence: 0}
txOut1 := &wire.TxOut{PkScript: []byte{1}, Value: 20}
utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
transaction1 := wire.NewMsgTx(1)
@ -653,9 +653,9 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction1.TxOut = []*wire.TxOut{txOut1}
// transaction2 spends transaction1
hash2 := transaction1.TxHash()
outPoint2 := *wire.NewOutPoint(&hash2, 0)
txIn2 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{Hash: hash2, Index: 0}, Sequence: 0}
id2 := transaction1.TxID()
outPoint2 := *wire.NewOutPoint(&id2, 0)
txIn2 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: id2, Index: 0}, Sequence: 0}
txOut2 := &wire.TxOut{PkScript: []byte{2}, Value: 30}
utxoEntry2 := NewUTXOEntry(txOut2, false, 2)
transaction2 := wire.NewMsgTx(1)
@ -663,8 +663,8 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
transaction2.TxOut = []*wire.TxOut{txOut2}
// outpoint3 is the outpoint for transaction2
hash3 := transaction2.TxHash()
outPoint3 := *wire.NewOutPoint(&hash3, 0)
id3 := transaction2.TxID()
outPoint3 := *wire.NewOutPoint(&id3, 0)
// 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
@ -822,7 +822,7 @@ func TestApplyUTXOChanges(t *testing.T) {
chainedTx := wire.NewMsgTx(wire.TxVersion)
chainedTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{Hash: cbTx.TxHash(), Index: 0},
PreviousOutPoint: wire.OutPoint{TxID: cbTx.TxID(), Index: 0},
SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum,
})
@ -832,7 +832,7 @@ func TestApplyUTXOChanges(t *testing.T) {
})
//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{
Header: *blockHeader,
@ -852,7 +852,7 @@ func TestApplyUTXOChanges(t *testing.T) {
nonChainedTx := wire.NewMsgTx(wire.TxVersion)
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
Sequence: wire.MaxTxInSequenceNum,
})
@ -888,7 +888,7 @@ func TestDiffFromTx(t *testing.T) {
}
fus.AddTx(cbTx, 1)
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.AddTxIn(&wire.TxIn{
PreviousOutPoint: cbOutpoint,
@ -904,13 +904,13 @@ func TestDiffFromTx(t *testing.T) {
t.Errorf("diffFromTx: %v", err)
}
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")
}
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")
}
@ -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
invalidTx := wire.NewMsgTx(wire.TxVersion)
invalidTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0},
PreviousOutPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum,
})

73
blockdag/validate.go
View File

@ -59,36 +59,12 @@ var (
// isNullOutpoint determines whether or not a previous transaction output point
// is set.
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 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
// 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
@ -98,7 +74,7 @@ func IsCoinBaseTx(msgTx *wire.MsgTx) bool {
// This function only differs from IsCoinBaseTx in that it works with a higher
// level util transaction as opposed to a raw wire transaction.
func IsCoinBase(tx *util.Tx) bool {
return IsCoinBaseTx(tx.MsgTx())
return tx.MsgTx().IsCoinBase()
}
// 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 "+
"transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex)
tx.ID(), txInIndex)
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
// after the following checks, but there is no reason not to check the
// merkle root matches here.
merkles := BuildMerkleTreeStore(block.Transactions())
calculatedMerkleRoot := merkles[len(merkles)-1]
if !header.MerkleRoot.IsEqual(calculatedMerkleRoot) {
str := fmt.Sprintf("block merkle root is invalid - block "+
hashMerkleTree := BuildHashMerkleTreeStore(block.Transactions())
calculatedHashMerkleRoot := hashMerkleTree.Root()
if !header.HashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
str := fmt.Sprintf("block hash merkle root is invalid - block "+
"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)
}
// 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.
existingTxHashes := make(map[daghash.Hash]struct{})
existingTxIDs := make(map[daghash.Hash]struct{})
for _, tx := range transactions {
hash := tx.Hash()
if _, exists := existingTxHashes[*hash]; exists {
id := tx.ID()
if _, exists := existingTxIDs[*id]; exists {
str := fmt.Sprintf("block contains duplicate "+
"transaction %v", hash)
"transaction %v", id)
return ruleError(ErrDuplicateTx, str)
}
existingTxHashes[*hash] = struct{}{}
existingTxIDs[*id] = struct{}{}
}
// 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) {
str := fmt.Sprintf("block contains unfinalized "+
"transaction %v", tx.Hash())
"transaction %v", tx.ID())
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.
fetchSet := make(map[wire.OutPoint]struct{})
for _, tx := range transactions {
prevOut := wire.OutPoint{Hash: *tx.Hash()}
prevOut := wire.OutPoint{TxID: *tx.ID()}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
fetchSet[prevOut] = struct{}{}
@ -834,7 +819,7 @@ func ensureNoDuplicateTx(block *blockNode, utxoSet UTXOSet,
if ok {
str := fmt.Sprintf("tried to overwrite transaction %v "+
"at block height %d that is not fully spent",
outpoint.Hash, utxo.BlockHeight())
outpoint.TxID, utxo.BlockHeight())
return ruleError(ErrOverwriteTx, str)
}
}
@ -859,7 +844,7 @@ func CheckTransactionInputs(tx *util.Tx, txHeight int32, utxoSet UTXOSet, dagPar
return 0, nil
}
txHash := tx.Hash()
txID := tx.ID()
var totalSatoshiIn uint64
for txInIndex, txIn := range tx.MsgTx().TxIn {
// 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 "+
"transaction %s:%d either does not exist or "+
"has already been spent", txIn.PreviousOutPoint,
tx.Hash(), txInIndex)
tx.ID(), txInIndex)
return 0, ruleError(ErrMissingTxOut, str)
}
@ -931,7 +916,7 @@ func CheckTransactionInputs(tx *util.Tx, txHeight int32, utxoSet UTXOSet, dagPar
if totalSatoshiIn < totalSatoshiOut {
str := fmt.Sprintf("total value of all transaction inputs for "+
"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)
}

125
blockdag/validate_test.go
View File

@ -186,30 +186,36 @@ func TestCheckBlockSanity(t *testing.T) {
var invalidParentsOrderBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
Version: 0x10000000,
ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy.
0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
0x2a, 0x04, 0x71, 0xbc, 0xf8, 0x30, 0x95, 0x52,
0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00,
}, // SimNet genesis
},
[32]byte{ // Make go vet happy.
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
0x46, 0x11, 0x89, 0x6b, 0x82, 0x1a, 0x68, 0x3b,
0x7a, 0x4e, 0xde, 0xfe, 0x2c, 0x00, 0x00, 0x00,
}, // MainNet genesis
},
},
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xc0, 0x92, 0x53, 0x8f, 0x6f, 0xf7, 0xf5, 0x24,
0xd5, 0x33, 0xd4, 0x8b, 0xf3, 0xc0, 0xf8, 0xf9,
0x6f, 0xff, 0xfb, 0xb7, 0xdc, 0x39, 0x9d, 0x76,
0x8d, 0xb0, 0xe1, 0x9c, 0x2e, 0x6d, 0x22, 0xd9,
}), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
Timestamp: time.Unix(0x5bbe0435, 0),
HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x2f, 0x4c, 0xc3, 0x0b, 0x0a, 0x84, 0xbb, 0x95,
0x56, 0x9d, 0x77, 0xa2, 0xee, 0x3e, 0xb1, 0xac,
0x48, 0x3e, 0x8b, 0xe1, 0xcf, 0xdc, 0x20, 0xba,
0xae, 0xec, 0x0a, 0x2f, 0xe4, 0x85, 0x31, 0x30,
}),
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,
Nonce: 0x9ffffffffffffffb,
Nonce: 0x4000000000000001,
},
Transactions: []*wire.MsgTx{
{
@ -217,11 +223,13 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
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,
},
@ -230,28 +238,19 @@ func TestCheckBlockSanity(t *testing.T) {
{
Value: 0x12a05f200, // 5000000000
PkScript: []byte{
0x41, // OP_DATA_65
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
0x51,
},
},
},
LockTime: 0,
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
},
{
Version: 1,
TxIn: []*wire.TxIn{
{
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,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
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,
TxIn: []*wire.TxIn{
{
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,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
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,
TxIn: []*wire.TxIn{
{
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,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
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.
var Block100000 = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
Version: 0x10000000,
ParentHashes: []daghash.Hash{
[32]byte{ // Make go vet happy.
0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
@ -641,15 +643,21 @@ var Block100000 = wire.MsgBlock{
0x6a, 0xce, 0x0e, 0x38, 0xc6, 0x00, 0x00, 0x00,
},
},
MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0xe8, 0x09, 0xa1, 0x6c, 0xf2, 0xfb, 0xb1, 0x2d,
0xff, 0xff, 0x7d, 0x0f, 0x5b, 0xdc, 0xaa, 0xfd,
0xf1, 0xe4, 0x92, 0x23, 0x1b, 0x8c, 0xbf, 0x6a,
0x28, 0x52, 0x10, 0x9f, 0x93, 0x96, 0x1f, 0x25,
HashMerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
0x62, 0x0c, 0x88, 0xd3, 0xcb, 0x15, 0xc7, 0x8a,
0xe9, 0x62, 0x68, 0x4d, 0xc4, 0x2c, 0xe2, 0x14,
0xc2, 0x3c, 0x56, 0xf7, 0xc1, 0x65, 0xce, 0x07,
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,
Nonce: 1,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{
{
@ -657,11 +665,13 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
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,
},
@ -670,28 +680,19 @@ var Block100000 = wire.MsgBlock{
{
Value: 0x12a05f200, // 5000000000
PkScript: []byte{
0x41, // OP_DATA_65
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
0x51,
},
},
},
LockTime: 0,
LockTime: 0,
SubnetworkID: wire.SubnetworkIDNative,
},
{
Version: 1,
TxIn: []*wire.TxIn{
{
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,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -761,7 +762,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -830,7 +831,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
@ -903,7 +904,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
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,
0x2f, 0x01, 0xd4, 0x83, 0x9b, 0x2a, 0x04, 0x5e,
0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3,
@ -919,7 +920,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
@ -953,7 +954,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -1023,7 +1024,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -1092,7 +1093,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
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
// version bits scheme is being used.
vbTopBits = 0x20000000
vbTopBits = 0x10000000
// vbTopMask is the bitmask to use to determine whether or not the
// version bits scheme is in use.

2
btcjson/dagsvrresults.go
View File

@ -116,7 +116,7 @@ type GetBlockDAGInfoResult struct {
// getblocktemplate command.
type GetBlockTemplateResultTx struct {
Data string `json:"data"`
Hash string `json:"hash"`
ID string `json:"id"`
Depends []int64 `json:"depends"`
Fee uint64 `json:"fee"`
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)
}
// Sort sorts a slice of hashes
func Sort(hashes []Hash) {
sort.Slice(hashes, func(i, j int) bool {
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{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, 0x45, /* |.......E| */
0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6d, 0x65, /* |The Time| */
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| */
0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
},
Sequence: math.MaxUint64,
},
@ -41,15 +33,7 @@ var genesisCoinbaseTx = wire.MsgTx{
{
Value: 0x12a05f200,
PkScript: []byte{
0x41, 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, /* |A.g....U| */
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, /* |._.| */
0x51,
},
},
},
@ -60,43 +44,39 @@ var genesisCoinbaseTx = wire.MsgTx{
// genesisHash is the hash of the first block in the block chain for the main
// network (genesis block).
var genesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
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,
0x53, 0xb8, 0xf9, 0x4b, 0xec, 0x3f, 0xae, 0x0a,
0x7c, 0x79, 0x7a, 0x8c, 0x87, 0xfb, 0x4c, 0x37,
0xff, 0x68, 0xed, 0xdb, 0x4a, 0x96, 0xd6, 0xbd,
0x36, 0xf0, 0x28, 0x93, 0xe7, 0x09, 0xc3, 0xcc,
})
// genesisMerkleRoot is the hash of the first transaction in the genesis block
// for the main network.
var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
0x5a, 0x7c, 0x26, 0x54, 0x0d, 0x46, 0x6b, 0x5f,
0x4a, 0x2c, 0x29, 0xff, 0x2f, 0xa5, 0xa0, 0xad,
0x9c, 0xd2, 0x4f, 0x6e, 0xa9, 0x16, 0xfa, 0xb5,
0x52, 0x5e, 0x40, 0xa2, 0x69, 0xb6, 0x8d, 0x5c,
0x76, 0x2b, 0x33, 0xa9, 0x4c, 0xd4, 0x36, 0x13,
0x29, 0x5e, 0x9b, 0x68, 0xb7, 0xad, 0x2b, 0x16,
0x7c, 0x63, 0x89, 0xc3, 0x54, 0xc9, 0xa7, 0x06,
0x8c, 0x23, 0x24, 0x3c, 0x53, 0x6d, 0x56, 0x23,
})
// genesisBlock defines the genesis block of the block chain which serves as the
// public transaction ledger for the main network.
var genesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
Version: 1,
ParentHashes: []daghash.Hash{},
HashMerkleRoot: genesisMerkleRoot,
IDMerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c3cafec, 0),
Bits: 0x207fffff,
Nonce: 0xbffffffffffffffa,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
// regTestGenesisHash is the hash of the first block in the block chain for the
// regression test network (genesis block).
var regTestGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
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,
})
var regTestGenesisHash = genesisHash
// 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
@ -105,26 +85,11 @@ var regTestGenesisMerkleRoot = genesisMerkleRoot
// regTestGenesisBlock defines the genesis block of the block chain which serves
// as the public transaction ledger for the regression test network.
var regTestGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
var regTestGenesisBlock = genesisBlock
// testNet3GenesisHash is the hash of the first block in the block chain for the
// test network (version 3).
var testNet3GenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
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,
})
var testNet3GenesisHash = genesisHash
// 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
@ -133,26 +98,11 @@ var testNet3GenesisMerkleRoot = genesisMerkleRoot
// testNet3GenesisBlock defines the genesis block of the block chain which
// serves as the public transaction ledger for the test network (version 3).
var testNet3GenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
var testNet3GenesisBlock = genesisBlock
// simNetGenesisHash is the hash of the first block in the block chain for the
// simulation test network.
var simNetGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
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,
})
var simNetGenesisHash = genesisHash
// 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
@ -161,14 +111,4 @@ var simNetGenesisMerkleRoot = genesisMerkleRoot
// simNetGenesisBlock defines the genesis block of the block chain which serves
// as the public transaction ledger for the simulation test network.
var simNetGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5c34b3ba, 0),
Bits: 0x207fffff,
Nonce: 0xdffffffffffffff9,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
var simNetGenesisBlock = genesisBlock

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
// main network as of protocol version 60002.
var genesisBlockBytes = []byte{
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, /* |..| */
0x01, 0x00, 0x00, 0x00, 0x00, 0x76, 0x2b, 0x33,
0xa9, 0x4c, 0xd4, 0x36, 0x13, 0x29, 0x5e, 0x9b,
0x68, 0xb7, 0xad, 0x2b, 0x16, 0x7c, 0x63, 0x89,
0xc3, 0x54, 0xc9, 0xa7, 0x06, 0x8c, 0x23, 0x24,
0x3c, 0x53, 0x6d, 0x56, 0x23, 0x76, 0x2b, 0x33,
0xa9, 0x4c, 0xd4, 0x36, 0x13, 0x29, 0x5e, 0x9b,
0x68, 0xb7, 0xad, 0x2b, 0x16, 0x7c, 0x63, 0x89,
0xc3, 0x54, 0xc9, 0xa7, 0x06, 0x8c, 0x23, 0x24,
0x3c, 0x53, 0x6d, 0x56, 0x23, 0xec, 0xaf, 0x3c,
0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
0x20, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xbf, 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, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01,
0x00, 0x00, 0x00, 0x01, 0x51, 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,
}
// regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of
// the regression test network as of protocol version 60002.
var regTestGenesisBlockBytes = []byte{
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, /* |..| */
}
var regTestGenesisBlockBytes = genesisBlockBytes
// testNet3GenesisBlockBytes are the wire encoded bytes for the genesis block of
// the test network (version 3) as of protocol version 60002.
var testNet3GenesisBlockBytes = []byte{
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, /* |..| */
}
var testNet3GenesisBlockBytes = genesisBlockBytes
// simNetGenesisBlockBytes are the wire encoded bytes for the genesis block of
// the simulation test network as of protocol version 70002.
var simNetGenesisBlockBytes = []byte{
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, /* |..| */
}
var simNetGenesisBlockBytes = genesisBlockBytes

2
dagconfig/params.go
View File

@ -224,7 +224,7 @@ var MainNetParams = Params{
{"seed.bitcoin.jonasschnelli.ch", true},
},
// Chain parameters
// DAG parameters
GenesisBlock: &genesisBlock,
GenesisHash: &genesisHash,
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))
// 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) {
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 {
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.
func TestHandleRollbackErrors(t *testing.T) {
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())
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().
// The non-error-cases are tested in the more general tests.
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 {
name string
@ -716,7 +716,7 @@ func TestWritePendingAndCommitErrors(t *testing.T) {
rollbackCalled = false
err = pdb.Update(func(dbTx database.Tx) error {
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 {
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 {
return &wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{parent.BlockHash()},
MerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC
Bits: 0x2e00ffff, // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
Nonce: 0xc0192550, // 2148484547
Version: 1,
ParentHashes: []daghash.Hash{parent.BlockHash()},
HashMerkleRoot: genesisMerkleRoot,
Timestamp: time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC
Bits: 0x2e00ffff, // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
Nonce: 0xc0192550, // 2148484547
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
@ -108,7 +108,7 @@ var genesisCoinbaseTx = wire.MsgTx{
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{

8
integration/csv_test.go
View File

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

14
integration/rpctest/blockgen.go
View File

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

9
integration/rpctest/memwallet.go
View File

@ -10,7 +10,6 @@ import (
"fmt"
"sync"
"github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/btcec"
"github.com/daglabs/btcd/dagconfig"
"github.com/daglabs/btcd/dagconfig/daghash"
@ -207,9 +206,9 @@ func (m *memWallet) ingestBlock(update *chainUpdate) {
}
for _, tx := range update.filteredTxns {
mtx := tx.MsgTx()
isCoinbase := blockdag.IsCoinBaseTx(mtx)
txHash := mtx.TxHash()
m.evalOutputs(mtx.TxOut, &txHash, isCoinbase, undo)
isCoinbase := mtx.IsCoinBase()
txID := mtx.TxID()
m.evalOutputs(mtx.TxOut, &txID, isCoinbase, 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)
}
op := wire.OutPoint{Hash: *txHash, Index: uint32(i)}
op := wire.OutPoint{TxID: *txHash, Index: uint32(i)}
m.utxos[op] = &utxo{
value: util.Amount(output.Value),
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]
txHash := minedTx.TxHash()
if txHash != *txid {
t.Fatalf("txid's don't match, %v vs %v", txHash, txid)
minedTxID := minedTx.TxID()
if minedTxID != *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
}
hash := *t.Tx.Hash()
hash := *t.Tx.ID()
if _, ok := ef.observed[hash]; !ok {
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)
for _, h := range txHistory {
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
}
}

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).
func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
// Nothing to do if passed tx is not an orphan.
txHash := tx.Hash()
otx, exists := mp.orphans[*txHash]
txID := tx.ID()
otx, exists := mp.orphans[*txID]
if !exists {
return
}
@ -202,7 +202,7 @@ func (mp *TxPool) removeOrphan(tx *util.Tx, removeRedeemers bool) {
for _, txIn := range otx.tx.MsgTx().TxIn {
orphans, exists := mp.orphansByPrev[txIn.PreviousOutPoint]
if exists {
delete(orphans, *txHash)
delete(orphans, *txID)
// Remove the map entry altogether if there are no
// 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.
if removeRedeemers {
prevOut := wire.OutPoint{Hash: *txHash}
prevOut := wire.OutPoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
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.
delete(mp.orphans, *txHash)
delete(mp.orphans, *txID)
}
// 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.
mp.limitNumOrphans()
mp.orphans[*tx.Hash()] = &orphanTx{
mp.orphans[*tx.ID()] = &orphanTx{
tx: tx,
tag: tag,
expiration: time.Now().Add(orphanTTL),
@ -331,10 +331,10 @@ func (mp *TxPool) addOrphan(tx *util.Tx, tag Tag) {
mp.orphansByPrev[txIn.PreviousOutPoint] =
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))
}
@ -458,11 +458,11 @@ func (mp *TxPool) HaveTransaction(hash *daghash.Hash) bool {
//
// This function MUST be called with the mempool lock held (for writes).
func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreInputs bool) error {
txHash := tx.Hash()
txID := tx.ID()
if removeRedeemers {
// Remove any transactions which rely on this one.
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 {
mp.removeTransaction(txRedeemer, true, false)
}
@ -470,11 +470,11 @@ func (mp *TxPool) removeTransaction(tx *util.Tx, removeRedeemers bool, restoreIn
}
// 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
// transaction if enabled.
if mp.cfg.AddrIndex != nil {
mp.cfg.AddrIndex.RemoveUnconfirmedTx(txHash)
mp.cfg.AddrIndex.RemoveUnconfirmedTx(txID)
}
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.
for _, txIn := range txDesc.Tx.MsgTx().TxIn {
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]
entry := blockdag.NewUTXOEntry(prevOut, false, mining.UnminedHeight)
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.pool, *txHash)
delete(mp.pool, *txID)
var err error
mp.mpUTXOSet, err = mp.mpUTXOSet.WithDiff(diff)
if err != nil {
@ -527,7 +527,7 @@ func (mp *TxPool) RemoveDoubleSpends(tx *util.Tx) {
mp.mtx.Lock()
for _, txIn := range tx.MsgTx().TxIn {
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)
}
}
@ -556,7 +556,7 @@ func (mp *TxPool) addTransaction(tx *util.Tx, height int32, fee uint64) *TxDesc
StartingPriority: mining.CalcPriority(tx.MsgTx(), mp.mpUTXOSet, height),
}
mp.pool[*tx.Hash()] = txD
mp.pool[*tx.ID()] = txD
for _, txIn := range tx.MsgTx().TxIn {
mp.outpoints[txIn.PreviousOutPoint] = tx
}
@ -612,10 +612,10 @@ func (mp *TxPool) CheckSpend(op wire.OutPoint) *util.Tx {
// orphans.
//
// 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.
mp.mtx.RLock()
txDesc, exists := mp.pool[*txHash]
txDesc, exists := mp.pool[*txID]
mp.mtx.RUnlock()
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) {
mp.cfg.DAG.UTXORLock()
defer mp.cfg.DAG.UTXORUnlock()
txHash := tx.Hash()
txID := tx.ID()
// Don't accept the transaction if it already exists in the pool. This
// applies to orphan transactions as well when the reject duplicate
// orphans flag is set. This check is intended to be a quick check to
// weed out duplicates.
if mp.isTransactionInPool(txHash) || (rejectDupOrphans &&
mp.isOrphanInPool(txHash)) {
if mp.isTransactionInPool(txID) || (rejectDupOrphans &&
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)
}
@ -685,7 +685,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// A standalone transaction must not be a coinbase transaction.
if blockdag.IsCoinBase(tx) {
str := fmt.Sprintf("transaction %v is an individual coinbase",
txHash)
txID)
return nil, nil, txRuleError(wire.RejectInvalid, str)
}
@ -711,7 +711,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
rejectCode = wire.RejectNonstandard
}
str := fmt.Sprintf("transaction %v is not standard: %v",
txHash, err)
txID, err)
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
// not already fully spent.
prevOut := wire.OutPoint{Hash: *txHash}
prevOut := wire.OutPoint{TxID: *txID}
for txOutIdx := range tx.MsgTx().TxOut {
prevOut.Index = uint32(txOutIdx)
_, 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
// result in all of the entries pointing to the same
// memory location and thus all be the final hash.
hashCopy := txIn.PreviousOutPoint.Hash
hashCopy := txIn.PreviousOutPoint.TxID
missingParents = append(missingParents, &hashCopy)
}
}
@ -802,7 +802,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
rejectCode = wire.RejectNonstandard
}
str := fmt.Sprintf("transaction %v has a non-standard "+
"input: %v", txHash, err)
"input: %v", txID, err)
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 {
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)
}
@ -845,7 +845,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
mp.cfg.Policy.MinRelayTxFee))
if serializedSize >= (DefaultBlockPrioritySize-1000) && txFee < minFee {
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)
return nil, nil, txRuleError(wire.RejectInsufficientFee, str)
}
@ -859,7 +859,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
nextBlockHeight)
if currentPriority <= mining.MinHighPriority {
str := fmt.Sprintf("transaction %v has insufficient "+
"priority (%g <= %g)", txHash,
"priority (%g <= %g)", txID,
currentPriority, mining.MinHighPriority)
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?
if mp.pennyTotal >= mp.cfg.Policy.FreeTxRelayLimit*10*1000 {
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)
}
oldTotal := mp.pennyTotal
@ -903,7 +903,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// Add to transaction pool.
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))
return nil, txD, nil
@ -944,7 +944,7 @@ func (mp *TxPool) processOrphans(acceptedTx *util.Tx) []*TxDesc {
firstElement := processList.Remove(processList.Front())
processItem := firstElement.(*util.Tx)
prevOut := wire.OutPoint{Hash: *processItem.Hash()}
prevOut := wire.OutPoint{TxID: *processItem.ID()}
for txOutIdx := range processItem.MsgTx().TxOut {
// Look up all orphans that redeem the output that is
// 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.
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.
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.
str := fmt.Sprintf("orphan transaction %v references "+
"outputs of unknown or fully-spent "+
"transaction %v", tx.Hash(), missingParents[0])
"transaction %v", tx.ID(), missingParents[0])
return nil, txRuleError(wire.RejectDuplicate, str)
}
@ -1106,22 +1106,22 @@ func (mp *TxPool) Count() int {
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.
//
// This function is safe for concurrent access.
func (mp *TxPool) TxHashes() []*daghash.Hash {
func (mp *TxPool) TxIDs() []*daghash.Hash {
mp.mtx.RLock()
hashes := make([]*daghash.Hash, len(mp.pool))
ids := make([]*daghash.Hash, len(mp.pool))
i := 0
for hash := range mp.pool {
hashCopy := hash
hashes[i] = &hashCopy
for txID := range mp.pool {
idCopy := txID
ids[i] = &idCopy
i++
}
mp.mtx.RUnlock()
return hashes
return ids
}
// 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),
}
for _, txIn := range tx.MsgTx().TxIn {
hash := &txIn.PreviousOutPoint.Hash
hash := &txIn.PreviousOutPoint.TxID
if mp.haveTransaction(hash) {
mpd.Depends = append(mpd.Depends,
hash.String())
}
}
result[tx.Hash().String()] = mpd
result[tx.ID().String()] = mpd
}
return result

97
mempool/mempool_test.go
View File

@ -9,7 +9,6 @@ import (
"encoding/hex"
"errors"
"fmt"
"github.com/daglabs/btcd/util/subnetworkid"
"math"
"reflect"
"runtime"
@ -17,6 +16,8 @@ import (
"testing"
"time"
"github.com/daglabs/btcd/util/subnetworkid"
"bou.ke/monkey"
"github.com/daglabs/btcd/blockdag"
"github.com/daglabs/btcd/blockdag/indexers"
@ -91,7 +92,7 @@ type spendableOutpoint struct {
// transactions.
func txOutToSpendableOutpoint(tx *util.Tx, outputNum uint32) 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),
}
}
@ -248,7 +249,7 @@ func (p *poolHarness) CreateTxChain(firstOutput spendableOutpoint, numTxns uint3
txChain = append(txChain, util.NewTx(tx))
// 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
@ -358,22 +359,22 @@ type testContext struct {
// should be reported as available by the HaveTransaction function based upon
// the two flags and tests that condition as well.
func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool bool) {
txHash := tx.Hash()
gotOrphanPool := tc.harness.txPool.IsOrphanInPool(txHash)
txID := tx.ID()
gotOrphanPool := tc.harness.txPool.IsOrphanInPool(txID)
if inOrphanPool != gotOrphanPool {
_, file, line, _ := runtime.Caller(1)
tc.t.Fatalf("%s:%d -- IsOrphanInPool: want %v, got %v", file,
line, inOrphanPool, gotOrphanPool)
}
gotTxPool := tc.harness.txPool.IsTransactionInPool(txHash)
gotTxPool := tc.harness.txPool.IsTransactionInPool(txID)
if inTxPool != gotTxPool {
_, file, line, _ := runtime.Caller(1)
tc.t.Fatalf("%s:%d -- IsTransactionInPool: want %v, got %v",
file, line, inTxPool, gotTxPool)
}
gotHaveTx := tc.harness.txPool.HaveTransaction(txHash)
gotHaveTx := tc.harness.txPool.HaveTransaction(txID)
wantHaveTx := inOrphanPool || inTxPool
if wantHaveTx != gotHaveTx {
_, file, line, _ := runtime.Caller(1)
@ -382,27 +383,27 @@ func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool boo
}
count := tc.harness.txPool.Count()
txHashes := tc.harness.txPool.TxHashes()
txIDs := tc.harness.txPool.TxIDs()
txDescs := tc.harness.txPool.TxDescs()
txMiningDescs := tc.harness.txPool.MiningDescs()
if count != len(txHashes) || count != len(txDescs) || count != len(txMiningDescs) {
tc.t.Error("mempool.TxHashes(), mempool.TxDescs() and mempool.MiningDescs() have different length")
if count != len(txIDs) || count != len(txDescs) || count != len(txMiningDescs) {
tc.t.Error("mempool.TxIDs(), mempool.TxDescs() and mempool.MiningDescs() have different length")
}
if inTxPool {
wasFound := false
for _, txh := range txHashes {
if *txHash == *txh {
for _, txI := range txIDs {
if *txID == *txI {
wasFound = true
break
}
}
if !wasFound {
tc.t.Error("Can not find transaction in mempool.TxHashes")
tc.t.Error("Can not find transaction in mempool.TxIDs")
}
wasFound = false
for _, txd := range txDescs {
if *txHash == *txd.Tx.Hash() {
if *txID == *txd.Tx.ID() {
wasFound = true
break
}
@ -413,7 +414,7 @@ func testPoolMembership(tc *testContext, tx *util.Tx, inOrphanPool, inTxPool boo
wasFound = false
for _, txd := range txMiningDescs {
if *txHash == *txd.Tx.Hash() {
if *txID == *txd.Tx.ID() {
wasFound = true
break
}
@ -476,7 +477,7 @@ func TestProcessTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 1},
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -590,7 +591,7 @@ func TestProcessTransaction(t *testing.T) {
if err != nil {
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)
addrHash := [20]byte{0x01}
@ -618,7 +619,7 @@ func TestProcessTransaction(t *testing.T) {
nonStdSigScriptTx := util.NewTx(&wire.MsgTx{
Version: 1,
TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{Hash: *p2shTx.Hash(), Index: 0},
PreviousOutPoint: wire.OutPoint{TxID: *p2shTx.ID(), Index: 0},
SignatureScript: wrappedP2SHNonStdSigScript,
Sequence: wire.MaxTxInSequenceNum,
}},
@ -640,7 +641,7 @@ func TestProcessTransaction(t *testing.T) {
"transaction input #%d has "+
"%d signature operations which is more "+
"than the allowed max amount of %d",
nonStdSigScriptTx.Hash(), 0, 16, 15)
nonStdSigScriptTx.ID(), 0, 16, 15)
if 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)
}
expectedErrStr = fmt.Sprintf("transaction %v sigop count is too high: %v > %v",
nonStdSigScriptTx.Hash(), 16, 15)
nonStdSigScriptTx.ID(), 16, 15)
if 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{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 1},
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
}
harness.txPool.ProcessTransaction(orphanedTx, true, false, 0)
testPoolMembership(tc, orphanedTx, true, false)
fetchedorphanedTx, err := harness.txPool.FetchTransaction(orphanedTx.Hash())
fetchedorphanedTx, err := harness.txPool.FetchTransaction(orphanedTx.ID())
if fetchedorphanedTx != 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)
testPoolMembership(tc, tx, false, true)
fetchedTx, err := harness.txPool.FetchTransaction(tx.Hash())
fetchedTx, err := harness.txPool.FetchTransaction(tx.ID())
if !reflect.DeepEqual(fetchedTx, tx) {
t.Fatalf("FetchTransaction: returned a transaction, but not the right one")
}
@ -1009,7 +1010,7 @@ func TestOrphanReject(t *testing.T) {
false, 0)
if err == nil {
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{}
if reflect.TypeOf(err) != reflect.TypeOf(expectedErr) {
@ -1052,15 +1053,15 @@ func TestOrphanExpiration(t *testing.T) {
expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0},
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1)
harness.txPool.ProcessTransaction(expiredTx, true,
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{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 0},
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 0},
}}, 1)
harness.txPool.ProcessTransaction(tx1, true,
false, 0)
@ -1075,7 +1076,7 @@ func TestOrphanExpiration(t *testing.T) {
tx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{2}, Index: 0},
outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 0},
}}, 1)
harness.txPool.ProcessTransaction(tx2, true,
false, 0)
@ -1098,7 +1099,7 @@ func TestMaxOrphanTxSize(t *testing.T) {
tx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0},
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1204,7 +1205,7 @@ func TestOrphanEviction(t *testing.T) {
// evicted matches the expected number.
var evictedTxns []*util.Tx
for _, tx := range chainedTxns[1:] {
if !harness.txPool.IsOrphanInPool(tx.Hash()) {
if !harness.txPool.IsOrphanInPool(tx.ID()) {
evictedTxns = append(evictedTxns, tx)
}
}
@ -1233,7 +1234,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{1}, Index: 1},
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1242,7 +1243,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1)
orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{2}, Index: 2},
outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 2},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1251,7 +1252,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1)
orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{3}, Index: 3},
outPoint: wire.OutPoint{TxID: daghash.Hash{3}, Index: 3},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1261,7 +1262,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{4}, Index: 4},
outPoint: wire.OutPoint{TxID: daghash.Hash{4}, Index: 4},
}}, 1)
if err != nil {
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.
nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000),
outPoint: wire.OutPoint{Hash: daghash.Hash{}, Index: 0},
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0},
}}, 1)
if err != nil {
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.
for i := 0; i < len(chainedTxns)-1; i++ {
op = wire.OutPoint{
Hash: *chainedTxns[i].Hash(),
TxID: *chainedTxns[i].ID(),
Index: 0,
}
expSpend := chainedTxns[i+1]
@ -1560,7 +1561,7 @@ func TestCheckSpend(t *testing.T) {
// The last tx should have no spend.
op = wire.OutPoint{
Hash: *chainedTxns[txChainLength-1].Hash(),
TxID: *chainedTxns[txChainLength-1].ID(),
Index: 0,
}
spend = harness.txPool.CheckSpend(op)
@ -1694,10 +1695,10 @@ func TestHandleNewBlock(t *testing.T) {
}
// Create orphan transaction and add it to UTXO set
hash := blockTx1.Hash()
txID := blockTx1.ID()
orphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(2500000000),
outPoint: wire.OutPoint{Hash: *hash, Index: 0},
outPoint: wire.OutPoint{TxID: *txID, Index: 0},
}}, 1)
if err != nil {
t.Fatalf("unable to create signed tx: %v", err)
@ -1720,7 +1721,7 @@ func TestHandleNewBlock(t *testing.T) {
block := util.NewBlock(&dummyBlock)
for i, tx := range block.Transactions() {
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
blockTransnactions := make(map[daghash.Hash]int)
for msg := range ch {
blockTransnactions[*msg.Tx.Hash()] = 1
if *msg.Tx.Hash() != *blockTx1.Hash() {
blockTransnactions[*msg.Tx.ID()] = 1
if *msg.Tx.ID() != *blockTx1.ID() {
if len(msg.AcceptedTxs) != 0 {
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 {
t.Fatalf("Wrong accepted transactions length")
}
if *msg.AcceptedTxs[0].Tx.Hash() != *orphanTx.Hash() {
t.Fatalf("Wrong accepted transaction hash")
if *msg.AcceptedTxs[0].Tx.ID() != *orphanTx.ID() {
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")
}
if _, ok := blockTransnactions[*blockTx1.Hash()]; !ok {
if _, ok := blockTransnactions[*blockTx1.ID()]; !ok {
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")
}
@ -1787,7 +1788,7 @@ var dummyBlock = wire.MsgBlock{
0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03,
0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11,
}}, // 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,
0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
@ -1803,7 +1804,7 @@ var dummyBlock = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{

2
mempool/policy_test.go
View File

@ -283,7 +283,7 @@ func TestCheckTransactionStandard(t *testing.T) {
if err != nil {
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)
dummyTxIn := wire.TxIn{
PreviousOutPoint: dummyPrevOut,

50
mining/mining.go
View File

@ -7,6 +7,7 @@ package mining
import (
"container/heap"
"fmt"
"math/rand"
"sort"
"time"
@ -395,7 +396,9 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
// ensure the transaction is not a duplicate transaction (paying the
// same value to the same public key address would otherwise be an
// 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)
if err != nil {
return nil, err
@ -444,13 +447,13 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
// non-finalized transactions.
tx := txDesc.Tx
if blockdag.IsCoinBase(tx) {
log.Tracef("Skipping coinbase tx %s", tx.Hash())
log.Tracef("Skipping coinbase tx %s", tx.ID())
continue
}
if !blockdag.IsFinalizedTransaction(tx, nextBlockHeight,
g.timeSource.AdjustedTime()) {
log.Tracef("Skipping non-finalized tx %s", tx.Hash())
log.Tracef("Skipping non-finalized tx %s", tx.ID())
continue
}
@ -499,7 +502,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
txGas := tx.MsgTx().Gas
if gasLimit-gasUsage < txGas {
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
}
gasUsageMap[subnetworkID] = gasUsage + txGas
@ -512,7 +515,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
blockPlusTxSize >= g.policy.BlockMaxSize {
log.Tracef("Skipping tx %s because it would exceed "+
"the max block size", tx.Hash())
"the max block size", tx.ID())
continue
}
@ -522,21 +525,21 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
if blockSigOps+numSigOps < blockSigOps ||
blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock {
log.Tracef("Skipping tx %s because it would exceed "+
"the maximum sigops per block", tx.Hash())
"the maximum sigops per block", tx.ID())
continue
}
numP2SHSigOps, err := blockdag.CountP2SHSigOps(tx, false,
blockUtxos)
if err != nil {
log.Tracef("Skipping tx %s due to error in "+
"GetSigOpCost: %v", tx.Hash(), err)
"GetSigOpCost: %v", tx.ID(), err)
continue
}
numSigOps += int64(numP2SHSigOps)
if blockSigOps+numSigOps < blockSigOps ||
blockSigOps+numSigOps > blockdag.MaxSigOpsPerBlock {
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
}
@ -548,7 +551,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
log.Tracef("Skipping tx %s with feePerKB %.2f "+
"< TxMinFreeFee %d and block size %d >= "+
"minBlockSize %d", tx.Hash(), prioItem.feePerKB,
"minBlockSize %d", tx.ID(), prioItem.feePerKB,
g.policy.TxMinFreeFee, blockPlusTxSize,
g.policy.BlockMinSize)
continue
@ -589,14 +592,14 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
blockUtxos, g.chainParams)
if err != nil {
log.Tracef("Skipping tx %s due to error in "+
"CheckTransactionInputs: %v", tx.Hash(), err)
"CheckTransactionInputs: %v", tx.ID(), err)
continue
}
err = blockdag.ValidateTransactionScripts(tx, blockUtxos,
txscript.StandardVerifyFlags, g.sigCache)
if err != nil {
log.Tracef("Skipping tx %s due to error in "+
"ValidateTransactionScripts: %v", tx.Hash(), err)
"ValidateTransactionScripts: %v", tx.ID(), err)
continue
}
@ -617,7 +620,7 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
txSigOpCounts = append(txSigOpCounts, numSigOps)
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
@ -650,14 +653,16 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
})
// Create a new block ready to be solved.
merkles := blockdag.BuildMerkleTreeStore(blockTxns)
hashMerkleTree := blockdag.BuildHashMerkleTreeStore(blockTxns)
idMerkleTree := blockdag.BuildIDMerkleTreeStore(blockTxns)
var msgBlock wire.MsgBlock
msgBlock.Header = wire.BlockHeader{
Version: nextBlockVersion,
ParentHashes: g.dag.TipHashes(),
MerkleRoot: *merkles[len(merkles)-1],
Timestamp: ts,
Bits: reqDifficulty,
Version: nextBlockVersion,
ParentHashes: g.dag.TipHashes(),
HashMerkleRoot: *hashMerkleTree.Root(),
IDMerkleRoot: *idMerkleTree.Root(),
Timestamp: ts,
Bits: reqDifficulty,
}
for _, tx := range blockTxns {
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.
// 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)
merkles := blockdag.BuildMerkleTreeStore(block.Transactions())
msgBlock.Header.MerkleRoot = *merkles[len(merkles)-1]
hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
msgBlock.Header.HashMerkleRoot = *hashMerkleTree.Root()
idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
msgBlock.Header.IDMerkleRoot = *idMerkleTree.Root()
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 {
var prevOut *wire.OutPoint
if originTx != nil {
originTxHash := originTx.TxHash()
prevOut = wire.NewOutPoint(&originTxHash, 0)
originTxID := originTx.TxID()
prevOut = wire.NewOutPoint(&originTxID, 0)
} else {
prevOut = &wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
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
// to disconnect peers for sending unsolicited transactions to provide
// interoperability.
txHash := tmsg.tx.Hash()
txID := tmsg.tx.ID()
// Ignore transactions that we have already rejected. Do not
// send a reject message here because if the transaction was already
// rejected, the transaction was unsolicited.
if _, exists = sm.rejectedTxns[*txHash]; exists {
if _, exists = sm.rejectedTxns[*txID]; exists {
log.Debugf("Ignoring unsolicited previously rejected "+
"transaction %v from %s", txHash, peer)
"transaction %v from %s", txID, peer)
return
}
@ -436,13 +436,13 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// 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
// we'll retry next time we get an inv.
delete(state.requestedTxns, *txHash)
delete(sm.requestedTxns, *txHash)
delete(state.requestedTxns, *txID)
delete(sm.requestedTxns, *txID)
if err != nil {
// Do not request this transaction again until a new block
// has been processed.
sm.rejectedTxns[*txHash] = struct{}{}
sm.rejectedTxns[*txID] = struct{}{}
sm.limitMap(sm.rejectedTxns, maxRejectedTxns)
// 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.
if _, ok := err.(mempool.RuleError); ok {
log.Debugf("Rejected transaction %v from %s: %v",
txHash, peer, err)
txID, peer, err)
} else {
log.Errorf("Failed to process transaction %v: %v",
txHash, err)
txID, err)
}
// Convert the error into an appropriate reject message and
// send it.
code, reason := mempool.ErrToRejectErr(err)
peer.PushRejectMsg(wire.CmdTx, code, reason, txHash, false)
peer.PushRejectMsg(wire.CmdTx, code, reason, txID, false)
return
}
@ -869,7 +869,7 @@ func (sm *SyncManager) haveInventory(invVect *wire.InvVect) (bool, error) {
// checked because the vast majority of transactions consist of
// two outputs where one is some form of "pay-to-somebody-else"
// 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++ {
prevOut.Index = i
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:
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))
case *wire.MsgBlock:

4
peer/peer_test.go
View File

@ -505,7 +505,7 @@ func TestPeerListeners(t *testing.T) {
{
"OnBlock",
wire.NewMsgBlock(wire.NewBlockHeader(1,
[]daghash.Hash{}, &daghash.Hash{}, 1, 1)),
[]daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
},
{
"OnInv",
@ -571,7 +571,7 @@ func TestPeerListeners(t *testing.T) {
{
"OnMerkleBlock",
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 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.
func newOutPointFromWire(op *wire.OutPoint) btcjson.OutPoint {
return btcjson.OutPoint{
Hash: op.Hash.String(),
Hash: op.TxID.String(),
Index: op.Index,
}
}
@ -1171,7 +1171,7 @@ func (c *Client) LoadTxFilterAsync(reload bool, addresses []util.Address,
outPointObjects := make([]btcjson.OutPoint, len(outPoints))
for i := range outPoints {
outPointObjects[i] = btcjson.OutPoint{
Hash: outPoints[i].Hash.String(),
Hash: outPoints[i].TxID.String(),
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))
for i, op := range ops {
outputs[i] = btcjson.TransactionInput{
TxID: op.Hash.String(),
TxID: op.TxID.String(),
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
// one.
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)
if len(invMsg.InvList)+1 > wire.MaxInvPerMsg {
break
@ -495,7 +495,7 @@ func (sp *Peer) OnMemPool(_ *peer.Peer, msg *wire.MsgMemPool) {
func (sp *Peer) OnTx(_ *peer.Peer, msg *wire.MsgTx) {
if config.MainConfig().BlocksOnly {
peerLog.Tracef("Ignoring tx %v from %v - blocksonly enabled",
msg.TxHash(), sp)
msg.TxID(), sp)
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
// methods and things such as hash caching.
tx := util.NewTx(msg)
iv := wire.NewInvVect(wire.InvTypeTx, tx.Hash())
iv := wire.NewInvVect(wire.InvTypeTx, tx.ID())
sp.AddKnownInventory(iv)
// 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.
func (s *Server) RelayTransactions(txns []*mempool.TxDesc) {
for _, txD := range txns {
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.Hash())
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.ID())
s.RelayInventory(iv, txD)
}
}
@ -2852,6 +2852,6 @@ func (s *Server) TransactionConfirmed(tx *util.Tx) {
return
}
iv := wire.NewInvVect(wire.InvTypeTx, tx.Hash())
iv := wire.NewInvVect(wire.InvTypeTx, tx.ID())
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 {
// Coinbase transactions only have a single txin by definition.
vinList := make([]btcjson.Vin, len(mtx.TxIn))
if blockdag.IsCoinBaseTx(mtx) {
if mtx.IsCoinBase() {
txIn := mtx.TxIn[0]
vinList[0].Coinbase = hex.EncodeToString(txIn.SignatureScript)
vinList[0].Sequence = txIn.Sequence
@ -673,7 +673,7 @@ func createVinList(mtx *wire.MsgTx) []btcjson.Vin {
disbuf, _ := txscript.DisasmString(txIn.SignatureScript)
vinEntry := &vinList[i]
vinEntry.TxID = txIn.PreviousOutPoint.Hash.String()
vinEntry.TxID = txIn.PreviousOutPoint.TxID.String()
vinEntry.Vout = txIn.PreviousOutPoint.Index
vinEntry.Sequence = txIn.Sequence
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
// to a raw transaction JSON object.
func createTxRawResult(chainParams *dagconfig.Params, mtx *wire.MsgTx,
txHash string, blkHeader *wire.BlockHeader, blkHash string,
func createTxRawResult(dagParams *dagconfig.Params, mtx *wire.MsgTx,
txID string, blkHeader *wire.BlockHeader, blkHash string,
blkHeight int32, chainHeight int32, acceptedBy *daghash.Hash) (*btcjson.TxRawResult, error) {
mtxHex, err := messageToHex(mtx)
@ -750,11 +750,11 @@ func createTxRawResult(chainParams *dagconfig.Params, mtx *wire.MsgTx,
txReply := &btcjson.TxRawResult{
Hex: mtxHex,
TxID: txHash,
TxID: txID,
Hash: mtx.TxHash().String(),
Size: int32(mtx.SerializeSize()),
Vin: createVinList(mtx),
Vout: createVoutList(mtx, chainParams, nil),
Vout: createVoutList(mtx, dagParams, nil),
Version: mtx.Version,
LockTime: mtx.LockTime,
}
@ -798,7 +798,7 @@ func handleDecodeRawTransaction(s *Server, cmd interface{}, closeChan <-chan str
// Create and return the result.
txReply := btcjson.TxRawDecodeResult{
TxID: mtx.TxHash().String(),
TxID: mtx.TxID().String(),
Version: mtx.Version,
Locktime: mtx.LockTime,
Vin: createVinList(&mtx),
@ -1147,7 +1147,7 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
Hash: c.Hash,
Version: blockHeader.Version,
VersionHex: fmt.Sprintf("%08x", blockHeader.Version),
MerkleRoot: blockHeader.MerkleRoot.String(),
MerkleRoot: blockHeader.HashMerkleRoot.String(),
ParentHashes: daghash.Strings(blockHeader.ParentHashes),
Nonce: blockHeader.Nonce,
Time: blockHeader.Timestamp.Unix(),
@ -1163,7 +1163,7 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
transactions := blk.Transactions()
txNames := make([]string, len(transactions))
for i, tx := range transactions {
txNames[i] = tx.Hash().String()
txNames[i] = tx.ID().String()
}
blockReply.Tx = txNames
@ -1173,13 +1173,13 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
for i, tx := range txns {
var acceptedBy *daghash.Hash
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 {
return nil, err
}
}
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
if err != nil {
return nil, err
@ -1348,7 +1348,7 @@ func handleGetBlockHeader(s *Server, cmd interface{}, closeChan <-chan struct{})
Height: blockHeight,
Version: blockHeader.Version,
VersionHex: fmt.Sprintf("%08x", blockHeader.Version),
MerkleRoot: blockHeader.MerkleRoot.String(),
MerkleRoot: blockHeader.HashMerkleRoot.String(),
NextHashes: nextHashStrings,
ParentHashes: daghash.Strings(blockHeader.ParentHashes),
Nonce: uint64(blockHeader.Nonce),
@ -1590,7 +1590,7 @@ func (state *gbtWorkState) updateBlockTemplate(s *Server, useCoinbaseValue bool)
log.Debugf("Generated block template (timestamp %v, "+
"target %s, merkle root %s)",
msgBlock.Header.Timestamp, targetDifficulty,
msgBlock.Header.MerkleRoot)
msgBlock.Header.HashMerkleRoot)
// Notify any clients that are long polling about the new
// template.
@ -1624,8 +1624,10 @@ func (state *gbtWorkState) updateBlockTemplate(s *Server, useCoinbaseValue bool)
// Update the merkle root.
block := util.NewBlock(template.Block)
merkles := blockdag.BuildMerkleTreeStore(block.Transactions())
template.Block.Header.MerkleRoot = *merkles[len(merkles)-1]
hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
template.Block.Header.HashMerkleRoot = *hashMerkleTree.Root()
idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
template.Block.Header.IDMerkleRoot = *idMerkleTree.Root()
}
// Set locals for convenience.
@ -1679,8 +1681,8 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
transactions := make([]btcjson.GetBlockTemplateResultTx, 0, numTx-1)
txIndex := make(map[daghash.Hash]int64, numTx)
for i, tx := range msgBlock.Transactions {
txHash := tx.TxHash()
txIndex[txHash] = int64(i)
txID := tx.TxID()
txIndex[txID] = int64(i)
// Skip the coinbase transaction.
if i == 0 {
@ -1695,7 +1697,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
// when multiple inputs reference the same transaction.
dependsMap := make(map[int64]struct{})
for _, txIn := range tx.TxIn {
if idx, ok := txIndex[txIn.PreviousOutPoint.Hash]; ok {
if idx, ok := txIndex[txIn.PreviousOutPoint.TxID]; ok {
dependsMap[idx] = struct{}{}
}
}
@ -1713,7 +1715,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
resultTx := btcjson.GetBlockTemplateResultTx{
Data: hex.EncodeToString(txBuf.Bytes()),
Hash: txHash.String(),
ID: txID.String(),
Depends: depends,
Fee: template.Fees[i],
SigOps: template.SigOpCounts[i],
@ -1772,7 +1774,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
resultTx := btcjson.GetBlockTemplateResultTx{
Data: hex.EncodeToString(txBuf.Bytes()),
Hash: tx.TxHash().String(),
ID: tx.TxID().String(),
Depends: []int64{},
Fee: template.Fees[0],
SigOps: template.SigOpCounts[0],
@ -2443,7 +2445,7 @@ func handleGetRawMempool(s *Server, cmd interface{}, closeChan <-chan struct{})
descs := mp.TxDescs()
hashStrings := make([]string, len(descs))
for i := range hashStrings {
hashStrings[i] = descs[i].Tx.Hash().String()
hashStrings[i] = descs[i].Tx.ID().String()
}
return hashStrings, nil
@ -2617,9 +2619,9 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
confirmations = 0
value = txOut.Value
pkScript = txOut.PkScript
isCoinbase = blockdag.IsCoinBaseTx(mtx)
isCoinbase = mtx.IsCoinBase()
} else {
out := wire.OutPoint{Hash: *txHash, Index: c.Vout}
out := wire.OutPoint{TxID: *txHash, Index: c.Vout}
entry, ok := s.cfg.DAG.GetUTXOEntry(out)
if !ok {
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
// memory pool.
origin := &txIn.PreviousOutPoint
originTx, err := mp.FetchTransaction(&origin.Hash)
originTx, err := mp.FetchTransaction(&origin.TxID)
if err == nil {
txOuts := originTx.MsgTx().TxOut
if origin.Index >= uint32(len(txOuts)) {
errStr := fmt.Sprintf("unable to find output "+
"%v referenced from transaction %s:%d",
origin, tx.TxHash(), txInIndex)
origin, tx.TxID(), txInIndex)
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.
blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(&origin.Hash)
blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(&origin.TxID)
if err != nil {
context := "Failed to retrieve transaction location"
return nil, internalRPCError(err.Error(), context)
}
if blockRegion == nil {
return nil, rpcNoTxInfoError(&origin.Hash)
return nil, rpcNoTxInfoError(&origin.TxID)
}
// 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
})
if err != nil {
return nil, rpcNoTxInfoError(&origin.Hash)
return nil, rpcNoTxInfoError(&origin.TxID)
}
// 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)) {
errStr := fmt.Sprintf("unable to find output %v "+
"referenced from transaction %s:%d", origin,
tx.TxHash(), txInIndex)
tx.TxID(), txInIndex)
return nil, internalRPCError(errStr, "")
}
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.
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.
if blockdag.IsCoinBaseTx(mtx) {
if mtx.IsCoinBase() {
// Only include the transaction if the filter map is empty
// because a coinbase input has no addresses and so would never
// match a non-empty filter.
@ -2847,7 +2849,7 @@ func createVinListPrevOut(s *Server, mtx *wire.MsgTx, chainParams *dagconfig.Par
// requested and available.
prevOut := &txIn.PreviousOutPoint
vinEntry := btcjson.VinPrevOut{
TxID: prevOut.Hash.String(),
TxID: prevOut.TxID.String(),
Vout: prevOut.Index,
Sequence: txIn.Sequence,
ScriptSig: &btcjson.ScriptSig{
@ -3151,7 +3153,7 @@ func handleSearchRawTransactions(s *Server, cmd interface{}, closeChan <-chan st
result := &srtList[i]
result.Hex = hexTxns[i]
result.TxID = mtx.TxHash().String()
result.TxID = mtx.TxID().String()
result.Vin, err = createVinListPrevOut(s, mtx, params, vinExtra,
filterAddrMap)
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 code (to match bitcoind behavior).
if _, ok := err.(mempool.RuleError); ok {
log.Debugf("Rejected transaction %v: %v", tx.Hash(),
log.Debugf("Rejected transaction %v: %v", tx.ID(),
err)
} else {
log.Errorf("Failed to process transaction %v: %v",
tx.Hash(), err)
tx.ID(), err)
}
return nil, &btcjson.RPCError{
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
// 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)
if err != nil {
return nil, err
}
errStr := fmt.Sprintf("transaction %v is not in accepted list",
tx.Hash())
tx.ID())
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
// can be rebroadcast if they don't make their way into a block.
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)
return tx.Hash().String(), nil
return tx.ID().String(), nil
}
// handleSetGenerate implements the setGenerate command.

1
server/rpc/rpcserverhelp.go
View File

@ -291,6 +291,7 @@ var helpDescsEnUS = map[string]string{
// GetBlockTemplateResultTx help.
"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-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-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",

17
server/rpc/rpcwebsocket.go
View File

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

8
txscript/engine_test.go
View File

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

4
txscript/example_test.go
View File

@ -111,7 +111,7 @@ func ExampleSignTxOutput() {
}
txOut := wire.NewTxOut(100000000, pkScript)
originTx.AddTxOut(txOut)
originTxHash := originTx.TxHash()
originTxID := originTx.TxID()
// Create the transaction to redeem the fake transaction.
redeemTx := wire.NewMsgTx(wire.TxVersion)
@ -119,7 +119,7 @@ func ExampleSignTxOutput() {
// 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
// yet, hence nil is provided for it.
prevOut = wire.NewOutPoint(&originTxHash, 0)
prevOut = wire.NewOutPoint(&originTxID, 0)
txIn = wire.NewTxIn(prevOut, nil)
redeemTx.AddTxIn(txIn)

4
txscript/reference_test.go
View File

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

6
txscript/sign_test.go
View File

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

22
util/block_test.go
View File

@ -37,7 +37,7 @@ func TestBlock(t *testing.T) {
}
// Hash for block 100,000.
wantHashStr := "b75e32d07046b5290e131686c2b98636483cc4119573926eebc9dc944496d53b"
wantHashStr := "c076eb7a2c8cb2d8492a9a2a4221f7b031257e71acef37fd12a9967661f57693"
wantHash, err := daghash.NewHashFromStr(wantHashStr)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
@ -146,10 +146,10 @@ func TestBlock(t *testing.T) {
// Transaction offsets and length for the transaction in Block100000.
wantTxLocs := []wire.TxLoc{
{TxStart: 122, TxLen: 163},
{TxStart: 285, TxLen: 287},
{TxStart: 572, TxLen: 285},
{TxStart: 857, TxLen: 253},
{TxStart: 154, TxLen: 163},
{TxStart: 317, TxLen: 287},
{TxStart: 604, TxLen: 285},
{TxStart: 889, TxLen: 253},
}
// Ensure the transaction location information is accurate.
@ -258,7 +258,7 @@ func TestBlockErrors(t *testing.T) {
}
// Truncate the block byte buffer to force errors.
shortBytes := block100000Bytes[:122]
shortBytes := block100000Bytes[:154]
_, err = util.NewBlockFromBytes(shortBytes)
if err != io.EOF {
t.Errorf("NewBlockFromBytes: did not get expected error - "+
@ -318,7 +318,7 @@ var Block100000 = wire.MsgBlock{
0x17, 0xbe, 0x75, 0xe7, 0x29, 0x46, 0xdd, 0x03,
0x01, 0x92, 0x90, 0xf1, 0xca, 0x8a, 0x88, 0x11,
}}, // 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,
0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
@ -334,7 +334,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
@ -369,7 +369,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -439,7 +439,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -508,7 +508,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{
{
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,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
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 {
// Serialize
var buf [daghash.HashSize + 4]byte
copy(buf[:], outpoint.Hash[:])
copy(buf[:], outpoint.TxID[:])
binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index)
return bf.matches(buf[:])
@ -230,7 +230,7 @@ func (bf *Filter) AddHash(hash *daghash.Hash) {
func (bf *Filter) addOutPoint(outpoint *wire.OutPoint) {
// Serialize
var buf [daghash.HashSize + 4]byte
copy(buf[:], outpoint.Hash[:])
copy(buf[:], outpoint.TxID[:])
binary.LittleEndian.PutUint32(buf[daghash.HashSize:], outpoint.Index)
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.
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.
matched := bf.matches(tx.Hash()[:])
matched := bf.matches(tx.ID()[:])
// 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
@ -295,7 +295,7 @@ func (bf *Filter) matchTxAndUpdate(tx *util.Tx) bool {
}
matched = true
bf.maybeAddOutpoint(txOut.PkScript, tx.Hash(), uint32(i))
bf.maybeAddOutpoint(txOut.PkScript, tx.ID(), uint32(i))
break
}
}

119
util/bloom/filter_test.go
View File

@ -244,50 +244,86 @@ func TestFilterInsertKey(t *testing.T) {
}
func TestFilterBloomMatch(t *testing.T) {
str := "01000000010B26E9B7735EB6AABDF358BAB62F9816A21BA9" +
"EBDB719D5299E88607D722C190000000008B483045022007" +
"0ACA44506C5CEF3A16ED519D7C3C39F8AAB192C4E1C90D06" +
"5F37B8A4AF6141022100A8E160B856C2D43D27D8FBA71E5A" +
"EF6405B8643AC4CB7CB3C462ACED7F14711A0141046D11FE" +
"E51B0E60666D5049A9101A72741DF480B96EE26488A4D346" +
"6B95C9A40AC5EEEF87E10A5CD336C19A84565F80FA6C5479" +
"57B7700FF4DFBDEFE76036C339FFFFFFFFFFFFFFFF021BFF" +
"3D11000000001976A91404943FDD508053C75000106D3BC6" +
"E2754DBCFF1988AC2F15DE00000000001976A914A266436D" +
"2965547608B9E15D9032A7B9D64FA43188AC000000000000" +
"00000100000000000000000000000000000000000000"
strBytes, err := hex.DecodeString(str)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err)
return
strBytes := []byte{
0x01, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x26, 0xe9,
0xb7, 0x73, 0x5e, 0xb6, 0xaa, 0xbd, 0xf3, 0x58,
0xba, 0xb6, 0x2f, 0x98, 0x16, 0xa2, 0x1b, 0xa9,
0xeb, 0xdb, 0x71, 0x9d, 0x52, 0x99, 0xe8, 0x86,
0x07, 0xd7, 0x22, 0xc1, 0x90, 0x00, 0x00, 0x00,
0x00, 0x8b, 0x48, 0x30, 0x45, 0x02, 0x20, 0x07,
0x0a, 0xca, 0x44, 0x50, 0x6c, 0x5c, 0xef, 0x3a,
0x16, 0xed, 0x51, 0x9d, 0x7c, 0x3c, 0x39, 0xf8,
0xaa, 0xb1, 0x92, 0xc4, 0xe1, 0xc9, 0x0d, 0x06,
0x5f, 0x37, 0xb8, 0xa4, 0xaf, 0x61, 0x41, 0x02,
0x21, 0x00, 0xa8, 0xe1, 0x60, 0xb8, 0x56, 0xc2,
0xd4, 0x3d, 0x27, 0xd8, 0xfb, 0xa7, 0x1e, 0x5a,
0xef, 0x64, 0x05, 0xb8, 0x64, 0x3a, 0xc4, 0xcb,
0x7c, 0xb3, 0xc4, 0x62, 0xac, 0xed, 0x7f, 0x14,
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)
if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return
}
spendingTxStr := "0100000001D25EE298643F1793383A12" +
"8F8E70FF33932B6532511CC6E7556D03" +
"3370AB7CB7000000008C493046022100" +
"DA0DC6AECEFE1E06EFDF05773757DEB1" +
"68820930E3B0D03F46F5FCF150BF990C" +
"022100D25B5C87040076E4F253F8262E" +
"763E2DD51E7FF0BE157727C4BC42807F" +
"17BD39014104E6C26EF67DC610D2CD19" +
"2484789A6CF9AEA9930B944B7E2DB534" +
"2B9D9E5B9FF79AFF9A2EE1978DD7FD01" +
"DFC522EE02283D3B06A9D03ACF809696" +
"8D7DBB0F9178FFFFFFFFFFFFFFFF028B" +
"A7940E000000001976A914BADEECFDEF" +
"0507247FC8F74241D73BC039972D7B88" +
"AC4094A802000000001976A914C10932" +
"483FEC93ED51F5FE95E72559F2CC7043" +
"F988AC00000000000000000100000000" +
"000000000000000000000000000000"
spendingTxBytes, err := hex.DecodeString(spendingTxStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed to decode spendingTxStr: %v", err)
return
spendingTxBytes := []byte{
0x01, 0x00, 0x00, 0x00, 0x01, 0x4c, 0x55, 0x7d,
0x38, 0xc1, 0xde, 0x01, 0x1d, 0x08, 0x0d, 0x54,
0x16, 0xd4, 0x8f, 0x67, 0xdb, 0xbd, 0x20, 0xf2,
0x60, 0x68, 0x4a, 0x1b, 0x58, 0xb8, 0xbb, 0x9e,
0x8c, 0x65, 0x1c, 0xf0, 0xcb, 0x00, 0x00, 0x00,
0x00, 0x8c, 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, 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)
@ -297,7 +333,7 @@ func TestFilterBloomMatch(t *testing.T) {
}
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)
if err != nil {
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)
inputStr = "d25ee298643f1793383a128f8e70ff33932b6532511cc6e7556d033370ab7cb7" // non-reversed tx hash
inputStr = "4c557d38c1de011d080d5416d48f67dbbd20f260684a1b58b8bb9e8c651cf0cb" // non-reversed tx id
hashBytes, err := hex.DecodeString(inputStr)
if err != nil {
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
0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
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
0x4C, 0x86, 0x04, 0x1B, // Bits
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 {
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.

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
0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77, 0x0F, 0xDC, 0xC9,
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
0x4C, 0x86, 0x04, 0x1B, // Bits
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)
want := []byte{
0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xCD, 0xA8,
0x56, 0xB1, 0x43, 0xD9, 0xDB, 0x2C, 0x1C, 0xAF,
0xF0, 0x1D, 0x1A, 0xEC, 0xC8, 0x63, 0x0D, 0x30,
0x62, 0x5D, 0x10, 0xE8, 0xB4, 0xB8, 0xB0, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xB5, 0x0C, 0xC0,
0x69, 0xD6, 0xA3, 0xE3, 0x3E, 0x3F, 0xF8, 0x4A,
0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77,
0x0F, 0xDC, 0xC9, 0x6B, 0x2C, 0x3F, 0xF6, 0x0A,
0xBE, 0x18, 0x4F, 0x19, 0x63, 0x67, 0x29, 0x1B,
0x4D, 0x00, 0x00, 0x00, 0x00, 0x4C, 0x86, 0x04,
0x1B, 0x8F, 0xA4, 0x5D, 0x63, 0x00, 0x00, 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,
0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xcd, 0xa8,
0x56, 0xb1, 0x43, 0xd9, 0xdb, 0x2c, 0x1c, 0xaf,
0xf0, 0x1d, 0x1a, 0xec, 0xc8, 0x63, 0x0d, 0x30,
0x62, 0x5d, 0x10, 0xe8, 0xb4, 0xb8, 0xb0, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x0c, 0xc0,
0x69, 0xd6, 0xa3, 0xe3, 0x3e, 0x3f, 0xf8, 0x4a,
0x5c, 0x41, 0xd9, 0xd3, 0xfe, 0xbe, 0x7c, 0x77,
0x0f, 0xdc, 0xc9, 0x6b, 0x2c, 0x3f, 0xf6, 0x0a,
0xbe, 0x18, 0x4f, 0x19, 0x63, 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, 0x67, 0x29, 0x1b,
0x4d, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x86, 0x04,
0x1b, 0x8f, 0xa4, 0x5d, 0x63, 0x00, 0x00, 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))
if err != nil {

8
util/coinset/coins.go
View File

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

6
util/coinset/coins_test.go
View File

@ -19,12 +19,14 @@ import (
type TestCoin struct {
TxHash *daghash.Hash
TxID *daghash.Hash
TxIndex uint32
TxValue util.Amount
TxNumConfs int64
}
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) Value() util.Amount { return c.TxValue }
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.Write([]byte(fmt.Sprintf("%d", index)))
hash, _ := daghash.NewHash(h.Sum(nil))
id, _ := daghash.NewHash(h.Sum(nil))
c := &TestCoin{
TxHash: hash,
TxID: id,
TxIndex: 0,
TxValue: value,
TxNumConfs: numConfs,
@ -115,7 +119,7 @@ func TestCoinSet(t *testing.T) {
t.Errorf("Expected only 1 TxIn, got %d", len(mtx.TxIn))
}
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")
}
}

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 {
// Size of the hash plus size of int32 index
data := make([]byte, daghash.HashSize+4)
copy(data[:], outpoint.Hash.CloneBytes()[:])
copy(data[:], outpoint.TxID.CloneBytes()[:])
binary.LittleEndian.PutUint32(data[daghash.HashSize:], outpoint.Index)
return data
}
@ -305,8 +305,8 @@ func BuildBasicFilter(block *wire.MsgBlock) (*gcs.Filter, error) {
for i, tx := range block.Transactions {
// First we'll compute the bash of the transaction and add that
// directly to the filter.
txHash := tx.TxHash()
b.AddHash(&txHash)
txID := tx.TxID()
b.AddHash(&txID)
// Skip the inputs for the coinbase transaction
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.
func TestUseBlockHash(t *testing.T) {
// Block hash #448710, pretty high difficulty.
hash, err := daghash.NewHashFromStr(testHash)
txID, err := daghash.NewHashFromStr(testHash)
if err != nil {
t.Fatalf("Hash from string failed: %s", err.Error())
}
// wire.OutPoint
outPoint := wire.OutPoint{
Hash: *hash,
TxID: *txID,
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
// correctly, then test it.
b := builder.WithKeyHash(hash)
b := builder.WithKeyHash(txID)
key, err := b.Key()
if err != nil {
t.Fatalf("Builder instantiation with key hash failed: %s",
@ -84,16 +84,16 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]),
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.
b = builder.WithKeyHashP(hash, 30)
BuilderTest(b, hash, 30, outPoint, addrBytes, t)
b = builder.WithKeyHashP(txID, 30)
BuilderTest(b, txID, 30, outPoint, addrBytes, t)
// Create a GCSBuilder with a random key, set the key from a hash
// manually, check that the key is correct, and test it.
b = builder.WithRandomKey()
b.SetKeyFromHash(hash)
b.SetKeyFromHash(txID)
key, err = b.Key()
if err != nil {
t.Fatalf("Builder instantiation with known key failed: %s",
@ -104,7 +104,7 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]),
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.
b = builder.WithRandomKey()
@ -114,7 +114,7 @@ func TestUseBlockHash(t *testing.T) {
err.Error())
}
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.
b = builder.WithRandomKeyP(30)
@ -127,7 +127,7 @@ func TestUseBlockHash(t *testing.T) {
if key2 == key1 {
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.
b = builder.WithKey(testKey)
@ -141,7 +141,7 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]),
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.
b = builder.WithKeyP(testKey, 30)
@ -155,13 +155,13 @@ func TestUseBlockHash(t *testing.T) {
hex.EncodeToString(key[:]),
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
// works throughout all functions that use it.
b = builder.WithRandomKeyP(33).SetKeyFromHash(hash).SetKey(testKey)
b.SetP(30).AddEntry(hash.CloneBytes()).AddEntries(contents)
b.AddOutPoint(outPoint).AddHash(hash).AddScript(addrBytes)
b = builder.WithRandomKeyP(33).SetKeyFromHash(txID).SetKey(testKey)
b.SetP(30).AddEntry(txID.CloneBytes()).AddEntries(contents)
b.AddOutPoint(outPoint).AddHash(txID).AddScript(addrBytes)
_, err = b.Key()
if err != gcs.ErrPTooBig {
t.Fatalf("No error on P too big!")

16
util/tx.go
View File

@ -24,6 +24,7 @@ const TxIndexUnknown = -1
type Tx struct {
msgTx *wire.MsgTx // Underlying MsgTx
txHash *daghash.Hash // Cached transaction hash
txID *daghash.Hash // Cached transaction ID
txIndex int // Position within a block or TxIndexUnknown
}
@ -48,6 +49,21 @@ func (t *Tx) Hash() *daghash.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
// will be TxIndexUnknown if it hasn't already explicitly been set.
func (t *Tx) Index() int {

28
util/tx_test.go
View File

@ -17,19 +17,21 @@ import (
// TestTx tests the API for Tx.
func TestTx(t *testing.T) {
testTx := Block100000.Transactions[0]
tx := util.NewTx(testTx)
firstTestTx := Block100000.Transactions[0]
firstTx := util.NewTx(firstTestTx)
secondTestTx := Block100000.Transactions[1]
secondTx := util.NewTx(secondTestTx)
// 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",
spew.Sdump(msgTx), spew.Sdump(testTx))
spew.Sdump(msgTx), spew.Sdump(firstTestTx))
}
// Ensure transaction index set and get work properly.
wantIndex := 0
tx.SetIndex(0)
if gotIndex := tx.Index(); gotIndex != wantIndex {
firstTx.SetIndex(0)
if gotIndex := firstTx.Index(); gotIndex != wantIndex {
t.Errorf("Index: mismatched index - got %v, want %v",
gotIndex, wantIndex)
}
@ -43,12 +45,24 @@ func TestTx(t *testing.T) {
// Request the hash multiple times to test generation and caching.
for i := 0; i < 2; i++ {
hash := tx.Hash()
hash := firstTx.Hash()
if !hash.IsEqual(wantHash) {
t.Errorf("Hash #%d mismatched hash - got %v, want %v", i,
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.

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.
func (s sortableInputSlice) Less(i, j int) bool {
// Input hashes are the same, so compare the index.
ihash := s[i].PreviousOutPoint.Hash
jhash := s[j].PreviousOutPoint.Hash
ihash := s[i].PreviousOutPoint.TxID
jhash := s[j].PreviousOutPoint.TxID
if ihash == jhash {
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{
{
PreviousOutPoint: OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
@ -197,7 +197,7 @@ func BenchmarkReadOutPoint(b *testing.B) {
// transaction output point.
func BenchmarkWriteOutPoint(b *testing.B) {
op := &OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0,
}
for i := 0; i < b.N; i++ {
@ -268,7 +268,7 @@ func BenchmarkReadTxIn(b *testing.B) {
func BenchmarkWriteTxIn(b *testing.B) {
txIn := blockOne.Transactions[0].TxIn[0]
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
}
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.
@ -575,7 +575,7 @@ func BenchmarkDecodeMerkleBlock(b *testing.B) {
if err != nil {
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++ {
hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
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,
// not including the list of parent block headers.
// 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
// 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.
// 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.
ParentHashes []daghash.Hash
// Merkle tree reference to hash of all transactions for the block.
MerkleRoot daghash.Hash
// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
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.
Timestamp time.Time
@ -124,20 +127,21 @@ func (h *BlockHeader) SerializeSize() int {
}
// 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.
func NewBlockHeader(version int32, parentHashes []daghash.Hash, merkleRootHash *daghash.Hash,
bits uint32, nonce uint64) *BlockHeader {
func NewBlockHeader(version int32, parentHashes []daghash.Hash, hashMerkleRoot *daghash.Hash,
idMerkleRoot *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
// Limit the timestamp to one second precision since the protocol
// doesn't support better.
return &BlockHeader{
Version: version,
ParentHashes: parentHashes,
MerkleRoot: *merkleRootHash,
Timestamp: time.Unix(time.Now().Unix(), 0),
Bits: bits,
Nonce: nonce,
Version: version,
ParentHashes: parentHashes,
HashMerkleRoot: *hashMerkleRoot,
IDMerkleRoot: *idMerkleRoot,
Timestamp: time.Unix(time.Now().Unix(), 0),
Bits: bits,
Nonce: nonce,
}
}
@ -158,7 +162,7 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
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
@ -166,6 +170,6 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
// opposed to encoding for the wire.
func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
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)
}

101
wire/blockheader_test.go
View File

@ -24,17 +24,18 @@ func TestBlockHeader(t *testing.T) {
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := mainNetGenesisMerkleRoot
idMerkleRoot := &exampleIDMerkleRoot
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.
if !reflect.DeepEqual(bh.ParentHashes, hashes) {
t.Errorf("NewBlockHeader: wrong prev hashes - got %v, want %v",
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",
spew.Sprint(bh.MerkleRoot), spew.Sprint(merkleHash))
spew.Sprint(bh.HashMerkleRoot), spew.Sprint(merkleHash))
}
if bh.Bits != bits {
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.
bits := uint32(0x1d00ffff)
baseBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
HashMerkleRoot: mainNetGenesisMerkleRoot,
IDMerkleRoot: exampleIDMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Bits: bits,
Nonce: nonce,
}
// 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,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
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,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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.
bits := uint32(0x1d00ffff)
baseBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
HashMerkleRoot: mainNetGenesisMerkleRoot,
IDMerkleRoot: exampleIDMerkleRoot,
Timestamp: time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
Bits: bits,
Nonce: nonce,
}
// 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,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
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,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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)
timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
baseBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
HashMerkleRoot: mainNetGenesisMerkleRoot,
IDMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
}
genesisBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{},
HashMerkleRoot: mainNetGenesisMerkleRoot,
IDMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
}
tests := []struct {
in *BlockHeader // Block header to encode
size int // Expected serialized size
}{
// Block with no transactions.
{genesisBlockHdr, 57},
{genesisBlockHdr, 89},
// First block in the mainnet block chain.
{baseBlockHdr, 121},
// First block in the mainnet block DAG.
{baseBlockHdr, 153},
}
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
baseBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
}
genesisBlockHdr := &BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{},
MerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
Version: 1,
ParentHashes: []daghash.Hash{},
HashMerkleRoot: mainNetGenesisMerkleRoot,
Timestamp: timestamp,
Bits: bits,
Nonce: nonce,
}
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,
})
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
// errors in the RandomUint64 function.
type fakeRandReader struct {

6
wire/message_test.go
View File

@ -68,7 +68,7 @@ func TestMessage(t *testing.T) {
msgFilterAdd := NewMsgFilterAdd([]byte{0x01})
msgFilterClear := NewMsgFilterClear()
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)
msgReject := NewMsgReject("block", RejectDuplicate, "duplicate block")
msgGetCFilters := NewMsgGetCFilters(GCSFilterExtended, 0, &daghash.Hash{})
@ -91,7 +91,7 @@ func TestMessage(t *testing.T) {
{msgGetAddr, msgGetAddr, pver, MainNet, 24},
{msgAddr, msgAddr, pver, MainNet, 25},
{msgGetBlocks, msgGetBlocks, pver, MainNet, 61},
{msgBlock, msgBlock, pver, MainNet, 308},
{msgBlock, msgBlock, pver, MainNet, 340},
{msgInv, msgInv, pver, MainNet, 25},
{msgGetData, msgGetData, pver, MainNet, 25},
{msgNotFound, msgNotFound, pver, MainNet, 25},
@ -107,7 +107,7 @@ func TestMessage(t *testing.T) {
{msgFilterAdd, msgFilterAdd, pver, MainNet, 26},
{msgFilterClear, msgFilterClear, pver, MainNet, 24},
{msgFilterLoad, msgFilterLoad, pver, MainNet, 35},
{msgMerkleBlock, msgMerkleBlock, pver, MainNet, 151},
{msgMerkleBlock, msgMerkleBlock, pver, MainNet, 183},
{msgReject, msgReject, pver, MainNet, 79},
{msgGetCFilters, msgGetCFilters, 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()
}
// 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
// Message interface. See MsgBlock for details.
func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {

89
wire/msgblock_test.go
View File

@ -22,10 +22,11 @@ func TestBlock(t *testing.T) {
// Block 1 header.
parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot
hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits
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.
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.
func TestBlockHash(t *testing.T) {
// Block 1 hash.
hashStr := "f10122ba81929ca2bc907541ebb20302122ce83a24ff9124c9e36402ecd837b7"
hashStr := "67ec32b619b4cda3255de5318c730e2e9f696d335427adfecae884aa41156b0f"
wantHash, err := daghash.NewHashFromStr(hashStr)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
@ -218,18 +197,20 @@ func TestBlockWireErrors(t *testing.T) {
{&blockOne, blockOneBytes, pver, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2.
{&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},
// Force error in timestamp.
// Force error in ID merkle root.
{&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.
{&blockOne, blockOneBytes, pver, 109, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, 141, io.ErrShortWrite, io.EOF},
// 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.
{&blockOne, blockOneBytes, pver, 121, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, 153, io.ErrShortWrite, io.EOF},
// 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))
@ -340,18 +321,20 @@ func TestBlockSerializeErrors(t *testing.T) {
{&blockOne, blockOneBytes, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2.
{&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},
// Force error in timestamp.
// Force error in ID merkle root.
{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
// Force error in difficulty bits.
{&blockOne, blockOneBytes, 109, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, 141, io.ErrShortWrite, io.EOF},
// Force error in header nonce.
{&blockOne, blockOneBytes, 113, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, 145, io.ErrShortWrite, io.EOF},
// Force error in transaction count.
{&blockOne, blockOneBytes, 121, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, 153, io.ErrShortWrite, io.EOF},
// 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))
@ -414,10 +397,14 @@ func TestBlockOverflowErrors(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
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,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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
}{
// Block with no transactions.
{noTxBlock, 122},
{noTxBlock, 154},
// First block in the mainnet block chain.
{&blockOne, len(blockOneBytes)},
@ -491,13 +478,13 @@ func TestBlockSerializeSize(t *testing.T) {
// blockOne is the first block in the mainnet block chain.
var blockOne = MsgBlock{
Header: BlockHeader{
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
MerkleRoot: daghash.Hash(mainNetGenesisMerkleRoot),
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689
Version: 1,
ParentHashes: []daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
HashMerkleRoot: daghash.Hash(mainNetGenesisMerkleRoot),
IDMerkleRoot: exampleIDMerkleRoot,
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689
},
Transactions: []*MsgTx{
{
@ -505,7 +492,7 @@ var blockOne = MsgBlock{
TxIn: []*TxIn{
{
PreviousOutPoint: OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
@ -550,10 +537,14 @@ var blockOneBytes = []byte{
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
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,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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.
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.
// Num headers (varInt) + max allowed headers (header length + 1 byte
// for the number of transactions which is always 0).
wantPayload := uint32(16436009)
wantPayload := uint32(16500009)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
@ -62,10 +62,11 @@ func TestHeaders(t *testing.T) {
// numbers of headers and protocol versions.
func TestHeadersWire(t *testing.T) {
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := blockOne.Header.MerkleRoot
hashMerkleRoot := blockOne.Header.HashMerkleRoot
idMerkleRoot := blockOne.Header.IDMerkleRoot
bits := uint32(0x1d00ffff)
nonce := uint64(0x9962e301)
bh := NewBlockHeader(1, hashes, &merkleHash, bits, nonce)
bh := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bh.Version = blockOne.Header.Version
bh.Timestamp = blockOne.Header.Timestamp
@ -94,6 +95,10 @@ func TestHeadersWire(t *testing.T) {
0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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{}
hashes := []daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
merkleHash := blockOne.Header.MerkleRoot
hashMerkleRoot := blockOne.Header.HashMerkleRoot
idMerkleRoot := blockOne.Header.IDMerkleRoot
bits := uint32(0x1d00ffff)
nonce := uint64(0x9962e301)
bh := NewBlockHeader(1, hashes, &merkleHash, bits, nonce)
bh := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bh.Version = blockOne.Header.Version
bh.Timestamp = blockOne.Header.Timestamp
@ -250,6 +256,10 @@ func TestHeadersWireErrors(t *testing.T) {
0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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
// to force errors.
bhTrans := NewBlockHeader(1, hashes, &merkleHash, bits, nonce)
bhTrans := NewBlockHeader(1, hashes, &hashMerkleRoot, &idMerkleRoot, bits, nonce)
bhTrans.Version = blockOne.Header.Version
bhTrans.Timestamp = blockOne.Header.Timestamp
@ -287,10 +297,14 @@ func TestHeadersWireErrors(t *testing.T) {
0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
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,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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.
{maxHeaders, maxHeadersEncoded, pver, 3, wireErr, wireErr},
// 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.
{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.
parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot
hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits
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.
wantCmd := "merkleblock"
@ -114,10 +115,11 @@ func TestMerkleBlock(t *testing.T) {
func TestMerkleBlockCrossProtocol(t *testing.T) {
// Block 1 header.
parentHashes := blockOne.Header.ParentHashes
merkleHash := &blockOne.Header.MerkleRoot
hashMerkleRoot := &blockOne.Header.HashMerkleRoot
idMerkleRoot := &blockOne.Header.IDMerkleRoot
bits := blockOne.Header.Bits
nonce := blockOne.Header.Nonce
bh := NewBlockHeader(1, parentHashes, merkleHash, bits, nonce)
bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot, bits, nonce)
msg := NewMsgMerkleBlock(bh)
@ -215,26 +217,28 @@ func TestMerkleBlockWireErrors(t *testing.T) {
{&merkleBlockOne, merkleBlockOneBytes, pver, 5, io.ErrShortWrite, io.EOF},
// Force error in prev block hash #2.
{&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},
// Force error in timestamp.
// Force error in hash merkle root.
{&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.
{&merkleBlockOne, merkleBlockOneBytes, pver, 109, io.ErrShortWrite, io.EOF},
{&merkleBlockOne, merkleBlockOneBytes, pver, 141, io.ErrShortWrite, io.EOF},
// 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.
{&merkleBlockOne, merkleBlockOneBytes, pver, 121, io.ErrShortWrite, io.EOF},
{&merkleBlockOne, merkleBlockOneBytes, pver, 153, io.ErrShortWrite, io.EOF},
// 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.
{&merkleBlockOne, merkleBlockOneBytes, pver, 126, io.ErrShortWrite, io.EOF},
// Force error in num flag bytes.
{&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.
{&merkleBlockOne, merkleBlockOneBytes, pver, 159, io.ErrShortWrite, io.EOF},
{&merkleBlockOne, merkleBlockOneBytes, pver, 191, io.ErrShortWrite, io.EOF},
// 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))
@ -294,7 +298,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
// allowed tx hashes.
var buf bytes.Buffer
WriteVarInt(&buf, pver, maxTxPerBlock+1)
numHashesOffset := 125
numHashesOffset := 157
exceedMaxHashes := make([]byte, numHashesOffset)
copy(exceedMaxHashes, merkleBlockOneBytes[:numHashesOffset])
exceedMaxHashes = append(exceedMaxHashes, buf.Bytes()...)
@ -303,7 +307,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
// allowed flag bytes.
buf.Reset()
WriteVarInt(&buf, pver, maxFlagsPerMerkleBlock+1)
numFlagBytesOffset := 158
numFlagBytesOffset := 190
exceedMaxFlagBytes := make([]byte, numFlagBytesOffset)
copy(exceedMaxFlagBytes, merkleBlockOneBytes[:numFlagBytesOffset])
exceedMaxFlagBytes = append(exceedMaxFlagBytes, buf.Bytes()...)
@ -339,15 +343,16 @@ var merkleBlockOne = MsgMerkleBlock{
Header: BlockHeader{
Version: 1,
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,
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
}),
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689
IDMerkleRoot: exampleIDMerkleRoot,
Timestamp: time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
Bits: 0x1d00ffff, // 486604799
Nonce: 0x9962e301, // 2573394689
},
Transactions: 1,
Hashes: []*daghash.Hash{
@ -377,7 +382,11 @@ var merkleBlockOneBytes = []byte{
0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44, // MerkleRoot
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
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
0xff, 0xff, 0x00, 0x1d, // Bits
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
)
// 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 (
// SubnetworkIDSupportsAll is the subnetwork ID that is used to signal to peers that you support all subnetworks
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
// transaction outputs.
type OutPoint struct {
Hash daghash.Hash
TxID daghash.Hash
Index uint32
}
@ -177,7 +189,7 @@ type OutPoint struct {
// provided hash and index.
func NewOutPoint(hash *daghash.Hash, index uint32) *OutPoint {
return &OutPoint{
Hash: *hash,
TxID: *hash,
Index: index,
}
}
@ -191,7 +203,7 @@ func (o OutPoint) String() string {
// optimization may go unnoticed, so allocate space for 10 decimal
// digits, which will fit any uint32.
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 = strconv.AppendUint(buf, uint64(o.Index), 10)
return string(buf)
@ -207,11 +219,22 @@ type TxIn struct {
// SerializeSize returns the number of bytes it would take to serialize the
// the transaction input.
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 +
// serialized varint size for the length of SignatureScript +
// SignatureScript bytes.
return 44 + VarIntSerializeSize(uint64(len(t.SignatureScript))) +
len(t.SignatureScript)
return 44 + serializeSignatureScriptSize(t.SignatureScript, encodingFlags)
}
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
@ -274,6 +297,23 @@ func (msg *MsgTx) AddTxOut(to *TxOut) {
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.
func (msg *MsgTx) TxHash() daghash.Hash {
// 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())
}
// 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
// modified when the copy is manipulated.
func (msg *MsgTx) Copy() *MsgTx {
@ -309,7 +365,7 @@ func (msg *MsgTx) Copy() *MsgTx {
// Deep copy the old previous outpoint.
oldOutPoint := oldTxIn.PreviousOutPoint
newOutPoint := OutPoint{}
newOutPoint.Hash.SetBytes(oldOutPoint.Hash[:])
newOutPoint.TxID.SetBytes(oldOutPoint.TxID[:])
newOutPoint.Index = oldOutPoint.Index
// 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
// database, as opposed to encoding transactions for the wire.
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))
if err != nil {
return err
@ -572,7 +632,7 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
}
for _, ti := range msg.TxIn {
err = writeTxIn(w, pver, msg.Version, ti)
err = writeTxIn(w, pver, msg.Version, ti, encodingFlags)
if err != nil {
return err
}
@ -612,11 +672,12 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
return err
}
err = WriteVarInt(w, pver, uint64(len(msg.Payload)))
if err != nil {
return err
if encodingFlags&txEncodingExcludeSubNetworkData != txEncodingExcludeSubNetworkData {
err = WriteVarInt(w, pver, uint64(len(msg.Payload)))
w.Write(msg.Payload)
} else {
err = WriteVarInt(w, pver, 0)
}
_, err := w.Write(msg.Payload)
if err != nil {
return err
}
@ -648,9 +709,22 @@ func (msg *MsgTx) Serialize(w io.Writer) error {
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.
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
// bytes + Serialized varint size for the number of transaction
// inputs and outputs.
@ -658,19 +732,28 @@ func (msg *MsgTx) SerializeSize() int {
VarIntSerializeSize(uint64(len(msg.TxOut)))
if msg.SubnetworkID != SubnetworkIDNative {
// Gas 8 bytes + Serialized varint size for the length of the payload
n += 8 + VarIntSerializeSize(uint64(len(msg.Payload)))
// Gas 8 bytes
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 {
n += txIn.SerializeSize()
n += txIn.serializeSize(encodingFlags)
}
for _, txOut := range msg.TxOut {
n += txOut.SerializeSize()
}
n += len(msg.Payload)
if encodingFlags&txEncodingExcludeSubNetworkData != txEncodingExcludeSubNetworkData {
n += len(msg.Payload)
}
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.
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 {
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
// to w.
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 {
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
// 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)
if err != nil {
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 {
return err
}

117
wire/msgtx_test.go
View File

@ -51,9 +51,9 @@ func TestTx(t *testing.T) {
// testing package functionality.
prevOutIndex := uint32(1)
prevOut := NewOutPoint(hash, prevOutIndex)
if !prevOut.Hash.IsEqual(hash) {
if !prevOut.TxID.IsEqual(hash) {
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 {
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.
func TestTxHash(t *testing.T) {
// Hash of first transaction from block 113875.
hashStr := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa"
wantHash, err := daghash.NewHashFromStr(hashStr)
func TestTxHashAndID(t *testing.T) {
hash1Str := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa"
wantHash1, err := daghash.NewHashFromStr(hash1Str)
if err != nil {
t.Errorf("NewHashFromStr: %v", err)
return
}
// First transaction from block 113875.
msgTx := NewMsgTx(1)
tx1 := NewMsgTx(1)
txIn := TxIn{
PreviousOutPoint: OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
@ -164,15 +163,103 @@ func TestTxHash(t *testing.T) {
0xac, // OP_CHECKSIG
},
}
msgTx.AddTxIn(&txIn)
msgTx.AddTxOut(&txOut)
msgTx.LockTime = 0
tx1.AddTxIn(&txIn)
tx1.AddTxOut(&txOut)
tx1.LockTime = 0
// Ensure the hash produced is expected.
txHash := msgTx.TxHash()
if !txHash.IsEqual(wantHash) {
tx1Hash := tx1.TxHash()
if !tx1Hash.IsEqual(wantHash1) {
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{
{
PreviousOutPoint: OutPoint{
Hash: daghash.Hash{},
TxID: daghash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{