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

[DEV-361] Create type TxID as alias to daghash.Hash. (#175)

Browse Source 
* [DEV-361] Create type TxID as alias to daghash.Hash. Use it for transaction IDs

* [DEV-361] Fixed missed renames

* [DEV-361] Removed usage of zeroHash

* [DEV-361] Fixed more missed renames
This commit is contained in:
Evgeny Khirin 2019-01-27 14:27:10 +02:00 committed by Ori Newman
parent 9a2eee78a4
commit 100fbbaaa4
55 changed files with 431 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
blockdag/checkpoints.go
View File

@ -27,6 +27,15 @@ func newHashFromStr(hexStr string) *daghash.Hash {
return hash return hash
} }
// newTxIDFromStr converts the passed big-endian hex string into a
// daghash.TxID. It only differs from the one available in daghash in that
// it ignores the error since it will only (and must only) be called with
// hard-coded, and therefore known good, IDs.
func newTxIDFromStr(hexStr string) *daghash.TxID {
txID, _ := daghash.NewTxIDFromStr(hexStr)
return txID
}
// Checkpoints returns a slice of checkpoints (regardless of whether they are // Checkpoints returns a slice of checkpoints (regardless of whether they are
// already known). When there are no checkpoints for the chain, it will return // already known). When there are no checkpoints for the chain, it will return
// nil. // nil.

2
blockdag/common_test.go
View File

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

6
blockdag/dagio.go
View File

@ -528,10 +528,10 @@ func deserializeOutPoint(serialized []byte) (*wire.OutPoint, error) {
return nil, errDeserialize("unexpected end of data") return nil, errDeserialize("unexpected end of data")
} }
hash := daghash.Hash{} txID := daghash.TxID{}
hash.SetBytes(serialized[:daghash.HashSize]) txID.SetBytes(serialized[:daghash.HashSize])
index, _ := deserializeVLQ(serialized[daghash.HashSize:]) index, _ := deserializeVLQ(serialized[daghash.HashSize:])
return wire.NewOutPoint(&hash, uint32(index)), nil return wire.NewOutPoint(&txID, uint32(index)), nil
} }
// deserializeUTXOEntry decodes a UTXO entry from the passed serialized byte // deserializeUTXOEntry decodes a UTXO entry from the passed serialized byte

10
blockdag/dagio_test.go
View File

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

6
blockdag/fullblocktests/generate.go
View File

@ -285,7 +285,7 @@ func (g *testGenerator) createCoinbaseTx(blockHeight int32) *wire.MsgTx {
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
// Coinbase transactions have no inputs, so previous outpoint is // Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index. // zero hash and max index.
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{},
wire.MaxPrevOutIndex), wire.MaxPrevOutIndex),
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
SignatureScript: coinbaseScript, SignatureScript: coinbaseScript,
@ -1529,9 +1529,9 @@ func Generate(includeLargeReorg bool) (tests [][]TestInstance, err error) {
// \-> b52(14) // \-> b52(14)
g.setTip("b43") g.setTip("b43")
g.nextBlock("b52", outs[14], func(b *wire.MsgBlock) { g.nextBlock("b52", outs[14], func(b *wire.MsgBlock) {
hash := newHashFromStr("00000000000000000000000000000000" + txID := newTxIDFromStr("00000000000000000000000000000000" +
"00000000000000000123456789abcdef") "00000000000000000123456789abcdef")
b.Transactions[1].TxIn[0].PreviousOutPoint.TxID = *hash b.Transactions[1].TxIn[0].PreviousOutPoint.TxID = *txID
b.Transactions[1].TxIn[0].PreviousOutPoint.Index = 0 b.Transactions[1].TxIn[0].PreviousOutPoint.Index = 0
}) })
rejected(blockdag.ErrMissingTxOut) rejected(blockdag.ErrMissingTxOut)

14
blockdag/fullblocktests/params.go
View File

@ -29,6 +29,18 @@ func newHashFromStr(hexStr string) *daghash.Hash {
return hash return hash
} }
// newTxIDFromStr converts the passed big-endian hex string into a
// wire.TxID. It only differs from the one available in daghash in that
// it panics on an error since it will only (and must only) be called with
// hard-coded, and therefore known good, hashes.
func newTxIDFromStr(hexStr string) *daghash.TxID {
txID, err := daghash.NewTxIDFromStr(hexStr)
if err != nil {
panic(err)
}
return txID
}
// fromHex converts the passed hex string into a byte slice and will panic if // fromHex converts the passed hex string into a byte slice and will panic if
// there is an error. This is only provided for the hard-coded constants so // there is an error. This is only provided for the hard-coded constants so
// errors in the source code can be detected. It will only (and must only) be // errors in the source code can be detected. It will only (and must only) be
@ -65,7 +77,7 @@ var (
Version: 1, Version: 1,
TxIn: []*wire.TxIn{{ TxIn: []*wire.TxIn{{
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: fromHex("04ffff001d010445" + SignatureScript: fromHex("04ffff001d010445" +

18
blockdag/indexers/addrindex.go
View File

@ -569,8 +569,8 @@ type AddrIndex struct {
// This allows fairly efficient updates when transactions are removed // This allows fairly efficient updates when transactions are removed
// once they are included into a block. // once they are included into a block.
unconfirmedLock sync.RWMutex unconfirmedLock sync.RWMutex
txnsByAddr map[[addrKeySize]byte]map[daghash.Hash]*util.Tx txnsByAddr map[[addrKeySize]byte]map[daghash.TxID]*util.Tx
addrsByTx map[daghash.Hash]map[[addrKeySize]byte]struct{} addrsByTx map[daghash.TxID]map[[addrKeySize]byte]struct{}
} }
// Ensure the AddrIndex type implements the Indexer interface. // Ensure the AddrIndex type implements the Indexer interface.
@ -808,7 +808,7 @@ func (idx *AddrIndex) indexUnconfirmedAddresses(pkScript []byte, tx *util.Tx) {
idx.unconfirmedLock.Lock() idx.unconfirmedLock.Lock()
addrIndexEntry := idx.txnsByAddr[addrKey] addrIndexEntry := idx.txnsByAddr[addrKey]
if addrIndexEntry == nil { if addrIndexEntry == nil {
addrIndexEntry = make(map[daghash.Hash]*util.Tx) addrIndexEntry = make(map[daghash.TxID]*util.Tx)
idx.txnsByAddr[addrKey] = addrIndexEntry idx.txnsByAddr[addrKey] = addrIndexEntry
} }
addrIndexEntry[*tx.ID()] = tx addrIndexEntry[*tx.ID()] = tx
@ -860,22 +860,22 @@ func (idx *AddrIndex) AddUnconfirmedTx(tx *util.Tx, utxoSet blockdag.UTXOSet) {
// (memory-only) address index. // (memory-only) address index.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (idx *AddrIndex) RemoveUnconfirmedTx(hash *daghash.Hash) { func (idx *AddrIndex) RemoveUnconfirmedTx(txID *daghash.TxID) {
idx.unconfirmedLock.Lock() idx.unconfirmedLock.Lock()
defer idx.unconfirmedLock.Unlock() defer idx.unconfirmedLock.Unlock()
// Remove all address references to the transaction from the address // Remove all address references to the transaction from the address
// index and remove the entry for the address altogether if it no longer // index and remove the entry for the address altogether if it no longer
// references any transactions. // references any transactions.
for addrKey := range idx.addrsByTx[*hash] { for addrKey := range idx.addrsByTx[*txID] {
delete(idx.txnsByAddr[addrKey], *hash) delete(idx.txnsByAddr[addrKey], *txID)
if len(idx.txnsByAddr[addrKey]) == 0 { if len(idx.txnsByAddr[addrKey]) == 0 {
delete(idx.txnsByAddr, addrKey) delete(idx.txnsByAddr, addrKey)
} }
} }
// Remove the entry from the transaction to address lookup map as well. // Remove the entry from the transaction to address lookup map as well.
delete(idx.addrsByTx, *hash) delete(idx.addrsByTx, *txID)
} }
// UnconfirmedTxnsForAddress returns all transactions currently in the // UnconfirmedTxnsForAddress returns all transactions currently in the
@ -917,8 +917,8 @@ func (idx *AddrIndex) UnconfirmedTxnsForAddress(addr util.Address) []*util.Tx {
func NewAddrIndex(dagParams *dagconfig.Params) *AddrIndex { func NewAddrIndex(dagParams *dagconfig.Params) *AddrIndex {
return &AddrIndex{ return &AddrIndex{
dagParams: dagParams, dagParams: dagParams,
txnsByAddr: make(map[[addrKeySize]byte]map[daghash.Hash]*util.Tx), txnsByAddr: make(map[[addrKeySize]byte]map[daghash.TxID]*util.Tx),
addrsByTx: make(map[daghash.Hash]map[[addrKeySize]byte]struct{}), addrsByTx: make(map[daghash.TxID]map[[addrKeySize]byte]struct{}),
} }
} }

2
blockdag/indexers/cfindex.go
View File

@ -174,7 +174,7 @@ func storeFilter(dbTx database.Tx, block *util.Block, f *gcs.Filter,
var prevHeader *daghash.Hash var prevHeader *daghash.Hash
header := block.MsgBlock().Header header := block.MsgBlock().Header
if header.IsGenesis() { if header.IsGenesis() {
prevHeader = &daghash.Zero prevHeader = &daghash.ZeroHash
} else { } else {
ph := header.SelectedParentHash() ph := header.SelectedParentHash()
pfh, err := dbFetchFilterIdxEntry(dbTx, hkey, ph) pfh, err := dbFetchFilterIdxEntry(dbTx, hkey, ph)

36
blockdag/indexers/txindex.go
View File

@ -171,8 +171,8 @@ func putAcceptingBlocksEntry(target []byte, includingBlockID uint32) {
byteOrder.PutUint32(target, includingBlockID) byteOrder.PutUint32(target, includingBlockID)
} }
func dbPutIncludingBlocksEntry(dbTx database.Tx, txHash *daghash.Hash, blockID uint32, serializedData []byte) error { func dbPutIncludingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint32, serializedData []byte) error {
bucket, err := dbTx.Metadata().Bucket(includingBlocksIndexKey).CreateBucketIfNotExists(txHash[:]) bucket, err := dbTx.Metadata().Bucket(includingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
if err != nil { if err != nil {
return err return err
} }
@ -181,8 +181,8 @@ func dbPutIncludingBlocksEntry(dbTx database.Tx, txHash *daghash.Hash, blockID u
return bucket.Put(blockIDBytes, serializedData) return bucket.Put(blockIDBytes, serializedData)
} }
func dbPutAcceptingBlocksEntry(dbTx database.Tx, txHash *daghash.Hash, blockID uint32, serializedData []byte) error { func dbPutAcceptingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint32, serializedData []byte) error {
bucket, err := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).CreateBucketIfNotExists(txHash[:]) bucket, err := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
if err != nil { if err != nil {
return err return err
} }
@ -198,14 +198,14 @@ func dbPutAcceptingBlocksEntry(dbTx database.Tx, txHash *daghash.Hash, blockID u
// //
// P.S Because the transaction can be found in multiple blocks, this function arbitarily // P.S Because the transaction can be found in multiple blocks, this function arbitarily
// returns the first block region that is stored in the txindex. // returns the first block region that is stored in the txindex.
func dbFetchFirstTxRegion(dbTx database.Tx, txHash *daghash.Hash) (*database.BlockRegion, error) { func dbFetchFirstTxRegion(dbTx database.Tx, txID *daghash.TxID) (*database.BlockRegion, error) {
// Load the record from the database and return now if it doesn't exist. // Load the record from the database and return now if it doesn't exist.
txBucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txHash[:]) txBucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txID[:])
if txBucket == nil { if txBucket == nil {
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("No block region"+ Description: fmt.Sprintf("No block region"+
"was found for %s", txHash), "was found for %s", txID),
} }
} }
cursor := txBucket.Cursor() cursor := txBucket.Cursor()
@ -213,7 +213,7 @@ func dbFetchFirstTxRegion(dbTx database.Tx, txHash *daghash.Hash) (*database.Blo
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("No block region"+ Description: fmt.Sprintf("No block region"+
"was found for %s", txHash), "was found for %s", txID),
} }
} }
blockIDBytes := cursor.Key() blockIDBytes := cursor.Key()
@ -227,7 +227,7 @@ func dbFetchFirstTxRegion(dbTx database.Tx, txHash *daghash.Hash) (*database.Blo
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("corrupt transaction index "+ Description: fmt.Sprintf("corrupt transaction index "+
"entry for %s", txHash), "entry for %s", txID),
} }
} }
@ -237,7 +237,7 @@ func dbFetchFirstTxRegion(dbTx database.Tx, txHash *daghash.Hash) (*database.Blo
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("corrupt transaction index "+ Description: fmt.Sprintf("corrupt transaction index "+
"entry for %s: %v", txHash, err), "entry for %s: %v", txID, err),
} }
} }
@ -449,11 +449,11 @@ func (idx *TxIndex) ConnectBlock(dbTx database.Tx, block *util.Block, _ *blockda
// will be returned for the both the entry and the error. // will be returned for the both the entry and the error.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (idx *TxIndex) TxFirstBlockRegion(hash *daghash.Hash) (*database.BlockRegion, error) { func (idx *TxIndex) TxFirstBlockRegion(txID *daghash.TxID) (*database.BlockRegion, error) {
var region *database.BlockRegion var region *database.BlockRegion
err := idx.db.View(func(dbTx database.Tx) error { err := idx.db.View(func(dbTx database.Tx) error {
var err error var err error
region, err = dbFetchFirstTxRegion(dbTx, hash) region, err = dbFetchFirstTxRegion(dbTx, txID)
return err return err
}) })
return region, err return region, err
@ -499,23 +499,23 @@ func dbFetchTxBlocks(dbTx database.Tx, txHash *daghash.Hash) ([]daghash.Hash, er
} }
// BlockThatAcceptedTx returns the hash of the block where the transaction got accepted (from the virtual block point of view) // BlockThatAcceptedTx returns the hash of the block where the transaction got accepted (from the virtual block point of view)
func (idx *TxIndex) BlockThatAcceptedTx(dag *blockdag.BlockDAG, txHash *daghash.Hash) (*daghash.Hash, error) { func (idx *TxIndex) BlockThatAcceptedTx(dag *blockdag.BlockDAG, txID *daghash.TxID) (*daghash.Hash, error) {
var acceptingBlock *daghash.Hash var acceptingBlock *daghash.Hash
err := idx.db.View(func(dbTx database.Tx) error { err := idx.db.View(func(dbTx database.Tx) error {
var err error var err error
acceptingBlock, err = dbFetchTxAcceptingBlock(dbTx, txHash, dag) acceptingBlock, err = dbFetchTxAcceptingBlock(dbTx, txID, dag)
return err return err
}) })
return acceptingBlock, err return acceptingBlock, err
} }
func dbFetchTxAcceptingBlock(dbTx database.Tx, txHash *daghash.Hash, dag *blockdag.BlockDAG) (*daghash.Hash, error) { func dbFetchTxAcceptingBlock(dbTx database.Tx, txID *daghash.TxID, dag *blockdag.BlockDAG) (*daghash.Hash, error) {
bucket := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).Bucket(txHash[:]) bucket := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).Bucket(txID[:])
if bucket == nil { if bucket == nil {
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("No accepting blocks "+ Description: fmt.Sprintf("No accepting blocks "+
"were found for %s", txHash), "were found for %s", txID),
} }
} }
cursor := bucket.Cursor() cursor := bucket.Cursor()
@ -523,7 +523,7 @@ func dbFetchTxAcceptingBlock(dbTx database.Tx, txHash *daghash.Hash, dag *blockd
return nil, database.Error{ return nil, database.Error{
ErrorCode: database.ErrCorruption, ErrorCode: database.ErrCorruption,
Description: fmt.Sprintf("No accepting blocks "+ Description: fmt.Sprintf("No accepting blocks "+
"were found for %s", txHash), "were found for %s", txID),
} }
} }
for ; cursor.Key() != nil; cursor.Next() { for ; cursor.Key() != nil; cursor.Next() {

16
blockdag/indexers/txindex_test.go
View File

@ -136,7 +136,7 @@ var block1 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -194,7 +194,7 @@ var block2 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -221,7 +221,7 @@ var block2 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{ TxID: daghash.TxID{
0x71, 0x17, 0x72, 0x40, 0x46, 0x3e, 0x00, 0x87, 0x71, 0x17, 0x72, 0x40, 0x46, 0x3e, 0x00, 0x87,
0x00, 0x55, 0x61, 0xbf, 0x85, 0x88, 0x16, 0x2d, 0x00, 0x55, 0x61, 0xbf, 0x85, 0x88, 0x16, 0x2d,
0xe9, 0x75, 0x89, 0x10, 0x8f, 0x27, 0x7c, 0xb6, 0xe9, 0x75, 0x89, 0x10, 0x8f, 0x27, 0x7c, 0xb6,
@ -255,7 +255,7 @@ var block3Tx = &wire.MsgTx{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{ TxID: daghash.TxID{
0x54, 0x87, 0x57, 0x84, 0xed, 0x18, 0xc2, 0xde, 0x54, 0x87, 0x57, 0x84, 0xed, 0x18, 0xc2, 0xde,
0x6c, 0xdb, 0x54, 0xfa, 0xab, 0x4f, 0x1f, 0x52, 0x6c, 0xdb, 0x54, 0xfa, 0xab, 0x4f, 0x1f, 0x52,
0x73, 0x4b, 0xbb, 0x62, 0x79, 0x84, 0x95, 0xbe, 0x73, 0x4b, 0xbb, 0x62, 0x79, 0x84, 0x95, 0xbe,
@ -330,7 +330,7 @@ var block3 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -389,7 +389,7 @@ var block3A = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -448,7 +448,7 @@ var block4 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -512,7 +512,7 @@ var block5 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

2
blockdag/merkle.go
View File

@ -61,7 +61,7 @@ func BuildHashMerkleTreeStore(transactions []*util.Tx) MerkleTree {
func BuildIDMerkleTreeStore(transactions []*util.Tx) MerkleTree { func BuildIDMerkleTreeStore(transactions []*util.Tx) MerkleTree {
txIDs := make([]*daghash.Hash, len(transactions)) txIDs := make([]*daghash.Hash, len(transactions))
for i, tx := range transactions { for i, tx := range transactions {
txIDs[i] = tx.ID() txIDs[i] = (*daghash.Hash)(tx.ID())
} }
return buildMerkleTreeStore(txIDs) return buildMerkleTreeStore(txIDs)
} }

4
blockdag/test_utils.go
View File

@ -116,7 +116,7 @@ func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, su
for i := uint32(0); i < numInputs; i++ { for i := uint32(0); i < numInputs; i++ {
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, i), PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{}, i),
SignatureScript: []byte{}, SignatureScript: []byte{},
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}) })
@ -156,7 +156,7 @@ func createCoinbaseTxForTest(blockHeight int32, numOutputs uint32, extraNonce in
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
// Coinbase transactions have no inputs, so previous outpoint is // Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index. // zero hash and max index.
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{},
wire.MaxPrevOutIndex), wire.MaxPrevOutIndex),
SignatureScript: coinbaseScript, SignatureScript: coinbaseScript,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,

44
blockdag/utxoset_test.go
View File

@ -13,10 +13,10 @@ import (
// TestUTXOCollection makes sure that utxoCollection cloning and string representations work as expected. // TestUTXOCollection makes sure that utxoCollection cloning and string representations work as expected.
func TestUTXOCollection(t *testing.T) { func TestUTXOCollection(t *testing.T) {
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
hash1, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111") txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outPoint0 := *wire.NewOutPoint(hash0, 0) outPoint0 := *wire.NewOutPoint(txID0, 0)
outPoint1 := *wire.NewOutPoint(hash1, 0) outPoint1 := *wire.NewOutPoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0) utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 20}, false, 1) utxoEntry1 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 20}, false, 1)
@ -72,10 +72,10 @@ func TestUTXOCollection(t *testing.T) {
// TestUTXODiff makes sure that utxoDiff creation, cloning, and string representations work as expected. // TestUTXODiff makes sure that utxoDiff creation, cloning, and string representations work as expected.
func TestUTXODiff(t *testing.T) { func TestUTXODiff(t *testing.T) {
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
hash1, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111") txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outPoint0 := *wire.NewOutPoint(hash0, 0) outPoint0 := *wire.NewOutPoint(txID0, 0)
outPoint1 := *wire.NewOutPoint(hash1, 0) outPoint1 := *wire.NewOutPoint(txID1, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0) utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0)
utxoEntry1 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 20}, false, 1) utxoEntry1 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 20}, false, 1)
diff := UTXODiff{ diff := UTXODiff{
@ -111,8 +111,8 @@ func TestUTXODiff(t *testing.T) {
// TestUTXODiffRules makes sure that all diffFrom and WithDiff rules are followed. // TestUTXODiffRules makes sure that all diffFrom and WithDiff rules are followed.
// Each test case represents a cell in the two tables outlined in the documentation for utxoDiff. // Each test case represents a cell in the two tables outlined in the documentation for utxoDiff.
func TestUTXODiffRules(t *testing.T) { func TestUTXODiffRules(t *testing.T) {
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
outPoint0 := *wire.NewOutPoint(hash0, 0) outPoint0 := *wire.NewOutPoint(txID0, 0)
utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0) utxoEntry0 := NewUTXOEntry(&wire.TxOut{PkScript: []byte{}, Value: 10}, true, 0)
// For each of the following test cases, we will: // For each of the following test cases, we will:
@ -327,10 +327,10 @@ func TestUTXODiffRules(t *testing.T) {
// TestFullUTXOSet makes sure that fullUTXOSet is working as expected. // TestFullUTXOSet makes sure that fullUTXOSet is working as expected.
func TestFullUTXOSet(t *testing.T) { func TestFullUTXOSet(t *testing.T) {
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
hash1, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111") txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outPoint0 := *wire.NewOutPoint(hash0, 0) outPoint0 := *wire.NewOutPoint(txID0, 0)
outPoint1 := *wire.NewOutPoint(hash1, 0) outPoint1 := *wire.NewOutPoint(txID1, 0)
txOut0 := &wire.TxOut{PkScript: []byte{}, Value: 10} txOut0 := &wire.TxOut{PkScript: []byte{}, Value: 10}
txOut1 := &wire.TxOut{PkScript: []byte{}, Value: 20} txOut1 := &wire.TxOut{PkScript: []byte{}, Value: 20}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0) utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
@ -360,7 +360,7 @@ func TestFullUTXOSet(t *testing.T) {
} }
// Test fullUTXOSet addTx // Test fullUTXOSet addTx
txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *hash0, Index: 0}, Sequence: 0} txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *txID0, Index: 0}, Sequence: 0}
transaction0 := wire.NewMsgTx(1) transaction0 := wire.NewMsgTx(1)
transaction0.TxIn = []*wire.TxIn{txIn0} transaction0.TxIn = []*wire.TxIn{txIn0}
transaction0.TxOut = []*wire.TxOut{txOut0} transaction0.TxOut = []*wire.TxOut{txOut0}
@ -389,10 +389,10 @@ func TestFullUTXOSet(t *testing.T) {
// TestDiffUTXOSet makes sure that diffUTXOSet is working as expected. // TestDiffUTXOSet makes sure that diffUTXOSet is working as expected.
func TestDiffUTXOSet(t *testing.T) { func TestDiffUTXOSet(t *testing.T) {
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
hash1, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111") txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
outPoint0 := *wire.NewOutPoint(hash0, 0) outPoint0 := *wire.NewOutPoint(txID0, 0)
outPoint1 := *wire.NewOutPoint(hash1, 0) outPoint1 := *wire.NewOutPoint(txID1, 0)
txOut0 := &wire.TxOut{PkScript: []byte{}, Value: 10} txOut0 := &wire.TxOut{PkScript: []byte{}, Value: 10}
txOut1 := &wire.TxOut{PkScript: []byte{}, Value: 20} txOut1 := &wire.TxOut{PkScript: []byte{}, Value: 20}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0) utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
@ -634,8 +634,8 @@ func TestUTXOSetDiffRules(t *testing.T) {
// TestDiffUTXOSet_addTx makes sure that diffUTXOSet addTx works as expected // TestDiffUTXOSet_addTx makes sure that diffUTXOSet addTx works as expected
func TestDiffUTXOSet_addTx(t *testing.T) { func TestDiffUTXOSet_addTx(t *testing.T) {
// transaction0 is coinbase. As such, it has exactly one input with hash zero and MaxUInt32 index // transaction0 is coinbase. As such, it has exactly one input with hash zero and MaxUInt32 index
hash0, _ := daghash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000") txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *hash0, Index: math.MaxUint32}, Sequence: 0} txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutPoint: wire.OutPoint{TxID: *txID0, Index: math.MaxUint32}, Sequence: 0}
txOut0 := &wire.TxOut{PkScript: []byte{0}, Value: 10} txOut0 := &wire.TxOut{PkScript: []byte{0}, Value: 10}
utxoEntry0 := NewUTXOEntry(txOut0, true, 0) utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
transaction0 := wire.NewMsgTx(1) transaction0 := wire.NewMsgTx(1)
@ -918,7 +918,7 @@ func TestDiffFromTx(t *testing.T) {
//Test that we get an error if we don't have the outpoint inside the utxo set //Test that we get an error if we don't have the outpoint inside the utxo set
invalidTx := wire.NewMsgTx(wire.TxVersion) invalidTx := wire.NewMsgTx(wire.TxVersion)
invalidTx.AddTxIn(&wire.TxIn{ invalidTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0}, PreviousOutPoint: wire.OutPoint{TxID: daghash.TxID{}, Index: 0},
SignatureScript: nil, SignatureScript: nil,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
}) })

11
blockdag/validate.go
View File

@ -49,17 +49,10 @@ const (
MaxOutputsPerBlock = wire.MaxBlockPayload / wire.MinTxOutPayload MaxOutputsPerBlock = wire.MaxBlockPayload / wire.MinTxOutPayload
) )
var (
// zeroHash is the zero value for a daghash.Hash and is defined as
// a package level variable to avoid the need to create a new instance
// every time a check is needed.
zeroHash daghash.Hash
)
// isNullOutpoint determines whether or not a previous transaction output point // isNullOutpoint determines whether or not a previous transaction output point
// is set. // is set.
func isNullOutpoint(outpoint *wire.OutPoint) bool { func isNullOutpoint(outpoint *wire.OutPoint) bool {
if outpoint.Index == math.MaxUint32 && outpoint.TxID == zeroHash { if outpoint.Index == math.MaxUint32 && outpoint.TxID == daghash.ZeroTxID {
return true return true
} }
return false return false
@ -545,7 +538,7 @@ func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) er
// Check for duplicate transactions. This check will be fairly quick // Check for duplicate transactions. This check will be fairly quick
// since the transaction IDs are already cached due to building the // since the transaction IDs are already cached due to building the
// merkle tree above. // merkle tree above.
existingTxIDs := make(map[daghash.Hash]struct{}) existingTxIDs := make(map[daghash.TxID]struct{})
for _, tx := range transactions { for _, tx := range transactions {
id := tx.ID() id := tx.ID()
if _, exists := existingTxIDs[*id]; exists { if _, exists := existingTxIDs[*id]; exists {

26
blockdag/validate_test.go
View File

@ -234,7 +234,7 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -261,7 +261,7 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -331,7 +331,7 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -400,7 +400,7 @@ func TestCheckBlockSanity(t *testing.T) {
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
@ -471,7 +471,7 @@ func TestCheckBlockSanity(t *testing.T) {
// and handled properly. // and handled properly.
func TestCheckSerializedHeight(t *testing.T) { func TestCheckSerializedHeight(t *testing.T) {
// Create an empty coinbase template to be used in the tests below. // Create an empty coinbase template to be used in the tests below.
coinbaseOutpoint := wire.NewOutPoint(&daghash.Hash{}, math.MaxUint32) coinbaseOutpoint := wire.NewOutPoint(&daghash.TxID{}, math.MaxUint32)
coinbaseTx := wire.NewMsgTx(1) coinbaseTx := wire.NewMsgTx(1)
coinbaseTx.AddTxIn(wire.NewTxIn(coinbaseOutpoint, nil)) coinbaseTx.AddTxIn(wire.NewTxIn(coinbaseOutpoint, nil))
@ -676,7 +676,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -703,7 +703,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -773,7 +773,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -842,7 +842,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
@ -931,7 +931,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -965,7 +965,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -1035,7 +1035,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -1104,7 +1104,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,

2
btcjson/dagsvrwscmds.go
View File

@ -100,7 +100,7 @@ func NewNotifyReceivedCmd(addresses []string) *NotifyReceivedCmd {
// OutPoint describes a transaction outpoint that will be marshalled to and // OutPoint describes a transaction outpoint that will be marshalled to and
// from JSON. // from JSON.
type OutPoint struct { type OutPoint struct {
Hash string `json:"hash"` TxID string `json:"txid"`
Index uint32 `json:"index"` Index uint32 `json:"index"`
} }

24
btcjson/dagsvrwscmds_test.go
View File

@ -143,49 +143,49 @@ func TestDAGSvrWsCmds(t *testing.T) {
{ {
name: "notifySpent", name: "notifySpent",
newCmd: func() (interface{}, error) { newCmd: func() (interface{}, error) {
return btcjson.NewCmd("notifySpent", `[{"hash":"123","index":0}]`) return btcjson.NewCmd("notifySpent", `[{"txid":"123","index":0}]`)
}, },
staticCmd: func() interface{} { staticCmd: func() interface{} {
ops := []btcjson.OutPoint{{Hash: "123", Index: 0}} ops := []btcjson.OutPoint{{TxID: "123", Index: 0}}
return btcjson.NewNotifySpentCmd(ops) return btcjson.NewNotifySpentCmd(ops)
}, },
marshalled: `{"jsonrpc":"1.0","method":"notifySpent","params":[[{"hash":"123","index":0}]],"id":1}`, marshalled: `{"jsonrpc":"1.0","method":"notifySpent","params":[[{"txid":"123","index":0}]],"id":1}`,
unmarshalled: &btcjson.NotifySpentCmd{ unmarshalled: &btcjson.NotifySpentCmd{
OutPoints: []btcjson.OutPoint{{Hash: "123", Index: 0}}, OutPoints: []btcjson.OutPoint{{TxID: "123", Index: 0}},
}, },
}, },
{ {
name: "stopNotifySpent", name: "stopNotifySpent",
newCmd: func() (interface{}, error) { newCmd: func() (interface{}, error) {
return btcjson.NewCmd("stopNotifySpent", `[{"hash":"123","index":0}]`) return btcjson.NewCmd("stopNotifySpent", `[{"txid":"123","index":0}]`)
}, },
staticCmd: func() interface{} { staticCmd: func() interface{} {
ops := []btcjson.OutPoint{{Hash: "123", Index: 0}} ops := []btcjson.OutPoint{{TxID: "123", Index: 0}}
return btcjson.NewStopNotifySpentCmd(ops) return btcjson.NewStopNotifySpentCmd(ops)
}, },
marshalled: `{"jsonrpc":"1.0","method":"stopNotifySpent","params":[[{"hash":"123","index":0}]],"id":1}`, marshalled: `{"jsonrpc":"1.0","method":"stopNotifySpent","params":[[{"txid":"123","index":0}]],"id":1}`,
unmarshalled: &btcjson.StopNotifySpentCmd{ unmarshalled: &btcjson.StopNotifySpentCmd{
OutPoints: []btcjson.OutPoint{{Hash: "123", Index: 0}}, OutPoints: []btcjson.OutPoint{{TxID: "123", Index: 0}},
}, },
}, },
{ {
name: "loadTxFilter", name: "loadTxFilter",
newCmd: func() (interface{}, error) { newCmd: func() (interface{}, error) {
return btcjson.NewCmd("loadTxFilter", false, `["1Address"]`, `[{"hash":"0000000000000000000000000000000000000000000000000000000000000123","index":0}]`) return btcjson.NewCmd("loadTxFilter", false, `["1Address"]`, `[{"txid":"0000000000000000000000000000000000000000000000000000000000000123","index":0}]`)
}, },
staticCmd: func() interface{} { staticCmd: func() interface{} {
addrs := []string{"1Address"} addrs := []string{"1Address"}
ops := []btcjson.OutPoint{{ ops := []btcjson.OutPoint{{
Hash: "0000000000000000000000000000000000000000000000000000000000000123", TxID: "0000000000000000000000000000000000000000000000000000000000000123",
Index: 0, Index: 0,
}} }}
return btcjson.NewLoadTxFilterCmd(false, addrs, ops) return btcjson.NewLoadTxFilterCmd(false, addrs, ops)
}, },
marshalled: `{"jsonrpc":"1.0","method":"loadTxFilter","params":[false,["1Address"],[{"hash":"0000000000000000000000000000000000000000000000000000000000000123","index":0}]],"id":1}`, marshalled: `{"jsonrpc":"1.0","method":"loadTxFilter","params":[false,["1Address"],[{"txid":"0000000000000000000000000000000000000000000000000000000000000123","index":0}]],"id":1}`,
unmarshalled: &btcjson.LoadTxFilterCmd{ unmarshalled: &btcjson.LoadTxFilterCmd{
Reload: false, Reload: false,
Addresses: []string{"1Address"}, Addresses: []string{"1Address"},
OutPoints: []btcjson.OutPoint{{Hash: "0000000000000000000000000000000000000000000000000000000000000123", Index: 0}}, OutPoints: []btcjson.OutPoint{{TxID: "0000000000000000000000000000000000000000000000000000000000000123", Index: 0}},
}, },
}, },
{ {

52
dagconfig/daghash/hash.go
View File

@ -27,6 +27,9 @@ var ErrHashStrSize = fmt.Errorf("max hash string length is %v bytes", MaxHashStr
// typically represents the double sha256 of data. // typically represents the double sha256 of data.
type Hash [HashSize]byte type Hash [HashSize]byte
// TxID is transaction hash not including payload and signature.
type TxID Hash
// String returns the Hash as the hexadecimal string of the byte-reversed // String returns the Hash as the hexadecimal string of the byte-reversed
// hash. // hash.
func (hash Hash) String() string { func (hash Hash) String() string {
@ -36,6 +39,12 @@ func (hash Hash) String() string {
return hex.EncodeToString(hash[:]) return hex.EncodeToString(hash[:])
} }
// String returns the TxId as the hexadecimal string of the byte-reversed
// hash.
func (txID TxID) String() string {
return Hash(txID).String()
}
// Strings returns a slice of strings representing the hashes in the given slice of hashes // Strings returns a slice of strings representing the hashes in the given slice of hashes
func Strings(hashes []Hash) []string { func Strings(hashes []Hash) []string {
strings := make([]string, len(hashes)) strings := make([]string, len(hashes))
@ -58,6 +67,15 @@ func (hash *Hash) CloneBytes() []byte {
return newHash return newHash
} }
// CloneBytes returns a copy of the bytes which represent the TxID as a byte
// slice.
//
// NOTE: It is generally cheaper to just slice the hash directly thereby reusing
// the same bytes rather than calling this method.
func (txID *TxID) CloneBytes() []byte {
return (*Hash)(txID).CloneBytes()
}
// SetBytes sets the bytes which represent the hash. An error is returned if // SetBytes sets the bytes which represent the hash. An error is returned if
// the number of bytes passed in is not HashSize. // the number of bytes passed in is not HashSize.
func (hash *Hash) SetBytes(newHash []byte) error { func (hash *Hash) SetBytes(newHash []byte) error {
@ -71,6 +89,12 @@ func (hash *Hash) SetBytes(newHash []byte) error {
return nil return nil
} }
// SetBytes sets the bytes which represent the TxID. An error is returned if
// the number of bytes passed in is not HashSize.
func (txID *TxID) SetBytes(newID []byte) error {
return (*Hash)(txID).SetBytes(newID)
}
// IsEqual returns true if target is the same as hash. // IsEqual returns true if target is the same as hash.
func (hash *Hash) IsEqual(target *Hash) bool { func (hash *Hash) IsEqual(target *Hash) bool {
if hash == nil && target == nil { if hash == nil && target == nil {
@ -82,6 +106,11 @@ func (hash *Hash) IsEqual(target *Hash) bool {
return *hash == *target return *hash == *target
} }
// IsEqual returns true if target is the same as TxID.
func (txID *TxID) IsEqual(target *TxID) bool {
return (*Hash)(txID).IsEqual((*Hash)(target))
}
// AreEqual returns true if both slices contain the same hashes. // AreEqual returns true if both slices contain the same hashes.
// Either slice must not contain duplicates. // Either slice must not contain duplicates.
func AreEqual(first []Hash, second []Hash) bool { func AreEqual(first []Hash, second []Hash) bool {
@ -109,6 +138,13 @@ func NewHash(newHash []byte) (*Hash, error) {
return &sh, err return &sh, err
} }
// NewTxID returns a new TxID from a byte slice. An error is returned if
// the number of bytes passed in is not HashSize.
func NewTxID(newTxID []byte) (*TxID, error) {
hash, err := NewHash(newTxID)
return (*TxID)(hash), err
}
// NewHashFromStr creates a Hash from a hash string. The string should be // NewHashFromStr creates a Hash from a hash string. The string should be
// the hexadecimal string of a byte-reversed hash, but any missing characters // the hexadecimal string of a byte-reversed hash, but any missing characters
// result in zero padding at the end of the Hash. // result in zero padding at the end of the Hash.
@ -121,6 +157,14 @@ func NewHashFromStr(hash string) (*Hash, error) {
return ret, nil return ret, nil
} }
// NewTxIDFromStr creates a TxID from a hash string. The string should be
// the hexadecimal string of a byte-reversed hash, but any missing characters
// result in zero padding at the end of the Hash.
func NewTxIDFromStr(idStr string) (*TxID, error) {
hash, err := NewHashFromStr(idStr)
return (*TxID)(hash), err
}
// Decode decodes the byte-reversed hexadecimal string encoding of a Hash to a // Decode decodes the byte-reversed hexadecimal string encoding of a Hash to a
// destination. // destination.
func Decode(dst *Hash, src string) error { func Decode(dst *Hash, src string) error {
@ -197,6 +241,10 @@ func Sort(hashes []Hash) {
}) })
} }
// Zero is the Hash value of all zero bytes, defined here for // ZeroHash is the Hash value of all zero bytes, defined here for
// convenience. // convenience.
var Zero Hash var ZeroHash Hash
// ZeroTxID is the Hash value of all zero bytes, defined here for
// convenience.
var ZeroTxID TxID

2
dagconfig/genesis.go
View File

@ -19,7 +19,7 @@ var genesisCoinbaseTx = wire.MsgTx{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

5
database/cmd/dbtool/insecureimport.go
View File

@ -12,7 +12,6 @@ import (
"sync" "sync"
"time" "time"
"github.com/daglabs/btcd/dagconfig/daghash"
"github.com/daglabs/btcd/database" "github.com/daglabs/btcd/database"
"github.com/daglabs/btcd/util" "github.com/daglabs/btcd/util"
"github.com/daglabs/btcd/wire" "github.com/daglabs/btcd/wire"
@ -30,10 +29,6 @@ var (
InFile: "bootstrap.dat", InFile: "bootstrap.dat",
Progress: 10, Progress: 10,
} }
// zeroHash is a simply a hash with all zeros. It is defined here to
// avoid creating it multiple times.
zeroHash = daghash.Hash{}
) )
// importResults houses the stats and result as an import operation. // importResults houses the stats and result as an import operation.

2
integration/rpctest/blockgen.go
View File

@ -109,7 +109,7 @@ func createCoinbaseTx(coinbaseScript []byte, nextBlockHeight int32,
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
// Coinbase transactions have no inputs, so previous outpoint is // Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index. // zero hash and max index.
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{},
wire.MaxPrevOutIndex), wire.MaxPrevOutIndex),
SignatureScript: coinbaseScript, SignatureScript: coinbaseScript,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,

4
integration/rpctest/memwallet.go
View File

@ -246,7 +246,7 @@ func (m *memWallet) chainSyncer() {
// evalOutputs evaluates each of the passed outputs, creating a new matching // evalOutputs evaluates each of the passed outputs, creating a new matching
// utxo within the wallet if we're able to spend the output. // utxo within the wallet if we're able to spend the output.
func (m *memWallet) evalOutputs(outputs []*wire.TxOut, txHash *daghash.Hash, func (m *memWallet) evalOutputs(outputs []*wire.TxOut, txID *daghash.TxID,
isCoinbase bool, undo *undoEntry) { isCoinbase bool, undo *undoEntry) {
for i, output := range outputs { for i, output := range outputs {
@ -268,7 +268,7 @@ func (m *memWallet) evalOutputs(outputs []*wire.TxOut, txHash *daghash.Hash,
maturityHeight = m.currentHeight + int32(m.net.CoinbaseMaturity) maturityHeight = m.currentHeight + int32(m.net.CoinbaseMaturity)
} }
op := wire.OutPoint{TxID: *txHash, Index: uint32(i)} op := wire.OutPoint{TxID: *txID, Index: uint32(i)}
m.utxos[op] = &utxo{ m.utxos[op] = &utxo{
value: util.Amount(output.Value), value: util.Amount(output.Value),
keyIndex: keyIndex, keyIndex: keyIndex,

32
mempool/estimatefee.go
View File

@ -93,8 +93,8 @@ func NewSatoshiPerByte(fee util.Amount, size uint32) SatoshiPerByte {
// observedTransaction represents an observed transaction and some // observedTransaction represents an observed transaction and some
// additional data required for the fee estimation algorithm. // additional data required for the fee estimation algorithm.
type observedTransaction struct { type observedTransaction struct {
// A transaction hash. // A transaction ID.
hash daghash.Hash id daghash.TxID
// The fee per byte of the transaction in satoshis. // The fee per byte of the transaction in satoshis.
feeRate SatoshiPerByte feeRate SatoshiPerByte
@ -108,7 +108,7 @@ type observedTransaction struct {
} }
func (o *observedTransaction) Serialize(w io.Writer) { func (o *observedTransaction) Serialize(w io.Writer) {
binary.Write(w, binary.BigEndian, o.hash) binary.Write(w, binary.BigEndian, o.id)
binary.Write(w, binary.BigEndian, o.feeRate) binary.Write(w, binary.BigEndian, o.feeRate)
binary.Write(w, binary.BigEndian, o.observed) binary.Write(w, binary.BigEndian, o.observed)
binary.Write(w, binary.BigEndian, o.mined) binary.Write(w, binary.BigEndian, o.mined)
@ -118,7 +118,7 @@ func deserializeObservedTransaction(r io.Reader) (*observedTransaction, error) {
ot := observedTransaction{} ot := observedTransaction{}
// The first 32 bytes should be a hash. // The first 32 bytes should be a hash.
binary.Read(r, binary.BigEndian, &ot.hash) binary.Read(r, binary.BigEndian, &ot.id)
// The next 8 are SatoshiPerByte // The next 8 are SatoshiPerByte
binary.Read(r, binary.BigEndian, &ot.feeRate) binary.Read(r, binary.BigEndian, &ot.feeRate)
@ -169,7 +169,7 @@ type FeeEstimator struct {
numBlocksRegistered uint32 numBlocksRegistered uint32
mtx sync.RWMutex mtx sync.RWMutex
observed map[daghash.Hash]*observedTransaction observed map[daghash.TxID]*observedTransaction
bin [estimateFeeDepth][]*observedTransaction bin [estimateFeeDepth][]*observedTransaction
// The cached estimates. // The cached estimates.
@ -190,7 +190,7 @@ func NewFeeEstimator(maxRollback, minRegisteredBlocks uint32) *FeeEstimator {
lastKnownHeight: mining.UnminedHeight, lastKnownHeight: mining.UnminedHeight,
binSize: estimateFeeBinSize, binSize: estimateFeeBinSize,
maxReplacements: estimateFeeMaxReplacements, maxReplacements: estimateFeeMaxReplacements,
observed: make(map[daghash.Hash]*observedTransaction), observed: make(map[daghash.TxID]*observedTransaction),
dropped: make([]*registeredBlock, 0, maxRollback), dropped: make([]*registeredBlock, 0, maxRollback),
} }
} }
@ -206,12 +206,12 @@ func (ef *FeeEstimator) ObserveTransaction(t *TxDesc) {
return return
} }
hash := *t.Tx.ID() txID := *t.Tx.ID()
if _, ok := ef.observed[hash]; !ok { if _, ok := ef.observed[txID]; !ok {
size := uint32(t.Tx.MsgTx().SerializeSize()) size := uint32(t.Tx.MsgTx().SerializeSize())
ef.observed[hash] = &observedTransaction{ ef.observed[txID] = &observedTransaction{
hash: hash, id: txID,
feeRate: NewSatoshiPerByte(util.Amount(t.Fee), size), feeRate: NewSatoshiPerByte(util.Amount(t.Fee), size),
observed: t.Height, observed: t.Height,
mined: mining.UnminedHeight, mined: mining.UnminedHeight,
@ -255,10 +255,10 @@ func (ef *FeeEstimator) RegisterBlock(block *util.Block) error {
// Go through the txs in the block. // Go through the txs in the block.
for t := range transactions { for t := range transactions {
hash := *t.Hash() txID := *t.ID()
// Have we observed this tx in the mempool? // Have we observed this tx in the mempool?
o, ok := ef.observed[hash] o, ok := ef.observed[txID]
if !ok { if !ok {
continue continue
} }
@ -269,7 +269,7 @@ func (ef *FeeEstimator) RegisterBlock(block *util.Block) error {
// This shouldn't happen if the fee estimator works correctly, // This shouldn't happen if the fee estimator works correctly,
// but return an error if it does. // but return an error if it does.
if o.mined != mining.UnminedHeight { if o.mined != mining.UnminedHeight {
log.Error("Estimate fee: transaction ", hash.String(), " has already been mined") log.Error("Estimate fee: transaction ", txID.String(), " has already been mined")
return errors.New("Transaction has already been mined") return errors.New("Transaction has already been mined")
} }
@ -610,7 +610,7 @@ type observedTxSet []*observedTransaction
func (q observedTxSet) Len() int { return len(q) } func (q observedTxSet) Len() int { return len(q) }
func (q observedTxSet) Less(i, j int) bool { func (q observedTxSet) Less(i, j int) bool {
return strings.Compare(q[i].hash.String(), q[j].hash.String()) < 0 return strings.Compare(q[i].id.String(), q[j].id.String()) < 0
} }
func (q observedTxSet) Swap(i, j int) { func (q observedTxSet) Swap(i, j int) {
@ -691,7 +691,7 @@ func RestoreFeeEstimator(data FeeEstimatorState) (*FeeEstimator, error) {
} }
ef := &FeeEstimator{ ef := &FeeEstimator{
observed: make(map[daghash.Hash]*observedTransaction), observed: make(map[daghash.TxID]*observedTransaction),
} }
// Read basic parameters. // Read basic parameters.
@ -712,7 +712,7 @@ func RestoreFeeEstimator(data FeeEstimatorState) (*FeeEstimator, error) {
return nil, err return nil, err
} }
observed[i] = ot observed[i] = ot
ef.observed[ot.hash] = ot ef.observed[ot.id] = ot
} }
// Read bins. // Read bins.

2
mempool/estimatefee_test.go
View File

@ -24,7 +24,7 @@ func newTestFeeEstimator(binSize, maxReplacements, maxRollback uint32) *FeeEstim
binSize: int32(binSize), binSize: int32(binSize),
minRegisteredBlocks: 0, minRegisteredBlocks: 0,
maxReplacements: int32(maxReplacements), maxReplacements: int32(maxReplacements),
observed: make(map[daghash.Hash]*observedTransaction), observed: make(map[daghash.TxID]*observedTransaction),
dropped: make([]*registeredBlock, 0, maxRollback), dropped: make([]*registeredBlock, 0, maxRollback),
} }
} }

54
mempool/mempool.go
View File

@ -172,11 +172,11 @@ type TxPool struct {
mtx sync.RWMutex mtx sync.RWMutex
cfg Config cfg Config
pool map[daghash.Hash]*TxDesc pool map[daghash.TxID]*TxDesc
depends map[daghash.Hash]*TxDesc depends map[daghash.TxID]*TxDesc
dependsByPrev map[wire.OutPoint]map[daghash.Hash]*TxDesc dependsByPrev map[wire.OutPoint]map[daghash.TxID]*TxDesc
orphans map[daghash.Hash]*orphanTx orphans map[daghash.TxID]*orphanTx
orphansByPrev map[wire.OutPoint]map[daghash.Hash]*util.Tx orphansByPrev map[wire.OutPoint]map[daghash.TxID]*util.Tx
outpoints map[wire.OutPoint]*util.Tx outpoints map[wire.OutPoint]*util.Tx
pennyTotal float64 // exponentially decaying total for penny spends. pennyTotal float64 // exponentially decaying total for penny spends.
lastPennyUnix int64 // unix time of last ``penny spend'' lastPennyUnix int64 // unix time of last ``penny spend''
@ -336,7 +336,7 @@ func (mp *TxPool) addOrphan(tx *util.Tx, tag Tag) {
for _, txIn := range tx.MsgTx().TxIn { for _, txIn := range tx.MsgTx().TxIn {
if _, exists := mp.orphansByPrev[txIn.PreviousOutPoint]; !exists { if _, exists := mp.orphansByPrev[txIn.PreviousOutPoint]; !exists {
mp.orphansByPrev[txIn.PreviousOutPoint] = mp.orphansByPrev[txIn.PreviousOutPoint] =
make(map[daghash.Hash]*util.Tx) make(map[daghash.TxID]*util.Tx)
} }
mp.orphansByPrev[txIn.PreviousOutPoint][*tx.ID()] = tx mp.orphansByPrev[txIn.PreviousOutPoint][*tx.ID()] = tx
} }
@ -393,7 +393,7 @@ func (mp *TxPool) removeOrphanDoubleSpends(tx *util.Tx) {
// exists in the main pool. // exists in the main pool.
// //
// This function MUST be called with the mempool lock held (for reads). // This function MUST be called with the mempool lock held (for reads).
func (mp *TxPool) isTransactionInPool(hash *daghash.Hash) bool { func (mp *TxPool) isTransactionInPool(hash *daghash.TxID) bool {
if _, exists := mp.pool[*hash]; exists { if _, exists := mp.pool[*hash]; exists {
return true return true
} }
@ -404,7 +404,7 @@ func (mp *TxPool) isTransactionInPool(hash *daghash.Hash) bool {
// exists in the main pool. // exists in the main pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) IsTransactionInPool(hash *daghash.Hash) bool { func (mp *TxPool) IsTransactionInPool(hash *daghash.TxID) bool {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
inPool := mp.isTransactionInPool(hash) inPool := mp.isTransactionInPool(hash)
@ -417,7 +417,7 @@ func (mp *TxPool) IsTransactionInPool(hash *daghash.Hash) bool {
// exists in the depend pool. // exists in the depend pool.
// //
// This function MUST be called with the mempool lock held (for reads). // This function MUST be called with the mempool lock held (for reads).
func (mp *TxPool) isInDependPool(hash *daghash.Hash) bool { func (mp *TxPool) isInDependPool(hash *daghash.TxID) bool {
if _, exists := mp.depends[*hash]; exists { if _, exists := mp.depends[*hash]; exists {
return true return true
} }
@ -429,7 +429,7 @@ func (mp *TxPool) isInDependPool(hash *daghash.Hash) bool {
// exists in the main pool. // exists in the main pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) IsInDependPool(hash *daghash.Hash) bool { func (mp *TxPool) IsInDependPool(hash *daghash.TxID) bool {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
@ -440,7 +440,7 @@ func (mp *TxPool) IsInDependPool(hash *daghash.Hash) bool {
// in the orphan pool. // in the orphan pool.
// //
// This function MUST be called with the mempool lock held (for reads). // This function MUST be called with the mempool lock held (for reads).
func (mp *TxPool) isOrphanInPool(hash *daghash.Hash) bool { func (mp *TxPool) isOrphanInPool(hash *daghash.TxID) bool {
if _, exists := mp.orphans[*hash]; exists { if _, exists := mp.orphans[*hash]; exists {
return true return true
} }
@ -452,7 +452,7 @@ func (mp *TxPool) isOrphanInPool(hash *daghash.Hash) bool {
// in the orphan pool. // in the orphan pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) IsOrphanInPool(hash *daghash.Hash) bool { func (mp *TxPool) IsOrphanInPool(hash *daghash.TxID) bool {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
inPool := mp.isOrphanInPool(hash) inPool := mp.isOrphanInPool(hash)
@ -465,7 +465,7 @@ func (mp *TxPool) IsOrphanInPool(hash *daghash.Hash) bool {
// in the main pool or in the orphan pool. // in the main pool or in the orphan pool.
// //
// This function MUST be called with the mempool lock held (for reads). // This function MUST be called with the mempool lock held (for reads).
func (mp *TxPool) haveTransaction(hash *daghash.Hash) bool { func (mp *TxPool) haveTransaction(hash *daghash.TxID) bool {
return mp.isTransactionInPool(hash) || mp.isOrphanInPool(hash) return mp.isTransactionInPool(hash) || mp.isOrphanInPool(hash)
} }
@ -473,7 +473,7 @@ func (mp *TxPool) haveTransaction(hash *daghash.Hash) bool {
// in the main pool or in the orphan pool. // in the main pool or in the orphan pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) HaveTransaction(hash *daghash.Hash) bool { func (mp *TxPool) HaveTransaction(hash *daghash.TxID) bool {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
haveTx := mp.haveTransaction(hash) haveTx := mp.haveTransaction(hash)
@ -628,7 +628,7 @@ func (mp *TxPool) addTransaction(tx *util.Tx, height int32, fee uint64, parentsI
mp.depends[*tx.ID()] = txD mp.depends[*tx.ID()] = txD
for _, previousOutPoint := range parentsInPool { for _, previousOutPoint := range parentsInPool {
if _, exists := mp.dependsByPrev[*previousOutPoint]; !exists { if _, exists := mp.dependsByPrev[*previousOutPoint]; !exists {
mp.dependsByPrev[*previousOutPoint] = make(map[daghash.Hash]*TxDesc) mp.dependsByPrev[*previousOutPoint] = make(map[daghash.TxID]*TxDesc)
} }
mp.dependsByPrev[*previousOutPoint][*tx.ID()] = txD mp.dependsByPrev[*previousOutPoint][*tx.ID()] = txD
} }
@ -685,7 +685,7 @@ func (mp *TxPool) CheckSpend(op wire.OutPoint) *util.Tx {
} }
// This function MUST be called with the mempool lock held (for reads). // This function MUST be called with the mempool lock held (for reads).
func (mp *TxPool) fetchTransaction(txID *daghash.Hash) (*TxDesc, bool) { func (mp *TxPool) fetchTransaction(txID *daghash.TxID) (*TxDesc, bool) {
txDesc, exists := mp.pool[*txID] txDesc, exists := mp.pool[*txID]
if !exists { if !exists {
txDesc, exists = mp.depends[*txID] txDesc, exists = mp.depends[*txID]
@ -698,7 +698,7 @@ func (mp *TxPool) fetchTransaction(txID *daghash.Hash) (*TxDesc, bool) {
// orphans. // orphans.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) FetchTransaction(txID *daghash.Hash) (*util.Tx, error) { func (mp *TxPool) FetchTransaction(txID *daghash.TxID) (*util.Tx, error) {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.RLock() mp.mtx.RLock()
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
@ -715,7 +715,7 @@ func (mp *TxPool) FetchTransaction(txID *daghash.Hash) (*util.Tx, error) {
// more details. // more details.
// //
// This function MUST be called with the mempool lock held (for writes). // This function MUST be called with the mempool lock held (for writes).
func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDupOrphans bool) ([]*daghash.Hash, *TxDesc, error) { func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDupOrphans bool) ([]*daghash.TxID, *TxDesc, error) {
mp.cfg.DAG.UTXORLock() mp.cfg.DAG.UTXORLock()
defer mp.cfg.DAG.UTXORUnlock() defer mp.cfg.DAG.UTXORUnlock()
txID := tx.ID() txID := tx.ID()
@ -830,7 +830,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// don't exist or are already spent. Adding orphans to the orphan pool // don't exist or are already spent. Adding orphans to the orphan pool
// is not handled by this function, and the caller should use // is not handled by this function, and the caller should use
// maybeAddOrphan if this behavior is desired. // maybeAddOrphan if this behavior is desired.
var missingParents []*daghash.Hash var missingParents []*daghash.TxID
var parentsInPool []*wire.OutPoint var parentsInPool []*wire.OutPoint
for _, txIn := range tx.MsgTx().TxIn { for _, txIn := range tx.MsgTx().TxIn {
if _, ok := mp.mpUTXOSet.Get(txIn.PreviousOutPoint); !ok { if _, ok := mp.mpUTXOSet.Get(txIn.PreviousOutPoint); !ok {
@ -1009,7 +1009,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *util.Tx, isNew, rateLimit, rejectDu
// be added to the orphan pool. // be added to the orphan pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) MaybeAcceptTransaction(tx *util.Tx, isNew, rateLimit bool) ([]*daghash.Hash, *TxDesc, error) { func (mp *TxPool) MaybeAcceptTransaction(tx *util.Tx, isNew, rateLimit bool) ([]*daghash.TxID, *TxDesc, error) {
// Protect concurrent access. // Protect concurrent access.
mp.mtx.Lock() mp.mtx.Lock()
hashes, txD, err := mp.maybeAcceptTransaction(tx, isNew, rateLimit, true) hashes, txD, err := mp.maybeAcceptTransaction(tx, isNew, rateLimit, true)
@ -1209,9 +1209,9 @@ func (mp *TxPool) DepCount() int {
// pool. // pool.
// //
// This function is safe for concurrent access. // This function is safe for concurrent access.
func (mp *TxPool) TxIDs() []*daghash.Hash { func (mp *TxPool) TxIDs() []*daghash.TxID {
mp.mtx.RLock() mp.mtx.RLock()
ids := make([]*daghash.Hash, len(mp.pool)) ids := make([]*daghash.TxID, len(mp.pool))
i := 0 i := 0
for txID := range mp.pool { for txID := range mp.pool {
idCopy := txID idCopy := txID
@ -1348,11 +1348,11 @@ func New(cfg *Config) *TxPool {
mpUTXO := blockdag.NewDiffUTXOSet(virtualUTXO, blockdag.NewUTXODiff()) mpUTXO := blockdag.NewDiffUTXOSet(virtualUTXO, blockdag.NewUTXODiff())
return &TxPool{ return &TxPool{
cfg: *cfg, cfg: *cfg,
pool: make(map[daghash.Hash]*TxDesc), pool: make(map[daghash.TxID]*TxDesc),
depends: make(map[daghash.Hash]*TxDesc), depends: make(map[daghash.TxID]*TxDesc),
dependsByPrev: make(map[wire.OutPoint]map[daghash.Hash]*TxDesc), dependsByPrev: make(map[wire.OutPoint]map[daghash.TxID]*TxDesc),
orphans: make(map[daghash.Hash]*orphanTx), orphans: make(map[daghash.TxID]*orphanTx),
orphansByPrev: make(map[wire.OutPoint]map[daghash.Hash]*util.Tx), orphansByPrev: make(map[wire.OutPoint]map[daghash.TxID]*util.Tx),
nextExpireScan: time.Now().Add(orphanExpireScanInterval), nextExpireScan: time.Now().Add(orphanExpireScanInterval),
outpoints: make(map[wire.OutPoint]*util.Tx), outpoints: make(map[wire.OutPoint]*util.Tx),
mpUTXOSet: mpUTXO, mpUTXOSet: mpUTXO,

32
mempool/mempool_test.go
View File

@ -133,7 +133,7 @@ func (p *poolHarness) CreateCoinbaseTx(blockHeight int32, numOutputs uint32) (*u
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
// Coinbase transactions have no inputs, so previous outpoint is // Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index. // zero hash and max index.
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{},
wire.MaxPrevOutIndex), wire.MaxPrevOutIndex),
SignatureScript: coinbaseScript, SignatureScript: coinbaseScript,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,
@ -484,7 +484,7 @@ func TestProcessTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.TxID{}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -594,7 +594,7 @@ func TestProcessTransaction(t *testing.T) {
t.Fatalf("Script: error creating wrappedP2shNonSigScript: %v", err) t.Fatalf("Script: error creating wrappedP2shNonSigScript: %v", err)
} }
dummyPrevOutHash, err := daghash.NewHashFromStr("01") dummyPrevOutHash, err := daghash.NewTxIDFromStr("01")
if err != nil { if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err) t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
} }
@ -782,7 +782,7 @@ func TestAddrIndex(t *testing.T) {
}) })
defer guard.Unpatch() defer guard.Unpatch()
enteredRemoveUnconfirmedTx := false enteredRemoveUnconfirmedTx := false
guard = monkey.Patch((*indexers.AddrIndex).RemoveUnconfirmedTx, func(idx *indexers.AddrIndex, hash *daghash.Hash) { guard = monkey.Patch((*indexers.AddrIndex).RemoveUnconfirmedTx, func(idx *indexers.AddrIndex, hash *daghash.TxID) {
enteredRemoveUnconfirmedTx = true enteredRemoveUnconfirmedTx = true
}) })
defer guard.Unpatch() defer guard.Unpatch()
@ -897,7 +897,7 @@ func TestFetchTransaction(t *testing.T) {
orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.TxID{1}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1060,7 +1060,7 @@ func TestOrphanExpiration(t *testing.T) {
expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{ expiredTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.TxID{}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(expiredTx, true, harness.txPool.ProcessTransaction(expiredTx, true,
false, 0) false, 0)
@ -1068,7 +1068,7 @@ func TestOrphanExpiration(t *testing.T) {
tx1, err := harness.CreateSignedTx([]spendableOutpoint{{ tx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.TxID{1}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(tx1, true, harness.txPool.ProcessTransaction(tx1, true,
false, 0) false, 0)
@ -1083,7 +1083,7 @@ func TestOrphanExpiration(t *testing.T) {
tx2, err := harness.CreateSignedTx([]spendableOutpoint{{ tx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.TxID{2}, Index: 0},
}}, 1) }}, 1)
harness.txPool.ProcessTransaction(tx2, true, harness.txPool.ProcessTransaction(tx2, true,
false, 0) false, 0)
@ -1106,7 +1106,7 @@ func TestMaxOrphanTxSize(t *testing.T) {
tx, err := harness.CreateSignedTx([]spendableOutpoint{{ tx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.TxID{}, Index: 0},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1241,7 +1241,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx1, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{1}, Index: 1}, outPoint: wire.OutPoint{TxID: daghash.TxID{1}, Index: 1},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1250,7 +1250,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1) false, 1)
orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx2, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{2}, Index: 2}, outPoint: wire.OutPoint{TxID: daghash.TxID{2}, Index: 2},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1259,7 +1259,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
false, 1) false, 1)
orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx3, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{3}, Index: 3}, outPoint: wire.OutPoint{TxID: daghash.TxID{3}, Index: 3},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1269,7 +1269,7 @@ func TestRemoveOrphansByTag(t *testing.T) {
orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{ orphanedTx4, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{4}, Index: 4}, outPoint: wire.OutPoint{TxID: daghash.TxID{4}, Index: 4},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1330,7 +1330,7 @@ func TestBasicOrphanRemoval(t *testing.T) {
// and ensure the state of all other orphans are unaffected. // and ensure the state of all other orphans are unaffected.
nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{ nonChainedOrphanTx, err := harness.CreateSignedTx([]spendableOutpoint{{
amount: util.Amount(5000000000), amount: util.Amount(5000000000),
outPoint: wire.OutPoint{TxID: daghash.Hash{}, Index: 0}, outPoint: wire.OutPoint{TxID: daghash.TxID{}, Index: 0},
}}, 1) }}, 1)
if err != nil { if err != nil {
t.Fatalf("unable to create signed tx: %v", err) t.Fatalf("unable to create signed tx: %v", err)
@ -1740,7 +1740,7 @@ func TestHandleNewBlock(t *testing.T) {
}() }()
// process messages pushed by HandleNewBlock // process messages pushed by HandleNewBlock
blockTransnactions := make(map[daghash.Hash]int) blockTransnactions := make(map[daghash.TxID]int)
for msg := range ch { for msg := range ch {
blockTransnactions[*msg.Tx.ID()] = 1 blockTransnactions[*msg.Tx.ID()] = 1
if *msg.Tx.ID() != *blockTx1.ID() { if *msg.Tx.ID() != *blockTx1.ID() {
@ -1811,7 +1811,7 @@ var dummyBlock = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

4
mempool/policy_test.go
View File

@ -279,11 +279,11 @@ func TestDust(t *testing.T) {
// TestCheckTransactionStandard tests the checkTransactionStandard API. // TestCheckTransactionStandard tests the checkTransactionStandard API.
func TestCheckTransactionStandard(t *testing.T) { func TestCheckTransactionStandard(t *testing.T) {
// Create some dummy, but otherwise standard, data for transactions. // Create some dummy, but otherwise standard, data for transactions.
prevOutHash, err := daghash.NewHashFromStr("01") prevOutTxID, err := daghash.NewTxIDFromStr("01")
if err != nil { if err != nil {
t.Fatalf("NewShaHashFromStr: unexpected error: %v", err) t.Fatalf("NewShaHashFromStr: unexpected error: %v", err)
} }
dummyPrevOut := wire.OutPoint{TxID: *prevOutHash, Index: 1} dummyPrevOut := wire.OutPoint{TxID: *prevOutTxID, Index: 1}
dummySigScript := bytes.Repeat([]byte{0x00}, 65) dummySigScript := bytes.Repeat([]byte{0x00}, 65)
dummyTxIn := wire.TxIn{ dummyTxIn := wire.TxIn{
PreviousOutPoint: dummyPrevOut, PreviousOutPoint: dummyPrevOut,

4
mining/mining.go
View File

@ -70,7 +70,7 @@ type TxSource interface {
// HaveTransaction returns whether or not the passed transaction hash // HaveTransaction returns whether or not the passed transaction hash
// exists in the source pool. // exists in the source pool.
HaveTransaction(hash *daghash.Hash) bool HaveTransaction(txID *daghash.TxID) bool
} }
// txPrioItem houses a transaction along with extra information that allows the // txPrioItem houses a transaction along with extra information that allows the
@ -248,7 +248,7 @@ func createCoinbaseTx(params *dagconfig.Params, coinbaseScript []byte, nextBlock
tx.AddTxIn(&wire.TxIn{ tx.AddTxIn(&wire.TxIn{
// Coinbase transactions have no inputs, so previous outpoint is // Coinbase transactions have no inputs, so previous outpoint is
// zero hash and max index. // zero hash and max index.
PreviousOutPoint: *wire.NewOutPoint(&daghash.Hash{}, PreviousOutPoint: *wire.NewOutPoint(&daghash.TxID{},
wire.MaxPrevOutIndex), wire.MaxPrevOutIndex),
SignatureScript: coinbaseScript, SignatureScript: coinbaseScript,
Sequence: wire.MaxTxInSequenceNum, Sequence: wire.MaxTxInSequenceNum,

2
mining/policy_test.go
View File

@ -65,7 +65,7 @@ func createTxIn(originTx *wire.MsgTx, outputIndex uint32) *wire.TxIn {
prevOut = wire.NewOutPoint(&originTxID, 0) prevOut = wire.NewOutPoint(&originTxID, 0)
} else { } else {
prevOut = &wire.OutPoint{ prevOut = &wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xFFFFFFFF, Index: 0xFFFFFFFF,
} }
} }

69
netsync/manager.go
View File

@ -41,9 +41,6 @@ const (
maxRequestedTxns = wire.MaxInvPerMsg maxRequestedTxns = wire.MaxInvPerMsg
) )
// zeroHash is the zero value hash (all zeros). It is defined as a convenience.
var zeroHash daghash.Hash
// newPeerMsg signifies a newly connected peer to the block handler. // newPeerMsg signifies a newly connected peer to the block handler.
type newPeerMsg struct { type newPeerMsg struct {
peer *peerpkg.Peer peer *peerpkg.Peer
@ -135,7 +132,7 @@ type headerNode struct {
type peerSyncState struct { type peerSyncState struct {
syncCandidate bool syncCandidate bool
requestQueue []*wire.InvVect requestQueue []*wire.InvVect
requestedTxns map[daghash.Hash]struct{} requestedTxns map[daghash.TxID]struct{}
requestedBlocks map[daghash.Hash]struct{} requestedBlocks map[daghash.Hash]struct{}
} }
@ -157,8 +154,8 @@ type SyncManager struct {
quit chan struct{} quit chan struct{}
// These fields should only be accessed from the blockHandler thread // These fields should only be accessed from the blockHandler thread
rejectedTxns map[daghash.Hash]struct{} rejectedTxns map[daghash.TxID]struct{}
requestedTxns map[daghash.Hash]struct{} requestedTxns map[daghash.TxID]struct{}
requestedBlocks map[daghash.Hash]struct{} requestedBlocks map[daghash.Hash]struct{}
syncPeer *peerpkg.Peer syncPeer *peerpkg.Peer
peerStates map[*peerpkg.Peer]*peerSyncState peerStates map[*peerpkg.Peer]*peerSyncState
@ -293,7 +290,7 @@ func (sm *SyncManager) startSync() {
"%d from peer %s", sm.dag.Height()+1, "%d from peer %s", sm.dag.Height()+1,
sm.nextCheckpoint.Height, bestPeer.Addr()) //TODO: (Ori) This is probably wrong. Done only for compilation sm.nextCheckpoint.Height, bestPeer.Addr()) //TODO: (Ori) This is probably wrong. Done only for compilation
} else { } else {
bestPeer.PushGetBlocksMsg(locator, &zeroHash) bestPeer.PushGetBlocksMsg(locator, &daghash.ZeroHash)
} }
sm.syncPeer = bestPeer sm.syncPeer = bestPeer
} else { } else {
@ -346,7 +343,7 @@ func (sm *SyncManager) handleNewPeerMsg(peer *peerpkg.Peer) {
isSyncCandidate := sm.isSyncCandidate(peer) isSyncCandidate := sm.isSyncCandidate(peer)
sm.peerStates[peer] = &peerSyncState{ sm.peerStates[peer] = &peerSyncState{
syncCandidate: isSyncCandidate, syncCandidate: isSyncCandidate,
requestedTxns: make(map[daghash.Hash]struct{}), requestedTxns: make(map[daghash.TxID]struct{}),
requestedBlocks: make(map[daghash.Hash]struct{}), requestedBlocks: make(map[daghash.Hash]struct{}),
} }
@ -442,7 +439,7 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// Do not request this transaction again until a new block // Do not request this transaction again until a new block
// has been processed. // has been processed.
sm.rejectedTxns[*txID] = struct{}{} sm.rejectedTxns[*txID] = struct{}{}
sm.limitMap(sm.rejectedTxns, maxRejectedTxns) sm.limitTxIDMap(sm.rejectedTxns, maxRejectedTxns)
// When the error is a rule error, it means the transaction was // When the error is a rule error, it means the transaction was
// simply rejected as opposed to something actually going wrong, // simply rejected as opposed to something actually going wrong,
@ -459,7 +456,7 @@ func (sm *SyncManager) handleTxMsg(tmsg *txMsg) {
// Convert the error into an appropriate reject message and // Convert the error into an appropriate reject message and
// send it. // send it.
code, reason := mempool.ErrToRejectErr(err) code, reason := mempool.ErrToRejectErr(err)
peer.PushRejectMsg(wire.CmdTx, code, reason, txID, false) peer.PushRejectMsg(wire.CmdTx, code, reason, (*daghash.Hash)(txID), false)
return return
} }
@ -619,7 +616,7 @@ func (sm *SyncManager) handleBlockMsg(bmsg *blockMsg) {
blkHashUpdate = &highestTipHash blkHashUpdate = &highestTipHash
// Clear the rejected transactions. // Clear the rejected transactions.
sm.rejectedTxns = make(map[daghash.Hash]struct{}) sm.rejectedTxns = make(map[daghash.TxID]struct{})
} }
// Update the block height for this peer. But only send a message to // Update the block height for this peer. But only send a message to
@ -678,7 +675,7 @@ func (sm *SyncManager) handleBlockMsg(bmsg *blockMsg) {
sm.headerList.Init() sm.headerList.Init()
log.Infof("Reached the final checkpoint -- switching to normal mode") log.Infof("Reached the final checkpoint -- switching to normal mode")
locator := blockdag.BlockLocator([]*daghash.Hash{blockHash}) locator := blockdag.BlockLocator([]*daghash.Hash{blockHash})
err = peer.PushGetBlocksMsg(locator, &zeroHash) err = peer.PushGetBlocksMsg(locator, &daghash.ZeroHash)
if err != nil { if err != nil {
log.Warnf("Failed to send getblocks message to peer %s: %v", log.Warnf("Failed to send getblocks message to peer %s: %v",
peer.Addr(), err) peer.Addr(), err)
@ -856,7 +853,7 @@ func (sm *SyncManager) haveInventory(invVect *wire.InvVect) (bool, error) {
case wire.InvTypeTx: case wire.InvTypeTx:
// Ask the transaction memory pool if the transaction is known // Ask the transaction memory pool if the transaction is known
// to it in any form (main pool or orphan). // to it in any form (main pool or orphan).
if sm.txMemPool.HaveTransaction(&invVect.Hash) { if sm.txMemPool.HaveTransaction((*daghash.TxID)(&invVect.Hash)) {
return true, nil return true, nil
} }
@ -868,7 +865,7 @@ func (sm *SyncManager) haveInventory(invVect *wire.InvVect) (bool, error) {
// checked because the vast majority of transactions consist of // checked because the vast majority of transactions consist of
// two outputs where one is some form of "pay-to-somebody-else" // two outputs where one is some form of "pay-to-somebody-else"
// and the other is a change output. // and the other is a change output.
prevOut := wire.OutPoint{TxID: invVect.Hash} prevOut := wire.OutPoint{TxID: daghash.TxID(invVect.Hash)}
for i := uint32(0); i < 2; i++ { for i := uint32(0); i < 2; i++ {
prevOut.Index = i prevOut.Index = i
entry, ok := sm.dag.GetUTXOEntry(prevOut) entry, ok := sm.dag.GetUTXOEntry(prevOut)
@ -961,7 +958,7 @@ func (sm *SyncManager) handleInvMsg(imsg *invMsg) {
if iv.Type == wire.InvTypeTx { if iv.Type == wire.InvTypeTx {
// Skip the transaction if it has already been // Skip the transaction if it has already been
// rejected. // rejected.
if _, exists := sm.rejectedTxns[iv.Hash]; exists { if _, exists := sm.rejectedTxns[daghash.TxID(iv.Hash)]; exists {
continue continue
} }
} }
@ -1007,7 +1004,7 @@ func (sm *SyncManager) handleInvMsg(imsg *invMsg) {
// final one the remote peer knows about (zero // final one the remote peer knows about (zero
// stop hash). // stop hash).
locator := sm.dag.BlockLocatorFromHash(&iv.Hash) locator := sm.dag.BlockLocatorFromHash(&iv.Hash)
peer.PushGetBlocksMsg(locator, &zeroHash) peer.PushGetBlocksMsg(locator, &daghash.ZeroHash)
} }
} }
} }
@ -1028,7 +1025,7 @@ func (sm *SyncManager) handleInvMsg(imsg *invMsg) {
// request. // request.
if _, exists := sm.requestedBlocks[iv.Hash]; !exists { if _, exists := sm.requestedBlocks[iv.Hash]; !exists {
sm.requestedBlocks[iv.Hash] = struct{}{} sm.requestedBlocks[iv.Hash] = struct{}{}
sm.limitMap(sm.requestedBlocks, maxRequestedBlocks) sm.limitHashMap(sm.requestedBlocks, maxRequestedBlocks)
state.requestedBlocks[iv.Hash] = struct{}{} state.requestedBlocks[iv.Hash] = struct{}{}
gdmsg.AddInvVect(iv) gdmsg.AddInvVect(iv)
@ -1038,10 +1035,10 @@ func (sm *SyncManager) handleInvMsg(imsg *invMsg) {
case wire.InvTypeTx: case wire.InvTypeTx:
// Request the transaction if there is not already a // Request the transaction if there is not already a
// pending request. // pending request.
if _, exists := sm.requestedTxns[iv.Hash]; !exists { if _, exists := sm.requestedTxns[daghash.TxID(iv.Hash)]; !exists {
sm.requestedTxns[iv.Hash] = struct{}{} sm.requestedTxns[daghash.TxID(iv.Hash)] = struct{}{}
sm.limitMap(sm.requestedTxns, maxRequestedTxns) sm.limitTxIDMap(sm.requestedTxns, maxRequestedTxns)
state.requestedTxns[iv.Hash] = struct{}{} state.requestedTxns[daghash.TxID(iv.Hash)] = struct{}{}
gdmsg.AddInvVect(iv) gdmsg.AddInvVect(iv)
numRequested++ numRequested++
@ -1058,10 +1055,10 @@ func (sm *SyncManager) handleInvMsg(imsg *invMsg) {
} }
} }
// limitMap is a helper function for maps that require a maximum limit by // limitTxIDMap is a helper function for maps that require a maximum limit by
// evicting a random transaction if adding a new value would cause it to // evicting a random transaction if adding a new value would cause it to
// overflow the maximum allowed. // overflow the maximum allowed.
func (sm *SyncManager) limitMap(m map[daghash.Hash]struct{}, limit int) { func (sm *SyncManager) limitTxIDMap(m map[daghash.TxID]struct{}, limit int) {
if len(m)+1 > limit { if len(m)+1 > limit {
// Remove a random entry from the map. For most compilers, Go's // Remove a random entry from the map. For most compilers, Go's
// range statement iterates starting at a random item although // range statement iterates starting at a random item although
@ -1069,8 +1066,26 @@ func (sm *SyncManager) limitMap(m map[daghash.Hash]struct{}, limit int) {
// is not important here because an adversary would have to be // is not important here because an adversary would have to be
// able to pull off preimage attacks on the hashing function in // able to pull off preimage attacks on the hashing function in
// order to target eviction of specific entries anyways. // order to target eviction of specific entries anyways.
for txHash := range m { for txID := range m {
delete(m, txHash) delete(m, txID)
return
}
}
}
// limitHashMap is a helper function for maps that require a maximum limit by
// evicting a random item if adding a new value would cause it to
// overflow the maximum allowed.
func (sm *SyncManager) limitHashMap(m map[daghash.Hash]struct{}, limit int) {
if len(m)+1 > limit {
// Remove a random entry from the map. For most compilers, Go's
// range statement iterates starting at a random item although
// that is not 100% guaranteed by the spec. The iteration order
// is not important here because an adversary would have to be
// able to pull off preimage attacks on the hashing function in
// order to target eviction of specific entries anyways.
for hash := range m {
delete(m, hash)
return return
} }
} }
@ -1349,8 +1364,8 @@ func New(config *Config) (*SyncManager, error) {
dag: config.DAG, dag: config.DAG,
txMemPool: config.TxMemPool, txMemPool: config.TxMemPool,
chainParams: config.ChainParams, chainParams: config.ChainParams,
rejectedTxns: make(map[daghash.Hash]struct{}), rejectedTxns: make(map[daghash.TxID]struct{}),
requestedTxns: make(map[daghash.Hash]struct{}), requestedTxns: make(map[daghash.TxID]struct{}),
requestedBlocks: make(map[daghash.Hash]struct{}), requestedBlocks: make(map[daghash.Hash]struct{}),
peerStates: make(map[*peerpkg.Peer]*peerSyncState), peerStates: make(map[*peerpkg.Peer]*peerSyncState),
progressLogger: newBlockProgressLogger("Processed", log), progressLogger: newBlockProgressLogger("Processed", log),

7
peer/peer.go
View File

@ -77,10 +77,6 @@ var (
// and is used to assign an id to a peer. // and is used to assign an id to a peer.
nodeCount int32 nodeCount int32
// zeroHash is the zero value hash (all zeros). It is defined as a
// convenience.
zeroHash daghash.Hash
// sentNonces houses the unique nonces that are generated when pushing // sentNonces houses the unique nonces that are generated when pushing
// version messages that are used to detect self connections. // version messages that are used to detect self connections.
sentNonces = newMruNonceMap(50) sentNonces = newMruNonceMap(50)
@ -613,6 +609,7 @@ func (p *Peer) UserAgent() string {
return userAgent return userAgent
} }
// SubnetworkID returns peer subnetwork ID
func (p *Peer) SubnetworkID() *subnetworkid.SubnetworkID { func (p *Peer) SubnetworkID() *subnetworkid.SubnetworkID {
p.flagsMtx.Lock() p.flagsMtx.Lock()
subnetworkID := p.cfg.SubnetworkID subnetworkID := p.cfg.SubnetworkID
@ -1012,7 +1009,7 @@ func (p *Peer) PushRejectMsg(command string, code wire.RejectCode, reason string
log.Warnf("Sending a reject message for command "+ log.Warnf("Sending a reject message for command "+
"type %v which should have specified a hash "+ "type %v which should have specified a hash "+
"but does not", command) "but does not", command)
hash = &zeroHash hash = &daghash.ZeroHash
} }
msg.Hash = *hash msg.Hash = *hash
} }

4
rpcclient/notify.go
View File

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

4
rpcclient/wallet.go
View File

@ -386,11 +386,11 @@ func (r FutureListLockUnspentResult) Receive() ([]*wire.OutPoint, error) {
// Create a slice of outpoints from the transaction input structs. // Create a slice of outpoints from the transaction input structs.
ops := make([]*wire.OutPoint, len(inputs)) ops := make([]*wire.OutPoint, len(inputs))
for i, input := range inputs { for i, input := range inputs {
sha, err := daghash.NewHashFromStr(input.TxID) txID, err := daghash.NewTxIDFromStr(input.TxID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ops[i] = wire.NewOutPoint(sha, input.Vout) ops[i] = wire.NewOutPoint(txID, input.Vout)
} }
return ops, nil return ops, nil

19
server/p2p/p2p.go
View File

@ -69,9 +69,6 @@ var (
userAgentVersion = fmt.Sprintf("%d.%d.%d", version.AppMajor, version.AppMinor, version.AppPatch) userAgentVersion = fmt.Sprintf("%d.%d.%d", version.AppMajor, version.AppMinor, version.AppPatch)
) )
// zeroHash is the zero value hash (all zeros). It is defined as a convenience.
var zeroHash daghash.Hash
// onionAddr implements the net.Addr interface and represents a tor address. // onionAddr implements the net.Addr interface and represents a tor address.
type onionAddr struct { type onionAddr struct {
addr string addr string
@ -474,7 +471,7 @@ func (sp *Peer) OnMemPool(_ *peer.Peer, msg *wire.MsgMemPool) {
// or only the transactions that match the filter when there is // or only the transactions that match the filter when there is
// one. // one.
if !sp.filter.IsLoaded() || sp.filter.MatchTxAndUpdate(txDesc.Tx) { if !sp.filter.IsLoaded() || sp.filter.MatchTxAndUpdate(txDesc.Tx) {
iv := wire.NewInvVect(wire.InvTypeTx, txDesc.Tx.ID()) iv := wire.NewInvVect(wire.InvTypeTx, (*daghash.Hash)(txDesc.Tx.ID()))
invMsg.AddInvVect(iv) invMsg.AddInvVect(iv)
if len(invMsg.InvList)+1 > wire.MaxInvPerMsg { if len(invMsg.InvList)+1 > wire.MaxInvPerMsg {
break break
@ -503,7 +500,7 @@ func (sp *Peer) OnTx(_ *peer.Peer, msg *wire.MsgTx) {
// Convert the raw MsgTx to a util.Tx which provides some convenience // Convert the raw MsgTx to a util.Tx which provides some convenience
// methods and things such as hash caching. // methods and things such as hash caching.
tx := util.NewTx(msg) tx := util.NewTx(msg)
iv := wire.NewInvVect(wire.InvTypeTx, tx.ID()) iv := wire.NewInvVect(wire.InvTypeTx, (*daghash.Hash)(tx.ID()))
sp.AddKnownInventory(iv) sp.AddKnownInventory(iv)
// Queue the transaction up to be handled by the sync manager and // Queue the transaction up to be handled by the sync manager and
@ -619,7 +616,7 @@ func (sp *Peer) OnGetData(_ *peer.Peer, msg *wire.MsgGetData) {
var err error var err error
switch iv.Type { switch iv.Type {
case wire.InvTypeTx: case wire.InvTypeTx:
err = sp.server.pushTxMsg(sp, &iv.Hash, c, waitChan) err = sp.server.pushTxMsg(sp, (*daghash.TxID)(&iv.Hash), c, waitChan)
case wire.InvTypeBlock: case wire.InvTypeBlock:
err = sp.server.pushBlockMsg(sp, &iv.Hash, c, waitChan) err = sp.server.pushBlockMsg(sp, &iv.Hash, c, waitChan)
case wire.InvTypeFilteredBlock: case wire.InvTypeFilteredBlock:
@ -1217,23 +1214,23 @@ func (s *Server) RemoveRebroadcastInventory(iv *wire.InvVect) {
// passed transactions to all connected peers. // passed transactions to all connected peers.
func (s *Server) RelayTransactions(txns []*mempool.TxDesc) { func (s *Server) RelayTransactions(txns []*mempool.TxDesc) {
for _, txD := range txns { for _, txD := range txns {
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.ID()) iv := wire.NewInvVect(wire.InvTypeTx, (*daghash.Hash)(txD.Tx.ID()))
s.RelayInventory(iv, txD) s.RelayInventory(iv, txD)
} }
} }
// pushTxMsg sends a tx message for the provided transaction hash to the // pushTxMsg sends a tx message for the provided transaction hash to the
// connected peer. An error is returned if the transaction hash is not known. // connected peer. An error is returned if the transaction hash is not known.
func (s *Server) pushTxMsg(sp *Peer, hash *daghash.Hash, doneChan chan<- struct{}, func (s *Server) pushTxMsg(sp *Peer, txID *daghash.TxID, doneChan chan<- struct{},
waitChan <-chan struct{}) error { waitChan <-chan struct{}) error {
// Attempt to fetch the requested transaction from the pool. A // Attempt to fetch the requested transaction from the pool. A
// call could be made to check for existence first, but simply trying // call could be made to check for existence first, but simply trying
// to fetch a missing transaction results in the same behavior. // to fetch a missing transaction results in the same behavior.
tx, err := s.TxMemPool.FetchTransaction(hash) tx, err := s.TxMemPool.FetchTransaction(txID)
if err != nil { if err != nil {
peerLog.Tracef("Unable to fetch tx %v from transaction "+ peerLog.Tracef("Unable to fetch tx %v from transaction "+
"pool: %v", hash, err) "pool: %v", txID, err)
if doneChan != nil { if doneChan != nil {
doneChan <- struct{}{} doneChan <- struct{}{}
@ -2862,6 +2859,6 @@ func (s *Server) TransactionConfirmed(tx *util.Tx) {
return return
} }
iv := wire.NewInvVect(wire.InvTypeTx, tx.ID()) iv := wire.NewInvVect(wire.InvTypeTx, (*daghash.Hash)(tx.ID()))
s.RemoveRebroadcastInventory(iv) s.RemoveRebroadcastInventory(iv)
} }

38
server/rpc/rpcserver.go
View File

@ -326,10 +326,10 @@ func rpcDecodeHexError(gotHex string) *btcjson.RPCError {
// rpcNoTxInfoError is a convenience function for returning a nicely formatted // rpcNoTxInfoError is a convenience function for returning a nicely formatted
// RPC error which indicates there is no information available for the provided // RPC error which indicates there is no information available for the provided
// transaction hash. // transaction hash.
func rpcNoTxInfoError(txHash *daghash.Hash) *btcjson.RPCError { func rpcNoTxInfoError(txID *daghash.TxID) *btcjson.RPCError {
return btcjson.NewRPCError(btcjson.ErrRPCNoTxInfo, return btcjson.NewRPCError(btcjson.ErrRPCNoTxInfo,
fmt.Sprintf("No information available about transaction %v", fmt.Sprintf("No information available about transaction %v",
txHash)) txID))
} }
// gbtWorkState houses state that is used in between multiple RPC invocations to // gbtWorkState houses state that is used in between multiple RPC invocations to
@ -545,12 +545,12 @@ func handleCreateRawTransaction(s *Server, cmd interface{}, closeChan <-chan str
// some validity checks. // some validity checks.
mtx := wire.NewMsgTx(wire.TxVersion) mtx := wire.NewMsgTx(wire.TxVersion)
for _, input := range c.Inputs { for _, input := range c.Inputs {
txHash, err := daghash.NewHashFromStr(input.TxID) txID, err := daghash.NewTxIDFromStr(input.TxID)
if err != nil { if err != nil {
return nil, rpcDecodeHexError(input.TxID) return nil, rpcDecodeHexError(input.TxID)
} }
prevOut := wire.NewOutPoint(txHash, input.Vout) prevOut := wire.NewOutPoint(txID, input.Vout)
txIn := wire.NewTxIn(prevOut, []byte{}) txIn := wire.NewTxIn(prevOut, []byte{})
if c.LockTime != nil && *c.LockTime != 0 { if c.LockTime != nil && *c.LockTime != 0 {
txIn.Sequence = wire.MaxTxInSequenceNum - 1 txIn.Sequence = wire.MaxTxInSequenceNum - 1
@ -1679,7 +1679,7 @@ func (state *gbtWorkState) blockTemplateResult(useCoinbaseValue bool, submitOld
// the adjustments to the various lengths and indices. // the adjustments to the various lengths and indices.
numTx := len(msgBlock.Transactions) numTx := len(msgBlock.Transactions)
transactions := make([]btcjson.GetBlockTemplateResultTx, 0, numTx-1) transactions := make([]btcjson.GetBlockTemplateResultTx, 0, numTx-1)
txIndex := make(map[daghash.Hash]int64, numTx) txIndex := make(map[daghash.TxID]int64, numTx)
for i, tx := range msgBlock.Transactions { for i, tx := range msgBlock.Transactions {
txID := tx.TxID() txID := tx.TxID()
txIndex[txID] = int64(i) txIndex[txID] = int64(i)
@ -2456,7 +2456,7 @@ func handleGetRawTransaction(s *Server, cmd interface{}, closeChan <-chan struct
c := cmd.(*btcjson.GetRawTransactionCmd) c := cmd.(*btcjson.GetRawTransactionCmd)
// Convert the provided transaction hash hex to a Hash. // Convert the provided transaction hash hex to a Hash.
txHash, err := daghash.NewHashFromStr(c.TxID) txID, err := daghash.NewTxIDFromStr(c.TxID)
if err != nil { if err != nil {
return nil, rpcDecodeHexError(c.TxID) return nil, rpcDecodeHexError(c.TxID)
} }
@ -2471,7 +2471,7 @@ func handleGetRawTransaction(s *Server, cmd interface{}, closeChan <-chan struct
var mtx *wire.MsgTx var mtx *wire.MsgTx
var blkHash *daghash.Hash var blkHash *daghash.Hash
var blkHeight int32 var blkHeight int32
tx, err := s.cfg.TxMemPool.FetchTransaction(txHash) tx, err := s.cfg.TxMemPool.FetchTransaction(txID)
if err != nil { if err != nil {
if s.cfg.TxIndex == nil { if s.cfg.TxIndex == nil {
return nil, &btcjson.RPCError{ return nil, &btcjson.RPCError{
@ -2483,13 +2483,13 @@ func handleGetRawTransaction(s *Server, cmd interface{}, closeChan <-chan struct
} }
// Look up the location of the transaction. // Look up the location of the transaction.
blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(txHash) blockRegion, err := s.cfg.TxIndex.TxFirstBlockRegion(txID)
if err != nil { if err != nil {
context := "Failed to retrieve transaction location" context := "Failed to retrieve transaction location"
return nil, internalRPCError(err.Error(), context) return nil, internalRPCError(err.Error(), context)
} }
if blockRegion == nil { if blockRegion == nil {
return nil, rpcNoTxInfoError(txHash) return nil, rpcNoTxInfoError(txID)
} }
// Load the raw transaction bytes from the database. // Load the raw transaction bytes from the database.
@ -2500,7 +2500,7 @@ func handleGetRawTransaction(s *Server, cmd interface{}, closeChan <-chan struct
return err return err
}) })
if err != nil { if err != nil {
return nil, rpcNoTxInfoError(txHash) return nil, rpcNoTxInfoError(txID)
} }
// When the verbose flag isn't set, simply return the serialized // When the verbose flag isn't set, simply return the serialized
@ -2562,7 +2562,7 @@ func handleGetRawTransaction(s *Server, cmd interface{}, closeChan <-chan struct
dagHeight = s.cfg.DAG.Height() dagHeight = s.cfg.DAG.Height()
} }
rawTxn, err := createTxRawResult(s.cfg.DAGParams, mtx, txHash.String(), rawTxn, err := createTxRawResult(s.cfg.DAGParams, mtx, txID.String(),
blkHeader, blkHashStr, blkHeight, dagHeight, nil) blkHeader, blkHashStr, blkHeight, dagHeight, nil)
if err != nil { if err != nil {
return nil, err return nil, err
@ -2575,7 +2575,7 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
c := cmd.(*btcjson.GetTxOutCmd) c := cmd.(*btcjson.GetTxOutCmd)
// Convert the provided transaction hash hex to a Hash. // Convert the provided transaction hash hex to a Hash.
txHash, err := daghash.NewHashFromStr(c.TxID) txID, err := daghash.NewTxIDFromStr(c.TxID)
if err != nil { if err != nil {
return nil, rpcDecodeHexError(c.TxID) return nil, rpcDecodeHexError(c.TxID)
} }
@ -2593,10 +2593,10 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
} }
// TODO: This is racy. It should attempt to fetch it directly and check // TODO: This is racy. It should attempt to fetch it directly and check
// the error. // the error.
if includeMempool && s.cfg.TxMemPool.HaveTransaction(txHash) { if includeMempool && s.cfg.TxMemPool.HaveTransaction(txID) {
tx, err := s.cfg.TxMemPool.FetchTransaction(txHash) tx, err := s.cfg.TxMemPool.FetchTransaction(txID)
if err != nil { if err != nil {
return nil, rpcNoTxInfoError(txHash) return nil, rpcNoTxInfoError(txID)
} }
mtx := tx.MsgTx() mtx := tx.MsgTx()
@ -2611,7 +2611,7 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
txOut := mtx.TxOut[c.Vout] txOut := mtx.TxOut[c.Vout]
if txOut == nil { if txOut == nil {
errStr := fmt.Sprintf("Output index: %d for txid: %s "+ errStr := fmt.Sprintf("Output index: %d for txid: %s "+
"does not exist", c.Vout, txHash) "does not exist", c.Vout, txID)
return nil, internalRPCError(errStr, "") return nil, internalRPCError(errStr, "")
} }
@ -2621,10 +2621,10 @@ func handleGetTxOut(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
pkScript = txOut.PkScript pkScript = txOut.PkScript
isCoinbase = mtx.IsCoinBase() isCoinbase = mtx.IsCoinBase()
} else { } else {
out := wire.OutPoint{TxID: *txHash, Index: c.Vout} out := wire.OutPoint{TxID: *txID, Index: c.Vout}
entry, ok := s.cfg.DAG.GetUTXOEntry(out) entry, ok := s.cfg.DAG.GetUTXOEntry(out)
if !ok { if !ok {
return nil, rpcNoTxInfoError(txHash) return nil, rpcNoTxInfoError(txID)
} }
// To match the behavior of the reference client, return nil // To match the behavior of the reference client, return nil
@ -3280,7 +3280,7 @@ func handleSendRawTransaction(s *Server, cmd interface{}, closeChan <-chan struc
// Keep track of all the sendRawTransaction request txns so that they // Keep track of all the sendRawTransaction request txns so that they
// can be rebroadcast if they don't make their way into a block. // can be rebroadcast if they don't make their way into a block.
txD := acceptedTxs[0] txD := acceptedTxs[0]
iv := wire.NewInvVect(wire.InvTypeTx, txD.Tx.ID()) iv := wire.NewInvVect(wire.InvTypeTx, (*daghash.Hash)(txD.Tx.ID()))
s.cfg.ConnMgr.AddRebroadcastInventory(iv, txD) s.cfg.ConnMgr.AddRebroadcastInventory(iv, txD)
return tx.ID().String(), nil return tx.ID().String(), nil

2
server/rpc/rpcserverhelp.go
View File

@ -618,7 +618,7 @@ var helpDescsEnUS = map[string]string{
"stopNotifyReceived-addresses": "List of address to cancel receive notifications for", "stopNotifyReceived-addresses": "List of address to cancel receive notifications for",
// OutPoint help. // OutPoint help.
"outPoint-hash": "The hex-encoded bytes of the outPoint hash", "outPoint-txid": "The hex-encoded bytes of the outPoint transaction ID",
"outPoint-index": "The index of the outPoint", "outPoint-index": "The index of the outPoint",
// NotifySpentCmd help. // NotifySpentCmd help.

10
server/rpc/rpcwebsocket.go
View File

@ -1824,7 +1824,7 @@ func handleLoadTxFilter(wsc *wsClient, icmd interface{}) (interface{}, error) {
outPoints := make([]wire.OutPoint, len(cmd.OutPoints)) outPoints := make([]wire.OutPoint, len(cmd.OutPoints))
for i := range cmd.OutPoints { for i := range cmd.OutPoints {
hash, err := daghash.NewHashFromStr(cmd.OutPoints[i].Hash) txID, err := daghash.NewTxIDFromStr(cmd.OutPoints[i].TxID)
if err != nil { if err != nil {
return nil, &btcjson.RPCError{ return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidParameter, Code: btcjson.ErrRPCInvalidParameter,
@ -1832,7 +1832,7 @@ func handleLoadTxFilter(wsc *wsClient, icmd interface{}) (interface{}, error) {
} }
} }
outPoints[i] = wire.OutPoint{ outPoints[i] = wire.OutPoint{
TxID: *hash, TxID: *txID,
Index: cmd.OutPoints[i].Index, Index: cmd.OutPoints[i].Index,
} }
} }
@ -2044,12 +2044,12 @@ func checkAddressValidity(addrs []string, params *dagconfig.Params) error {
func deserializeOutpoints(serializedOuts []btcjson.OutPoint) ([]*wire.OutPoint, error) { func deserializeOutpoints(serializedOuts []btcjson.OutPoint) ([]*wire.OutPoint, error) {
outpoints := make([]*wire.OutPoint, 0, len(serializedOuts)) outpoints := make([]*wire.OutPoint, 0, len(serializedOuts))
for i := range serializedOuts { for i := range serializedOuts {
blockHash, err := daghash.NewHashFromStr(serializedOuts[i].Hash) txID, err := daghash.NewTxIDFromStr(serializedOuts[i].TxID)
if err != nil { if err != nil {
return nil, rpcDecodeHexError(serializedOuts[i].Hash) return nil, rpcDecodeHexError(serializedOuts[i].TxID)
} }
index := serializedOuts[i].Index index := serializedOuts[i].Index
outpoints = append(outpoints, wire.NewOutPoint(blockHash, index)) outpoints = append(outpoints, wire.NewOutPoint(txID, index))
} }
return outpoints, nil return outpoints, nil

8
txscript/engine_test.go
View File

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

2
txscript/example_test.go
View File

@ -101,7 +101,7 @@ func ExampleSignTxOutput() {
// would ordinarily be the real transaction that is being spent. It // would ordinarily be the real transaction that is being spent. It
// contains a single output that pays to address in the amount of 1 BTC. // contains a single output that pays to address in the amount of 1 BTC.
originTx := wire.NewMsgTx(wire.TxVersion) originTx := wire.NewMsgTx(wire.TxVersion)
prevOut := wire.NewOutPoint(&daghash.Hash{}, ^uint32(0)) prevOut := wire.NewOutPoint(&daghash.TxID{}, ^uint32(0))
txIn := wire.NewTxIn(prevOut, []byte{txscript.Op0, txscript.Op0}) txIn := wire.NewTxIn(prevOut, []byte{txscript.Op0, txscript.Op0})
originTx.AddTxIn(txIn) originTx.AddTxIn(txIn)
pkScript, err := txscript.PayToAddrScript(addr) pkScript, err := txscript.PayToAddrScript(addr)

2
txscript/reference_test.go
View File

@ -217,7 +217,7 @@ func parseExpectedResult(expected string) ([]ErrorCode, error) {
func createSpendingTx(sigScript, pkScript []byte) *wire.MsgTx { func createSpendingTx(sigScript, pkScript []byte) *wire.MsgTx {
coinbaseTx := wire.NewMsgTx(wire.TxVersion) coinbaseTx := wire.NewMsgTx(wire.TxVersion)
outPoint := wire.NewOutPoint(&daghash.Hash{}, ^uint32(0)) outPoint := wire.NewOutPoint(&daghash.TxID{}, ^uint32(0))
txIn := wire.NewTxIn(outPoint, []byte{Op0, Op0}) txIn := wire.NewTxIn(outPoint, []byte{Op0, Op0})
txOut := wire.NewTxOut(0, pkScript) txOut := wire.NewTxOut(0, pkScript)
coinbaseTx.AddTxIn(txIn) coinbaseTx.AddTxIn(txIn)

6
txscript/sign_test.go
View File

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

8
util/block_test.go
View File

@ -334,7 +334,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -369,7 +369,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
@ -439,7 +439,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
@ -508,7 +508,7 @@ var Block100000 = wire.MsgBlock{
TxIn: []*wire.TxIn{ TxIn: []*wire.TxIn{
{ {
PreviousOutPoint: wire.OutPoint{ PreviousOutPoint: wire.OutPoint{
TxID: daghash.Hash([32]byte{ // Make go vet happy. TxID: daghash.TxID([32]byte{ // Make go vet happy.
0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,

6
util/bloom/filter.go
View File

@ -250,15 +250,15 @@ func (bf *Filter) AddOutPoint(outpoint *wire.OutPoint) {
// script. // script.
// //
// This function MUST be called with the filter lock held. // This function MUST be called with the filter lock held.
func (bf *Filter) maybeAddOutpoint(pkScript []byte, outHash *daghash.Hash, outIdx uint32) { func (bf *Filter) maybeAddOutpoint(pkScript []byte, outTxID *daghash.TxID, outIdx uint32) {
switch bf.msgFilterLoad.Flags { switch bf.msgFilterLoad.Flags {
case wire.BloomUpdateAll: case wire.BloomUpdateAll:
outpoint := wire.NewOutPoint(outHash, outIdx) outpoint := wire.NewOutPoint(outTxID, outIdx)
bf.addOutPoint(outpoint) bf.addOutPoint(outpoint)
case wire.BloomUpdateP2PubkeyOnly: case wire.BloomUpdateP2PubkeyOnly:
class := txscript.GetScriptClass(pkScript) class := txscript.GetScriptClass(pkScript)
if class == txscript.PubKeyTy || class == txscript.MultiSigTy { if class == txscript.PubKeyTy || class == txscript.MultiSigTy {
outpoint := wire.NewOutPoint(outHash, outIdx) outpoint := wire.NewOutPoint(outTxID, outIdx)
bf.addOutPoint(outpoint) bf.addOutPoint(outpoint)
} }
} }

28
util/bloom/filter_test.go
View File

@ -414,12 +414,12 @@ func TestFilterBloomMatch(t *testing.T) {
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll) f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b" inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
hash, err = daghash.NewHashFromStr(inputStr) txID, err := daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err) t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return return
} }
outpoint := wire.NewOutPoint(hash, 0) outpoint := wire.NewOutPoint(txID, 0)
f.AddOutPoint(outpoint) f.AddOutPoint(outpoint)
if !f.MatchTxAndUpdate(tx) { if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match outpoint %s", inputStr) t.Errorf("TestFilterBloomMatch didn't match outpoint %s", inputStr)
@ -451,12 +451,12 @@ func TestFilterBloomMatch(t *testing.T) {
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll) f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b" inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
hash, err = daghash.NewHashFromStr(inputStr) txID, err = daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err) t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return return
} }
outpoint = wire.NewOutPoint(hash, 1) outpoint = wire.NewOutPoint(txID, 1)
f.AddOutPoint(outpoint) f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) { if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr) t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
@ -464,12 +464,12 @@ func TestFilterBloomMatch(t *testing.T) {
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll) f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b" inputStr = "000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
hash, err = daghash.NewHashFromStr(inputStr) txID, err = daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err) t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return return
} }
outpoint = wire.NewOutPoint(hash, 0) outpoint = wire.NewOutPoint(txID, 0)
f.AddOutPoint(outpoint) f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) { if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr) t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
@ -500,12 +500,12 @@ func TestFilterInsertUpdateNone(t *testing.T) {
f.Add(inputBytes) f.Add(inputBytes)
inputStr = "147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b" inputStr = "147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"
hash, err := daghash.NewHashFromStr(inputStr) txID, err := daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err) t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err)
return return
} }
outpoint := wire.NewOutPoint(hash, 0) outpoint := wire.NewOutPoint(txID, 0)
if f.MatchesOutPoint(outpoint) { if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr) t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
@ -513,12 +513,12 @@ func TestFilterInsertUpdateNone(t *testing.T) {
} }
inputStr = "02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041" inputStr = "02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"
hash, err = daghash.NewHashFromStr(inputStr) txID, err = daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err) t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err)
return return
} }
outpoint = wire.NewOutPoint(hash, 0) outpoint = wire.NewOutPoint(txID, 0)
if f.MatchesOutPoint(outpoint) { if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr) t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
@ -826,12 +826,12 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
// We should match the generation pubkey // We should match the generation pubkey
inputStr = "042aaac8c54b07f1e729e01d38b1fb26c6d595ed5920b856faf4070db79ce933" //0st tx hash inputStr = "042aaac8c54b07f1e729e01d38b1fb26c6d595ed5920b856faf4070db79ce933" //0st tx hash
hash, err := daghash.NewHashFromStr(inputStr) txID, err := daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err) t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err)
return return
} }
outpoint := wire.NewOutPoint(hash, 0) outpoint := wire.NewOutPoint(txID, 0)
if !f.MatchesOutPoint(outpoint) { if !f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly didn't match the generation "+ t.Errorf("TestMerkleBlockP2PubKeyOnly didn't match the generation "+
"outpoint %s", inputStr) "outpoint %s", inputStr)
@ -840,12 +840,12 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
// We should not match the 4th transaction, which is not p2pk // We should not match the 4th transaction, which is not p2pk
inputStr = "f9a116ecc107b6b1b0bdcd0d727bfaa3355f27f8fed08347bf0004244949d9eb" inputStr = "f9a116ecc107b6b1b0bdcd0d727bfaa3355f27f8fed08347bf0004244949d9eb"
hash, err = daghash.NewHashFromStr(inputStr) txID, err = daghash.NewTxIDFromStr(inputStr)
if err != nil { if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err) t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err)
return return
} }
outpoint = wire.NewOutPoint(hash, 0) outpoint = wire.NewOutPoint(txID, 0)
if f.MatchesOutPoint(outpoint) { if f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly matched outpoint %s", inputStr) t.Errorf("TestMerkleBlockP2PubKeyOnly matched outpoint %s", inputStr)
return return

2
util/bloom/merkleblock.go
View File

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

4
util/coinset/coins.go
View File

@ -17,7 +17,7 @@ import (
// Coin represents a spendable transaction outpoint // Coin represents a spendable transaction outpoint
type Coin interface { type Coin interface {
Hash() *daghash.Hash Hash() *daghash.Hash
ID() *daghash.Hash ID() *daghash.TxID
Index() uint32 Index() uint32
Value() util.Amount Value() util.Amount
PkScript() []byte PkScript() []byte
@ -361,7 +361,7 @@ func (c *SimpleCoin) Hash() *daghash.Hash {
} }
// ID returns the ID of the transaction on which the Coin is an output // ID returns the ID of the transaction on which the Coin is an output
func (c *SimpleCoin) ID() *daghash.Hash { func (c *SimpleCoin) ID() *daghash.TxID {
return c.Tx.ID() return c.Tx.ID()
} }

8
util/coinset/coins_test.go
View File

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

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

@ -102,6 +102,11 @@ func (b *GCSBuilder) SetKeyFromHash(keyHash *daghash.Hash) *GCSBuilder {
return b.SetKey(DeriveKey(keyHash)) return b.SetKey(DeriveKey(keyHash))
} }
// SetKeyFromTxID is wrapper of SetKeyFromHash for TxID
func (b *GCSBuilder) SetKeyFromTxID(keyTxID *daghash.TxID) *GCSBuilder {
return b.SetKeyFromHash((*daghash.Hash)(keyTxID))
}
// SetP sets the filter's probability after calling Builder(). // SetP sets the filter's probability after calling Builder().
func (b *GCSBuilder) SetP(p uint8) *GCSBuilder { func (b *GCSBuilder) SetP(p uint8) *GCSBuilder {
// Do nothing if the builder's already errored out. // Do nothing if the builder's already errored out.
@ -183,6 +188,12 @@ func (b *GCSBuilder) AddHash(hash *daghash.Hash) *GCSBuilder {
return b.AddEntry(hash.CloneBytes()) return b.AddEntry(hash.CloneBytes())
} }
// AddTxID adds a daghash.TxID to the list of entries to be included in the
// GCS filter when it's built.
func (b *GCSBuilder) AddTxID(txID *daghash.TxID) *GCSBuilder {
return b.AddHash((*daghash.Hash)(txID))
}
// AddScript adds all the data pushed in the script serialized as the passed // AddScript adds all the data pushed in the script serialized as the passed
// []byte to the list of entries to be included in the GCS filter when it's // []byte to the list of entries to be included in the GCS filter when it's
// built. // built.
@ -251,6 +262,11 @@ func WithKeyHashP(keyHash *daghash.Hash, p uint8) *GCSBuilder {
return WithKeyHashPN(keyHash, p, 0) return WithKeyHashPN(keyHash, p, 0)
} }
// WithKeyTxIDP is wrapper of WithKeyHashP for TxID
func WithKeyTxIDP(keyTxID *daghash.TxID, p uint8) *GCSBuilder {
return WithKeyHashP((*daghash.Hash)(keyTxID), p)
}
// WithKeyHash creates a GCSBuilder with key derived from the specified // WithKeyHash creates a GCSBuilder with key derived from the specified
// daghash.Hash. Probability is set to 20 (2^-20 collision probability). // daghash.Hash. Probability is set to 20 (2^-20 collision probability).
// Estimated filter size is set to zero, which means more reallocations are // Estimated filter size is set to zero, which means more reallocations are
@ -259,6 +275,11 @@ func WithKeyHash(keyHash *daghash.Hash) *GCSBuilder {
return WithKeyHashPN(keyHash, DefaultP, 0) return WithKeyHashPN(keyHash, DefaultP, 0)
} }
// WithKeyTxID is wrapper of WithKeyHash for transaction ID
func WithKeyTxID(keyTxID *daghash.TxID) *GCSBuilder {
return WithKeyHash((*daghash.Hash)(keyTxID))
}
// WithRandomKeyPN creates a GCSBuilder with a cryptographically random key and // WithRandomKeyPN creates a GCSBuilder with a cryptographically random key and
// the passed probability and estimated filter size. // the passed probability and estimated filter size.
func WithRandomKeyPN(p uint8, n uint32) *GCSBuilder { func WithRandomKeyPN(p uint8, n uint32) *GCSBuilder {
@ -306,7 +327,7 @@ func BuildBasicFilter(block *wire.MsgBlock) (*gcs.Filter, error) {
// First we'll compute the bash of the transaction and add that // First we'll compute the bash of the transaction and add that
// directly to the filter. // directly to the filter.
txID := tx.TxID() txID := tx.TxID()
b.AddHash(&txID) b.AddTxID(&txID)
// Skip the inputs for the coinbase transaction // Skip the inputs for the coinbase transaction
if i != 0 { if i != 0 {

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

@ -50,7 +50,7 @@ var (
// TestUseBlockHash tests using a block hash as a filter key. // TestUseBlockHash tests using a block hash as a filter key.
func TestUseBlockHash(t *testing.T) { func TestUseBlockHash(t *testing.T) {
// Block hash #448710, pretty high difficulty. // Block hash #448710, pretty high difficulty.
txID, err := daghash.NewHashFromStr(testHash) txID, err := daghash.NewTxIDFromStr(testHash)
if err != nil { if err != nil {
t.Fatalf("Hash from string failed: %s", err.Error()) t.Fatalf("Hash from string failed: %s", err.Error())
} }
@ -73,7 +73,7 @@ func TestUseBlockHash(t *testing.T) {
// Create a GCSBuilder with a key hash and check that the key is derived // Create a GCSBuilder with a key hash and check that the key is derived
// correctly, then test it. // correctly, then test it.
b := builder.WithKeyHash(txID) b := builder.WithKeyTxID(txID)
key, err := b.Key() key, err := b.Key()
if err != nil { if err != nil {
t.Fatalf("Builder instantiation with key hash failed: %s", t.Fatalf("Builder instantiation with key hash failed: %s",
@ -87,13 +87,13 @@ func TestUseBlockHash(t *testing.T) {
BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t) BuilderTest(b, txID, builder.DefaultP, outPoint, addrBytes, t)
// Create a GCSBuilder with a key hash and non-default P and test it. // Create a GCSBuilder with a key hash and non-default P and test it.
b = builder.WithKeyHashP(txID, 30) b = builder.WithKeyTxIDP(txID, 30)
BuilderTest(b, txID, 30, outPoint, addrBytes, t) BuilderTest(b, txID, 30, outPoint, addrBytes, t)
// Create a GCSBuilder with a random key, set the key from a hash // Create a GCSBuilder with a random key, set the key from a hash
// manually, check that the key is correct, and test it. // manually, check that the key is correct, and test it.
b = builder.WithRandomKey() b = builder.WithRandomKey()
b.SetKeyFromHash(txID) b.SetKeyFromTxID(txID)
key, err = b.Key() key, err = b.Key()
if err != nil { if err != nil {
t.Fatalf("Builder instantiation with known key failed: %s", t.Fatalf("Builder instantiation with known key failed: %s",
@ -159,9 +159,9 @@ func TestUseBlockHash(t *testing.T) {
// Create a GCSBuilder with a known key and too-high P and ensure error // Create a GCSBuilder with a known key and too-high P and ensure error
// works throughout all functions that use it. // works throughout all functions that use it.
b = builder.WithRandomKeyP(33).SetKeyFromHash(txID).SetKey(testKey) b = builder.WithRandomKeyP(33).SetKeyFromTxID(txID).SetKey(testKey)
b.SetP(30).AddEntry(txID.CloneBytes()).AddEntries(contents) b.SetP(30).AddEntry(txID.CloneBytes()).AddEntries(contents)
b.AddOutPoint(outPoint).AddHash(txID).AddScript(addrBytes) b.AddOutPoint(outPoint).AddTxID(txID).AddScript(addrBytes)
_, err = b.Key() _, err = b.Key()
if err != gcs.ErrPTooBig { if err != gcs.ErrPTooBig {
t.Fatalf("No error on P too big!") t.Fatalf("No error on P too big!")
@ -172,7 +172,7 @@ func TestUseBlockHash(t *testing.T) {
} }
} }
func BuilderTest(b *builder.GCSBuilder, hash *daghash.Hash, p uint8, func BuilderTest(b *builder.GCSBuilder, txID *daghash.TxID, p uint8,
outPoint wire.OutPoint, addrBytes []byte, t *testing.T) { outPoint wire.OutPoint, addrBytes []byte, t *testing.T) {
key, err := b.Key() key, err := b.Key()
@ -206,13 +206,13 @@ func BuilderTest(b *builder.GCSBuilder, hash *daghash.Hash, p uint8,
builder.DefaultP) builder.DefaultP)
} }
// Add a hash, build a filter, and test matches // Add a txID, build a filter, and test matches
b.AddHash(hash) b.AddTxID(txID)
f, err = b.Build() f, err = b.Build()
if err != nil { if err != nil {
t.Fatalf("Filter build failed: %s", err.Error()) t.Fatalf("Filter build failed: %s", err.Error())
} }
match, err = f.Match(key, hash.CloneBytes()) match, err = f.Match(key, txID.CloneBytes())
if err != nil { if err != nil {
t.Fatalf("Filter match failed: %s", err) t.Fatalf("Filter match failed: %s", err)
} }
@ -226,7 +226,7 @@ func BuilderTest(b *builder.GCSBuilder, hash *daghash.Hash, p uint8,
if err != nil { if err != nil {
t.Fatalf("Filter build failed: %s", err.Error()) t.Fatalf("Filter build failed: %s", err.Error())
} }
match, err = f.Match(key, hash.CloneBytes()) match, err = f.Match(key, txID.CloneBytes())
if err != nil { if err != nil {
t.Fatalf("Filter match failed: %s", err) t.Fatalf("Filter match failed: %s", err)
} }

4
util/tx.go
View File

@ -24,7 +24,7 @@ const TxIndexUnknown = -1
type Tx struct { type Tx struct {
msgTx *wire.MsgTx // Underlying MsgTx msgTx *wire.MsgTx // Underlying MsgTx
txHash *daghash.Hash // Cached transaction hash txHash *daghash.Hash // Cached transaction hash
txID *daghash.Hash // Cached transaction ID txID *daghash.TxID // Cached transaction ID
txIndex int // Position within a block or TxIndexUnknown txIndex int // Position within a block or TxIndexUnknown
} }
@ -52,7 +52,7 @@ func (t *Tx) Hash() *daghash.Hash {
// ID returns the id of the transaction. This is equivalent to // ID returns the id of the transaction. This is equivalent to
// calling TxID on the underlying wire.MsgTx, however it caches the // calling TxID on the underlying wire.MsgTx, however it caches the
// result so subsequent calls are more efficient. // result so subsequent calls are more efficient.
func (t *Tx) ID() *daghash.Hash { func (t *Tx) ID() *daghash.TxID {
// Return the cached hash if it has already been generated. // Return the cached hash if it has already been generated.
if t.txID != nil { if t.txID != nil {
return t.txID return t.txID

2
util/tx_test.go
View File

@ -54,7 +54,7 @@ func TestTx(t *testing.T) {
// ID for block 100,000 transaction 1. // ID for block 100,000 transaction 1.
wantIDStr := "1742649144632997855e06650c1df5fd27cad915419a8f14f2f1b5a652257342" wantIDStr := "1742649144632997855e06650c1df5fd27cad915419a8f14f2f1b5a652257342"
wantID, err := daghash.NewHashFromStr(wantIDStr) wantID, err := daghash.NewTxIDFromStr(wantIDStr)
// Request the ID multiple times to test generation and caching. // Request the ID multiple times to test generation and caching.
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
id := secondTx.ID() id := secondTx.ID()

4
wire/bench_test.go
View File

@ -24,7 +24,7 @@ var genesisCoinbaseTx = MsgTx{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{
@ -197,7 +197,7 @@ func BenchmarkReadOutPoint(b *testing.B) {
// transaction output point. // transaction output point.
func BenchmarkWriteOutPoint(b *testing.B) { func BenchmarkWriteOutPoint(b *testing.B) {
op := &OutPoint{ op := &OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0, Index: 0,
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {

2
wire/msgblock_test.go
View File

@ -551,7 +551,7 @@ var blockOne = MsgBlock{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{

24
wire/msgtx.go
View File

@ -57,7 +57,7 @@ const (
defaultTxInOutAlloc = 15 defaultTxInOutAlloc = 15
// minTxInPayload is the minimum payload size for a transaction input. // minTxInPayload is the minimum payload size for a transaction input.
// PreviousOutPoint.Hash + PreviousOutPoint.Index 4 bytes + Varint for // PreviousOutPoint.TxID + PreviousOutPoint.Index 4 bytes + Varint for
// SignatureScript length 1 byte + Sequence 4 bytes. // SignatureScript length 1 byte + Sequence 4 bytes.
minTxInPayload = 9 + daghash.HashSize minTxInPayload = 9 + daghash.HashSize
@ -181,22 +181,22 @@ var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)
// OutPoint defines a bitcoin data type that is used to track previous // OutPoint defines a bitcoin data type that is used to track previous
// transaction outputs. // transaction outputs.
type OutPoint struct { type OutPoint struct {
TxID daghash.Hash TxID daghash.TxID
Index uint32 Index uint32
} }
// NewOutPoint returns a new bitcoin transaction outpoint point with the // NewOutPoint returns a new bitcoin transaction outpoint point with the
// provided hash and index. // provided hash and index.
func NewOutPoint(hash *daghash.Hash, index uint32) *OutPoint { func NewOutPoint(txID *daghash.TxID, index uint32) *OutPoint {
return &OutPoint{ return &OutPoint{
TxID: *hash, TxID: *txID,
Index: index, Index: index,
} }
} }
// String returns the OutPoint in the human-readable form "hash:index". // String returns the OutPoint in the human-readable form "txID:index".
func (o OutPoint) String() string { func (o OutPoint) String() string {
// Allocate enough for hash string, colon, and 10 digits. Although // Allocate enough for ID string, colon, and 10 digits. Although
// at the time of writing, the number of digits can be no greater than // at the time of writing, the number of digits can be no greater than
// the length of the decimal representation of maxTxOutPerMessage, the // the length of the decimal representation of maxTxOutPerMessage, the
// maximum message payload may increase in the future and this // maximum message payload may increase in the future and this
@ -223,7 +223,7 @@ func (t *TxIn) SerializeSize() int {
} }
func (t *TxIn) serializeSize(encodingFlags txEncoding) int { func (t *TxIn) serializeSize(encodingFlags txEncoding) int {
// Outpoint Hash 32 bytes + Outpoint Index 4 bytes + Sequence 8 bytes + // Outpoint ID 32 bytes + Outpoint Index 4 bytes + Sequence 8 bytes +
// serialized varint size for the length of SignatureScript + // serialized varint size for the length of SignatureScript +
// SignatureScript bytes. // SignatureScript bytes.
return 44 + serializeSignatureScriptSize(t.SignatureScript, encodingFlags) return 44 + serializeSignatureScriptSize(t.SignatureScript, encodingFlags)
@ -301,7 +301,7 @@ func (msg *MsgTx) AddTxOut(to *TxOut) {
// is a special transaction created by miners that has no inputs. This is // is a special transaction created by miners that has no inputs. This is
// represented in the block dag by a transaction with a single input that has // represented in the block dag by a transaction with a single input that has
// a previous output transaction index set to the maximum value along with a // a previous output transaction index set to the maximum value along with a
// zero hash. // zero TxID.
func (msg *MsgTx) IsCoinBase() bool { func (msg *MsgTx) IsCoinBase() bool {
// A coin base must only have one transaction input. // A coin base must only have one transaction input.
if len(msg.TxIn) != 1 { if len(msg.TxIn) != 1 {
@ -309,9 +309,9 @@ func (msg *MsgTx) IsCoinBase() bool {
} }
// The previous output of a coinbase must have a max value index and // The previous output of a coinbase must have a max value index and
// a zero hash. // a zero TxID.
prevOut := &msg.TxIn[0].PreviousOutPoint prevOut := &msg.TxIn[0].PreviousOutPoint
return prevOut.Index == math.MaxUint32 && prevOut.TxID == daghash.Zero return prevOut.Index == math.MaxUint32 && prevOut.TxID == daghash.ZeroTxID
} }
// TxHash generates the Hash for the transaction. // TxHash generates the Hash for the transaction.
@ -326,7 +326,7 @@ func (msg *MsgTx) TxHash() daghash.Hash {
} }
// TxID generates the Hash for the transaction without the signature script, gas and payload fields. // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
func (msg *MsgTx) TxID() daghash.Hash { func (msg *MsgTx) TxID() daghash.TxID {
// Encode the transaction, replace signature script, payload and gas with // Encode the transaction, replace signature script, payload and gas with
// zeroes, and calculate double sha256 on the result. // zeroes, and calculate double sha256 on the result.
// Ignore the error returns since the only way the encode could fail // Ignore the error returns since the only way the encode could fail
@ -338,7 +338,7 @@ func (msg *MsgTx) TxID() daghash.Hash {
} }
buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(encodingFlags))) buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(encodingFlags)))
_ = msg.serialize(buf, encodingFlags) _ = msg.serialize(buf, encodingFlags)
return daghash.DoubleHashH(buf.Bytes()) return daghash.TxID(daghash.DoubleHashH(buf.Bytes()))
} }
// Copy creates a deep copy of a transaction so that the original does not get // Copy creates a deep copy of a transaction so that the original does not get

41
wire/msgtx_test.go
View File

@ -22,11 +22,10 @@ import (
func TestTx(t *testing.T) { func TestTx(t *testing.T) {
pver := ProtocolVersion pver := ProtocolVersion
// Block 100000 hash. txIDStr := "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
hashStr := "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506" txID, err := daghash.NewTxIDFromStr(txIDStr)
hash, err := daghash.NewHashFromStr(hashStr)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewTxIDFromStr: %v", err)
} }
// Ensure the command is expected value. // Ensure the command is expected value.
@ -50,16 +49,16 @@ func TestTx(t *testing.T) {
// NOTE: This is a block hash and made up index, but we're only // NOTE: This is a block hash and made up index, but we're only
// testing package functionality. // testing package functionality.
prevOutIndex := uint32(1) prevOutIndex := uint32(1)
prevOut := NewOutPoint(hash, prevOutIndex) prevOut := NewOutPoint(txID, prevOutIndex)
if !prevOut.TxID.IsEqual(hash) { if !prevOut.TxID.IsEqual(txID) {
t.Errorf("NewOutPoint: wrong hash - got %v, want %v", t.Errorf("NewOutPoint: wrong ID - got %v, want %v",
spew.Sprint(&prevOut.TxID), spew.Sprint(hash)) spew.Sprint(&prevOut.TxID), spew.Sprint(txID))
} }
if prevOut.Index != prevOutIndex { if prevOut.Index != prevOutIndex {
t.Errorf("NewOutPoint: wrong index - got %v, want %v", t.Errorf("NewOutPoint: wrong index - got %v, want %v",
prevOut.Index, prevOutIndex) prevOut.Index, prevOutIndex)
} }
prevOutStr := fmt.Sprintf("%s:%d", hash.String(), prevOutIndex) prevOutStr := fmt.Sprintf("%s:%d", txID.String(), prevOutIndex)
if s := prevOut.String(); s != prevOutStr { if s := prevOut.String(); s != prevOutStr {
t.Errorf("OutPoint.String: unexpected result - got %v, "+ t.Errorf("OutPoint.String: unexpected result - got %v, "+
"want %v", s, prevOutStr) "want %v", s, prevOutStr)
@ -130,8 +129,8 @@ func TestTx(t *testing.T) {
// TestTxHash tests the ability to generate the hash of a transaction accurately. // TestTxHash tests the ability to generate the hash of a transaction accurately.
func TestTxHashAndID(t *testing.T) { func TestTxHashAndID(t *testing.T) {
hash1Str := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa" txID1Str := "2d0dd1e05410fe76afbd90f577f615d603ca00b2fa53f963e6375ce742343faa"
wantHash1, err := daghash.NewHashFromStr(hash1Str) wantTxID1, err := daghash.NewTxIDFromStr(txID1Str)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewHashFromStr: %v", err)
return return
@ -141,7 +140,7 @@ func TestTxHashAndID(t *testing.T) {
tx1 := NewMsgTx(1) tx1 := NewMsgTx(1)
txIn := TxIn{ txIn := TxIn{
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}, SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
@ -169,16 +168,16 @@ func TestTxHashAndID(t *testing.T) {
// Ensure the hash produced is expected. // Ensure the hash produced is expected.
tx1Hash := tx1.TxHash() tx1Hash := tx1.TxHash()
if !tx1Hash.IsEqual(wantHash1) { if !tx1Hash.IsEqual((*daghash.Hash)(wantTxID1)) {
t.Errorf("TxHash: wrong hash - got %v, want %v", t.Errorf("TxHash: wrong hash - got %v, want %v",
spew.Sprint(tx1Hash), spew.Sprint(wantHash1)) spew.Sprint(tx1Hash), spew.Sprint(wantTxID1))
} }
// Ensure the TxID for coinbase transaction is the same as TxHash. // Ensure the TxID for coinbase transaction is the same as TxHash.
tx1ID := tx1.TxID() tx1ID := tx1.TxID()
if !tx1ID.IsEqual(wantHash1) { if !tx1ID.IsEqual(wantTxID1) {
t.Errorf("TxID: wrong ID - got %v, want %v", t.Errorf("TxID: wrong ID - got %v, want %v",
spew.Sprint(tx1ID), spew.Sprint(wantHash1)) spew.Sprint(tx1ID), spew.Sprint(wantTxID1))
} }
hash2Str := "ef55c85be28615b699bef1470d0d041982a6f3af5f900c978c3837b967b168b3" hash2Str := "ef55c85be28615b699bef1470d0d041982a6f3af5f900c978c3837b967b168b3"
@ -189,7 +188,7 @@ func TestTxHashAndID(t *testing.T) {
} }
id2Str := "12063f97b5fbbf441bd7962f88631a36a4b4a67649045c02ed840bedc97e88ea" id2Str := "12063f97b5fbbf441bd7962f88631a36a4b4a67649045c02ed840bedc97e88ea"
wantID2, err := daghash.NewHashFromStr(id2Str) wantID2, err := daghash.NewTxIDFromStr(id2Str)
if err != nil { if err != nil {
t.Errorf("NewHashFromStr: %v", err) t.Errorf("NewHashFromStr: %v", err)
return return
@ -200,7 +199,7 @@ func TestTxHashAndID(t *testing.T) {
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
Index: 0, Index: 0,
TxID: daghash.Hash{1, 2, 3}, TxID: daghash.TxID{1, 2, 3},
}, },
SignatureScript: []byte{ SignatureScript: []byte{
0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF,
@ -251,14 +250,14 @@ func TestTxHashAndID(t *testing.T) {
spew.Sprint(tx2ID), spew.Sprint(wantID2)) spew.Sprint(tx2ID), spew.Sprint(wantID2))
} }
if tx2ID.IsEqual(&tx2Hash) { if tx2ID.IsEqual((*daghash.TxID)(&tx2Hash)) {
t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload") t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload")
} }
tx2.Payload = []byte{} tx2.Payload = []byte{}
tx2.TxIn[0].SignatureScript = []byte{} tx2.TxIn[0].SignatureScript = []byte{}
newTx2Hash := tx2.TxHash() newTx2Hash := tx2.TxHash()
if !tx2ID.IsEqual(&newTx2Hash) { if !tx2ID.IsEqual((*daghash.TxID)(&newTx2Hash)) {
t.Errorf("tx2ID and newTx2Hash should be the same for transaction without empty signature and payload") t.Errorf("tx2ID and newTx2Hash should be the same for transaction without empty signature and payload")
} }
} }
@ -951,7 +950,7 @@ var multiTx = &MsgTx{
TxIn: []*TxIn{ TxIn: []*TxIn{
{ {
PreviousOutPoint: OutPoint{ PreviousOutPoint: OutPoint{
TxID: daghash.Hash{}, TxID: daghash.TxID{},
Index: 0xffffffff, Index: 0xffffffff,
}, },
SignatureScript: []byte{ SignatureScript: []byte{