770 lines
22 KiB
Go
770 lines
22 KiB
Go
// Copyright (c) 2015-2017 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package wtxmgr_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
"github.com/btcsuite/btcwallet/walletdb"
|
|
. "github.com/btcsuite/btcwallet/wtxmgr"
|
|
)
|
|
|
|
type queryState struct {
|
|
// slice items are ordered by height, mempool comes last.
|
|
blocks [][]TxDetails
|
|
txDetails map[chainhash.Hash][]TxDetails
|
|
}
|
|
|
|
func newQueryState() *queryState {
|
|
return &queryState{
|
|
txDetails: make(map[chainhash.Hash][]TxDetails),
|
|
}
|
|
}
|
|
|
|
func (q *queryState) deepCopy() *queryState {
|
|
cpy := newQueryState()
|
|
for _, blockDetails := range q.blocks {
|
|
var cpyDetails []TxDetails
|
|
for _, detail := range blockDetails {
|
|
cpyDetails = append(cpyDetails, *deepCopyTxDetails(&detail))
|
|
}
|
|
cpy.blocks = append(cpy.blocks, cpyDetails)
|
|
}
|
|
cpy.txDetails = make(map[chainhash.Hash][]TxDetails)
|
|
for txHash, details := range q.txDetails {
|
|
detailsSlice := make([]TxDetails, len(details))
|
|
for i, detail := range details {
|
|
detailsSlice[i] = *deepCopyTxDetails(&detail)
|
|
}
|
|
cpy.txDetails[txHash] = detailsSlice
|
|
}
|
|
return cpy
|
|
}
|
|
|
|
func deepCopyTxDetails(d *TxDetails) *TxDetails {
|
|
cpy := *d
|
|
cpy.MsgTx = *d.MsgTx.Copy()
|
|
if cpy.SerializedTx != nil {
|
|
cpy.SerializedTx = make([]byte, len(cpy.SerializedTx))
|
|
copy(cpy.SerializedTx, d.SerializedTx)
|
|
}
|
|
cpy.Credits = make([]CreditRecord, len(d.Credits))
|
|
copy(cpy.Credits, d.Credits)
|
|
cpy.Debits = make([]DebitRecord, len(d.Debits))
|
|
copy(cpy.Debits, d.Debits)
|
|
return &cpy
|
|
}
|
|
|
|
func (q *queryState) compare(t *testing.T, s *Store, ns walletdb.ReadBucket, changeDesc string) {
|
|
defer func() {
|
|
if t.Failed() {
|
|
t.Fatalf("Store state queries failed after '%s'", changeDesc)
|
|
}
|
|
}()
|
|
|
|
fwdBlocks := q.blocks
|
|
revBlocks := make([][]TxDetails, len(q.blocks))
|
|
copy(revBlocks, q.blocks)
|
|
for i := 0; i < len(revBlocks)/2; i++ {
|
|
revBlocks[i], revBlocks[len(revBlocks)-1-i] = revBlocks[len(revBlocks)-1-i], revBlocks[i]
|
|
}
|
|
checkBlock := func(blocks [][]TxDetails) func([]TxDetails) (bool, error) {
|
|
return func(got []TxDetails) (bool, error) {
|
|
if len(fwdBlocks) == 0 {
|
|
return false, fmt.Errorf("entered range when no more details expected")
|
|
}
|
|
exp := blocks[0]
|
|
if len(got) != len(exp) {
|
|
return false, fmt.Errorf("got len(details)=%d in transaction range, expected %d", len(got), len(exp))
|
|
}
|
|
for i := range got {
|
|
equalTxDetails(t, &got[i], &exp[i])
|
|
}
|
|
if t.Failed() {
|
|
return false, fmt.Errorf("Failed comparing range of transaction details")
|
|
}
|
|
blocks = blocks[1:]
|
|
return false, nil
|
|
}
|
|
}
|
|
err := s.RangeTransactions(ns, 0, -1, checkBlock(fwdBlocks))
|
|
if err != nil {
|
|
t.Fatalf("Failed in RangeTransactions (forwards iteration): %v", err)
|
|
}
|
|
err = s.RangeTransactions(ns, -1, 0, checkBlock(revBlocks))
|
|
if err != nil {
|
|
t.Fatalf("Failed in RangeTransactions (reverse iteration): %v", err)
|
|
}
|
|
|
|
for txHash, details := range q.txDetails {
|
|
for _, detail := range details {
|
|
blk := &detail.Block.Block
|
|
if blk.Height == -1 {
|
|
blk = nil
|
|
}
|
|
d, err := s.UniqueTxDetails(ns, &txHash, blk)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if d == nil {
|
|
t.Errorf("Found no matching transaction at height %d", detail.Block.Height)
|
|
continue
|
|
}
|
|
equalTxDetails(t, d, &detail)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatalf("Failed querying unique details regarding transaction %v", txHash)
|
|
}
|
|
|
|
// For the most recent tx with this hash, check that
|
|
// TxDetails (not looking up a tx at any particular
|
|
// height) matches the last.
|
|
detail := &details[len(details)-1]
|
|
d, err := s.TxDetails(ns, &txHash)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
equalTxDetails(t, d, detail)
|
|
if t.Failed() {
|
|
t.Fatalf("Failed querying latest details regarding transaction %v", txHash)
|
|
}
|
|
}
|
|
}
|
|
|
|
func equalTxDetails(t *testing.T, got, exp *TxDetails) {
|
|
// Need to avoid using reflect.DeepEqual against slices, since it
|
|
// returns false for nil vs non-nil zero length slices.
|
|
|
|
equalTxs(t, &got.MsgTx, &exp.MsgTx)
|
|
if got.Hash != exp.Hash {
|
|
t.Errorf("Found mismatched hashes")
|
|
t.Errorf("Got: %v", got.Hash)
|
|
t.Errorf("Expected: %v", exp.Hash)
|
|
}
|
|
if got.Received != exp.Received {
|
|
t.Errorf("Found mismatched receive time")
|
|
t.Errorf("Got: %v", got.Received)
|
|
t.Errorf("Expected: %v", exp.Received)
|
|
}
|
|
if !bytes.Equal(got.SerializedTx, exp.SerializedTx) {
|
|
t.Errorf("Found mismatched serialized txs")
|
|
t.Errorf("Got: %x", got.SerializedTx)
|
|
t.Errorf("Expected: %x", exp.SerializedTx)
|
|
}
|
|
if got.Block != exp.Block {
|
|
t.Errorf("Found mismatched block meta")
|
|
t.Errorf("Got: %v", got.Block)
|
|
t.Errorf("Expected: %v", exp.Block)
|
|
}
|
|
if len(got.Credits) != len(exp.Credits) {
|
|
t.Errorf("Credit slice lengths differ: Got %d Expected %d", len(got.Credits), len(exp.Credits))
|
|
} else {
|
|
for i := range got.Credits {
|
|
if got.Credits[i] != exp.Credits[i] {
|
|
t.Errorf("Found mismatched Credit[%d]", i)
|
|
t.Errorf("Got: %v", got.Credits[i])
|
|
t.Errorf("Expected: %v", exp.Credits[i])
|
|
}
|
|
}
|
|
}
|
|
if len(got.Debits) != len(exp.Debits) {
|
|
t.Errorf("Debit slice lengths differ: Got %d Expected %d", len(got.Debits), len(exp.Debits))
|
|
} else {
|
|
for i := range got.Debits {
|
|
if got.Debits[i] != exp.Debits[i] {
|
|
t.Errorf("Found mismatched Debit[%d]", i)
|
|
t.Errorf("Got: %v", got.Debits[i])
|
|
t.Errorf("Expected: %v", exp.Debits[i])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func equalTxs(t *testing.T, got, exp *wire.MsgTx) {
|
|
var bufGot, bufExp bytes.Buffer
|
|
err := got.Serialize(&bufGot)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = exp.Serialize(&bufExp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(bufGot.Bytes(), bufExp.Bytes()) {
|
|
t.Errorf("Found unexpected wire.MsgTx:")
|
|
t.Errorf("Got: %v", got)
|
|
t.Errorf("Expected: %v", exp)
|
|
}
|
|
}
|
|
|
|
// Returns time.Now() with seconds resolution, this is what Store saves.
|
|
func timeNow() time.Time {
|
|
return time.Unix(time.Now().Unix(), 0)
|
|
}
|
|
|
|
// Returns a copy of a TxRecord without the serialized tx.
|
|
func stripSerializedTx(rec *TxRecord) *TxRecord {
|
|
ret := *rec
|
|
ret.SerializedTx = nil
|
|
return &ret
|
|
}
|
|
|
|
func makeBlockMeta(height int32) BlockMeta {
|
|
if height == -1 {
|
|
return BlockMeta{Block: Block{Height: -1}}
|
|
}
|
|
|
|
b := BlockMeta{
|
|
Block: Block{Height: height},
|
|
Time: timeNow(),
|
|
}
|
|
// Give it a fake block hash created from the height and time.
|
|
binary.LittleEndian.PutUint32(b.Hash[0:4], uint32(height))
|
|
binary.LittleEndian.PutUint64(b.Hash[4:12], uint64(b.Time.Unix()))
|
|
return b
|
|
}
|
|
|
|
func TestStoreQueries(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type queryTest struct {
|
|
desc string
|
|
updates func(ns walletdb.ReadWriteBucket) // Unwinds from t.Fatal if the update errors.
|
|
state *queryState
|
|
}
|
|
var tests []queryTest
|
|
|
|
// Create the store and test initial state.
|
|
s, db, teardown, err := testStore()
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
lastState := newQueryState()
|
|
tests = append(tests, queryTest{
|
|
desc: "initial store",
|
|
updates: func(walletdb.ReadWriteBucket) {},
|
|
state: lastState,
|
|
})
|
|
|
|
// simplify error handling
|
|
insertTx := func(ns walletdb.ReadWriteBucket, rec *TxRecord, block *BlockMeta) {
|
|
err := s.InsertTx(ns, rec, block)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
addCredit := func(s *Store, ns walletdb.ReadWriteBucket, rec *TxRecord, block *BlockMeta, index uint32, change bool) {
|
|
err := s.AddCredit(ns, rec, block, index, change)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
newTxRecordFromMsgTx := func(tx *wire.MsgTx, received time.Time) *TxRecord {
|
|
rec, err := NewTxRecordFromMsgTx(tx, received)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return rec
|
|
}
|
|
rollback := func(ns walletdb.ReadWriteBucket, height int32) {
|
|
err := s.Rollback(ns, height)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Insert an unmined transaction. Mark no credits yet.
|
|
txA := spendOutput(&chainhash.Hash{}, 0, 100e8)
|
|
recA := newTxRecordFromMsgTx(txA, timeNow())
|
|
newState := lastState.deepCopy()
|
|
newState.blocks = [][]TxDetails{
|
|
{
|
|
{
|
|
TxRecord: *stripSerializedTx(recA),
|
|
Block: BlockMeta{Block: Block{Height: -1}},
|
|
},
|
|
},
|
|
}
|
|
newState.txDetails[recA.Hash] = []TxDetails{
|
|
newState.blocks[0][0],
|
|
}
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "insert tx A unmined",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recA, nil) },
|
|
state: newState,
|
|
})
|
|
|
|
// Add txA:0 as a change credit.
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0][0].Credits = []CreditRecord{
|
|
{
|
|
Index: 0,
|
|
Amount: btcutil.Amount(recA.MsgTx.TxOut[0].Value),
|
|
Spent: false,
|
|
Change: true,
|
|
},
|
|
}
|
|
newState.txDetails[recA.Hash][0].Credits = newState.blocks[0][0].Credits
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "mark unconfirmed txA:0 as credit",
|
|
updates: func(ns walletdb.ReadWriteBucket) { addCredit(s, ns, recA, nil, 0, true) },
|
|
state: newState,
|
|
})
|
|
|
|
// Insert another unmined transaction which spends txA:0, splitting the
|
|
// amount into outputs of 40 and 60 BTC.
|
|
txB := spendOutput(&recA.Hash, 0, 40e8, 60e8)
|
|
recB := newTxRecordFromMsgTx(txB, timeNow())
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0][0].Credits[0].Spent = true
|
|
newState.blocks[0] = append(newState.blocks[0], TxDetails{
|
|
TxRecord: *stripSerializedTx(recB),
|
|
Block: BlockMeta{Block: Block{Height: -1}},
|
|
Debits: []DebitRecord{
|
|
{
|
|
Amount: btcutil.Amount(recA.MsgTx.TxOut[0].Value),
|
|
Index: 0, // recB.MsgTx.TxIn index
|
|
},
|
|
},
|
|
})
|
|
newState.txDetails[recA.Hash][0].Credits[0].Spent = true
|
|
newState.txDetails[recB.Hash] = []TxDetails{newState.blocks[0][1]}
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "insert tx B unmined",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recB, nil) },
|
|
state: newState,
|
|
})
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0][1].Credits = []CreditRecord{
|
|
{
|
|
Index: 0,
|
|
Amount: btcutil.Amount(recB.MsgTx.TxOut[0].Value),
|
|
Spent: false,
|
|
Change: false,
|
|
},
|
|
}
|
|
newState.txDetails[recB.Hash][0].Credits = newState.blocks[0][1].Credits
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "mark txB:0 as non-change credit",
|
|
updates: func(ns walletdb.ReadWriteBucket) { addCredit(s, ns, recB, nil, 0, false) },
|
|
state: newState,
|
|
})
|
|
|
|
// Mine tx A at block 100. Leave tx B unmined.
|
|
b100 := makeBlockMeta(100)
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0] = newState.blocks[0][:1]
|
|
newState.blocks[0][0].Block = b100
|
|
newState.blocks = append(newState.blocks, lastState.blocks[0][1:])
|
|
newState.txDetails[recA.Hash][0].Block = b100
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "mine tx A",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recA, &b100) },
|
|
state: newState,
|
|
})
|
|
|
|
// Mine tx B at block 101.
|
|
b101 := makeBlockMeta(101)
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[1][0].Block = b101
|
|
newState.txDetails[recB.Hash][0].Block = b101
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "mine tx B",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recB, &b101) },
|
|
state: newState,
|
|
})
|
|
|
|
for _, tst := range tests {
|
|
err := walletdb.Update(db, func(tx walletdb.ReadWriteTx) error {
|
|
ns := tx.ReadWriteBucket(namespaceKey)
|
|
tst.updates(ns)
|
|
tst.state.compare(t, s, ns, tst.desc)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// Run some additional query tests with the current store's state:
|
|
// - Verify that querying for a transaction not in the store returns
|
|
// nil without failure.
|
|
// - Verify that querying for a unique transaction at the wrong block
|
|
// returns nil without failure.
|
|
// - Verify that breaking early on RangeTransactions stops further
|
|
// iteration.
|
|
|
|
err = walletdb.Update(db, func(tx walletdb.ReadWriteTx) error {
|
|
ns := tx.ReadWriteBucket(namespaceKey)
|
|
|
|
missingTx := spendOutput(&recB.Hash, 0, 40e8)
|
|
missingRec := newTxRecordFromMsgTx(missingTx, timeNow())
|
|
missingBlock := makeBlockMeta(102)
|
|
missingDetails, err := s.TxDetails(ns, &missingRec.Hash)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if missingDetails != nil {
|
|
t.Errorf("Expected no details, found details for tx %v", missingDetails.Hash)
|
|
}
|
|
missingUniqueTests := []struct {
|
|
hash *chainhash.Hash
|
|
block *Block
|
|
}{
|
|
{&missingRec.Hash, &b100.Block},
|
|
{&missingRec.Hash, &missingBlock.Block},
|
|
{&missingRec.Hash, nil},
|
|
{&recB.Hash, &b100.Block},
|
|
{&recB.Hash, &missingBlock.Block},
|
|
{&recB.Hash, nil},
|
|
}
|
|
for _, tst := range missingUniqueTests {
|
|
missingDetails, err = s.UniqueTxDetails(ns, tst.hash, tst.block)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if missingDetails != nil {
|
|
t.Errorf("Expected no details, found details for tx %v", missingDetails.Hash)
|
|
}
|
|
}
|
|
|
|
iterations := 0
|
|
err = s.RangeTransactions(ns, 0, -1, func([]TxDetails) (bool, error) {
|
|
iterations++
|
|
return true, nil
|
|
})
|
|
if iterations != 1 {
|
|
t.Errorf("RangeTransactions (forwards) ran func %d times", iterations)
|
|
}
|
|
iterations = 0
|
|
err = s.RangeTransactions(ns, -1, 0, func([]TxDetails) (bool, error) {
|
|
iterations++
|
|
return true, nil
|
|
})
|
|
if iterations != 1 {
|
|
t.Errorf("RangeTransactions (reverse) ran func %d times", iterations)
|
|
}
|
|
// Make sure it also breaks early after one iteration through unmined transactions.
|
|
rollback(ns, b101.Height)
|
|
iterations = 0
|
|
err = s.RangeTransactions(ns, -1, 0, func([]TxDetails) (bool, error) {
|
|
iterations++
|
|
return true, nil
|
|
})
|
|
if iterations != 1 {
|
|
t.Errorf("RangeTransactions (reverse) ran func %d times", iterations)
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// None of the above tests have tested RangeTransactions with multiple
|
|
// txs per block, so do that now. Start by moving tx B to block 100
|
|
// (same block as tx A), and then rollback from block 100 onwards so
|
|
// both are unmined.
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0] = append(newState.blocks[0], newState.blocks[1]...)
|
|
newState.blocks[0][1].Block = b100
|
|
newState.blocks = newState.blocks[:1]
|
|
newState.txDetails[recB.Hash][0].Block = b100
|
|
lastState = newState
|
|
tests = append(tests[:0:0], queryTest{
|
|
desc: "move tx B to block 100",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recB, &b100) },
|
|
state: newState,
|
|
})
|
|
newState = lastState.deepCopy()
|
|
newState.blocks[0][0].Block = makeBlockMeta(-1)
|
|
newState.blocks[0][1].Block = makeBlockMeta(-1)
|
|
newState.txDetails[recA.Hash][0].Block = makeBlockMeta(-1)
|
|
newState.txDetails[recB.Hash][0].Block = makeBlockMeta(-1)
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "rollback block 100",
|
|
updates: func(ns walletdb.ReadWriteBucket) { rollback(ns, b100.Height) },
|
|
state: newState,
|
|
})
|
|
|
|
// None of the above tests have tested transactions with colliding
|
|
// hashes, so mine tx A in block 100, and then insert tx A again
|
|
// unmined. Also mine tx A in block 101 (this moves it from unmined).
|
|
// This is a valid test because the store does not perform signature
|
|
// validation or keep a full utxo set, and duplicated transaction hashes
|
|
// from different blocks are allowed so long as all previous outputs are
|
|
// spent.
|
|
newState = lastState.deepCopy()
|
|
newState.blocks = append(newState.blocks, newState.blocks[0][1:])
|
|
newState.blocks[0] = newState.blocks[0][:1:1]
|
|
newState.blocks[0][0].Block = b100
|
|
newState.blocks[1] = []TxDetails{
|
|
{
|
|
TxRecord: *stripSerializedTx(recA),
|
|
Block: makeBlockMeta(-1),
|
|
},
|
|
newState.blocks[1][0],
|
|
}
|
|
newState.txDetails[recA.Hash][0].Block = b100
|
|
newState.txDetails[recA.Hash] = append(newState.txDetails[recA.Hash], newState.blocks[1][0])
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "insert duplicate tx A",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recA, &b100); insertTx(ns, recA, nil) },
|
|
state: newState,
|
|
})
|
|
newState = lastState.deepCopy()
|
|
newState.blocks = [][]TxDetails{
|
|
newState.blocks[0],
|
|
{newState.blocks[1][0]},
|
|
{newState.blocks[1][1]},
|
|
}
|
|
newState.blocks[1][0].Block = b101
|
|
newState.txDetails[recA.Hash][1].Block = b101
|
|
lastState = newState
|
|
tests = append(tests, queryTest{
|
|
desc: "mine duplicate tx A",
|
|
updates: func(ns walletdb.ReadWriteBucket) { insertTx(ns, recA, &b101) },
|
|
state: newState,
|
|
})
|
|
|
|
for _, tst := range tests {
|
|
err := walletdb.Update(db, func(tx walletdb.ReadWriteTx) error {
|
|
ns := tx.ReadWriteBucket(namespaceKey)
|
|
tst.updates(ns)
|
|
tst.state.compare(t, s, ns, tst.desc)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPreviousPkScripts(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
s, db, teardown, err := testStore()
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Invalid scripts but sufficient for testing.
|
|
var (
|
|
scriptA0 = []byte("tx A output 0")
|
|
scriptA1 = []byte("tx A output 1")
|
|
scriptB0 = []byte("tx B output 0")
|
|
scriptB1 = []byte("tx B output 1")
|
|
scriptC0 = []byte("tx C output 0")
|
|
scriptC1 = []byte("tx C output 1")
|
|
)
|
|
|
|
// Create a transaction spending two prevous outputs and generating two
|
|
// new outputs the passed pkScipts. Spends outputs 0 and 1 from prevHash.
|
|
buildTx := func(prevHash *chainhash.Hash, script0, script1 []byte) *wire.MsgTx {
|
|
return &wire.MsgTx{
|
|
TxIn: []*wire.TxIn{
|
|
{PreviousOutPoint: wire.OutPoint{
|
|
Hash: *prevHash,
|
|
Index: 0,
|
|
}},
|
|
{PreviousOutPoint: wire.OutPoint{
|
|
Hash: *prevHash, Index: 1,
|
|
}},
|
|
},
|
|
TxOut: []*wire.TxOut{
|
|
{Value: 1e8, PkScript: script0},
|
|
{Value: 1e8, PkScript: script1},
|
|
},
|
|
}
|
|
}
|
|
|
|
newTxRecordFromMsgTx := func(tx *wire.MsgTx) *TxRecord {
|
|
rec, err := NewTxRecordFromMsgTx(tx, timeNow())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return rec
|
|
}
|
|
|
|
// Create transactions with the fake output scripts.
|
|
var (
|
|
txA = buildTx(&chainhash.Hash{}, scriptA0, scriptA1)
|
|
recA = newTxRecordFromMsgTx(txA)
|
|
txB = buildTx(&recA.Hash, scriptB0, scriptB1)
|
|
recB = newTxRecordFromMsgTx(txB)
|
|
txC = buildTx(&recB.Hash, scriptC0, scriptC1)
|
|
recC = newTxRecordFromMsgTx(txC)
|
|
txD = buildTx(&recC.Hash, nil, nil)
|
|
recD = newTxRecordFromMsgTx(txD)
|
|
)
|
|
|
|
insertTx := func(ns walletdb.ReadWriteBucket, rec *TxRecord, block *BlockMeta) {
|
|
err := s.InsertTx(ns, rec, block)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
addCredit := func(ns walletdb.ReadWriteBucket, rec *TxRecord, block *BlockMeta, index uint32) {
|
|
err := s.AddCredit(ns, rec, block, index, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
type scriptTest struct {
|
|
rec *TxRecord
|
|
block *Block
|
|
scripts [][]byte
|
|
}
|
|
runTest := func(ns walletdb.ReadWriteBucket, tst *scriptTest) {
|
|
scripts, err := s.PreviousPkScripts(ns, tst.rec, tst.block)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
height := int32(-1)
|
|
if tst.block != nil {
|
|
height = tst.block.Height
|
|
}
|
|
if len(scripts) != len(tst.scripts) {
|
|
t.Errorf("Transaction %v height %d: got len(scripts)=%d, expected %d",
|
|
tst.rec.Hash, height, len(scripts), len(tst.scripts))
|
|
return
|
|
}
|
|
for i := range scripts {
|
|
if !bytes.Equal(scripts[i], tst.scripts[i]) {
|
|
// Format scripts with %s since they are (should be) ascii.
|
|
t.Errorf("Transaction %v height %d script %d: got '%s' expected '%s'",
|
|
tst.rec.Hash, height, i, scripts[i], tst.scripts[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
dbtx, err := db.BeginReadWriteTx()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer dbtx.Commit()
|
|
ns := dbtx.ReadWriteBucket(namespaceKey)
|
|
|
|
// Insert transactions A-C unmined, but mark no credits yet. Until
|
|
// these are marked as credits, PreviousPkScripts should not return
|
|
// them.
|
|
insertTx(ns, recA, nil)
|
|
insertTx(ns, recB, nil)
|
|
insertTx(ns, recC, nil)
|
|
|
|
b100 := makeBlockMeta(100)
|
|
b101 := makeBlockMeta(101)
|
|
|
|
tests := []scriptTest{
|
|
{recA, nil, nil},
|
|
{recA, &b100.Block, nil},
|
|
{recB, nil, nil},
|
|
{recB, &b100.Block, nil},
|
|
{recC, nil, nil},
|
|
{recC, &b100.Block, nil},
|
|
}
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after unmined tx inserts")
|
|
}
|
|
|
|
// Mark credits. Tx C output 1 not marked as a credit: tx D will spend
|
|
// both later but when C is mined, output 1's script should not be
|
|
// returned.
|
|
addCredit(ns, recA, nil, 0)
|
|
addCredit(ns, recA, nil, 1)
|
|
addCredit(ns, recB, nil, 0)
|
|
addCredit(ns, recB, nil, 1)
|
|
addCredit(ns, recC, nil, 0)
|
|
tests = []scriptTest{
|
|
{recA, nil, nil},
|
|
{recA, &b100.Block, nil},
|
|
{recB, nil, [][]byte{scriptA0, scriptA1}},
|
|
{recB, &b100.Block, nil},
|
|
{recC, nil, [][]byte{scriptB0, scriptB1}},
|
|
{recC, &b100.Block, nil},
|
|
}
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after marking unmined credits")
|
|
}
|
|
|
|
// Mine tx A in block 100. Test results should be identical.
|
|
insertTx(ns, recA, &b100)
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after mining tx A")
|
|
}
|
|
|
|
// Mine tx B in block 101.
|
|
insertTx(ns, recB, &b101)
|
|
tests = []scriptTest{
|
|
{recA, nil, nil},
|
|
{recA, &b100.Block, nil},
|
|
{recB, nil, nil},
|
|
{recB, &b101.Block, [][]byte{scriptA0, scriptA1}},
|
|
{recC, nil, [][]byte{scriptB0, scriptB1}},
|
|
{recC, &b101.Block, nil},
|
|
}
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after mining tx B")
|
|
}
|
|
|
|
// Mine tx C in block 101 (same block as tx B) to test debits from the
|
|
// same block.
|
|
insertTx(ns, recC, &b101)
|
|
tests = []scriptTest{
|
|
{recA, nil, nil},
|
|
{recA, &b100.Block, nil},
|
|
{recB, nil, nil},
|
|
{recB, &b101.Block, [][]byte{scriptA0, scriptA1}},
|
|
{recC, nil, nil},
|
|
{recC, &b101.Block, [][]byte{scriptB0, scriptB1}},
|
|
}
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after mining tx C")
|
|
}
|
|
|
|
// Insert tx D, which spends C:0 and C:1. However, only C:0 is marked
|
|
// as a credit, and only that output script should be returned.
|
|
insertTx(ns, recD, nil)
|
|
tests = append(tests, scriptTest{recD, nil, [][]byte{scriptC0}})
|
|
tests = append(tests, scriptTest{recD, &b101.Block, nil})
|
|
for _, tst := range tests {
|
|
runTest(ns, &tst)
|
|
}
|
|
if t.Failed() {
|
|
t.Fatal("Failed after inserting tx D")
|
|
}
|
|
}
|