// safePut is used to put a value into an immutable ticket treap, returning
// the mutated, immutable treap given as a result. It first checks to see if
// there is already this key in the treap. If there is, it returns an error.
// TODO This function could also check to make sure the states of the ticket
// treap value are valid.
func safePut(t *tickettreap.Immutable, k tickettreap.Key, v *tickettreap.Value) (*tickettreap.Immutable, error) {
if t.Has(k) {
return nil, stakeRuleError(ErrDuplicateTicket, fmt.Sprintf("attempted "+
"to insert duplicate key %v into treap", chainhash.Hash(k)))
}
return t.Put(k, v), nil
}
// safeDelete is used to delete a value in an immutable ticket treap, returning
// the mutated, immutable treap given as a result. It first checks to see if
// the key exists in the treap. If it does not, it returns an error.
func safeDelete(t *tickettreap.Immutable, k tickettreap.Key) (*tickettreap.Immutable, error) {
if !t.Has(k) {
return nil, stakeRuleError(ErrMissingTicket, fmt.Sprintf("attempted to "+
"delete non-existing key %v from treap", chainhash.Hash(k)))
}
return t.Delete(k), nil
}
// MissedTickets returns the list of missed tickets for this stake node.
func (sn *Node) MissedTickets() []chainhash.Hash {
tickets := make([]chainhash.Hash, sn.missedTickets.Len())
i := 0
sn.missedTickets.ForEach(func(k tickettreap.Key, v *tickettreap.Value) bool {
tickets[i] = chainhash.Hash(k)
i++
return true
})
return tickets
}
// RevokedTickets returns the list of revoked tickets for this stake node.
func (sn *Node) RevokedTickets() []*chainhash.Hash {
tickets := make([]*chainhash.Hash, sn.revokedTickets.Len())
i := 0
sn.revokedTickets.ForEach(func(k tickettreap.Key, v *tickettreap.Value) bool {
h := chainhash.Hash(k)
tickets[i] = &h
i++
return true
})
return tickets
}
// findDifferences finds individual differences in two treaps and prints
// them. For use in debugging.
func findDifferences(a *tickettreap.Immutable, b *tickettreap.Immutable) {
aMap := make(map[tickettreap.Key]*tickettreap.Value)
a.ForEach(func(k tickettreap.Key, v *tickettreap.Value) bool {
aMap[k] = v
return true
})
bMap := make(map[tickettreap.Key]*tickettreap.Value)
b.ForEach(func(k tickettreap.Key, v *tickettreap.Value) bool {
bMap[k] = v
return true
})
for k, v := range aMap {
h := chainhash.Hash(k)
vB := bMap[k]
if vB == nil {
fmt.Printf("Second map missing key %v\n", h)
} else {
if *v != *vB {
fmt.Printf("Second map val for %v is %v, first map %v\n", h,
vB, v)
}
}
}
for k, v := range bMap {
h := chainhash.Hash(k)
vA := aMap[k]
if vA == nil {
fmt.Printf("First map missing key %v\n", h)
} else {
if *v != *vA {
fmt.Printf("First map val for %v is %v, second map %v\n", h,
vA, v)
}
}
}
}
// TestShaHashString tests the stringized output for sha hashes.
func TestShaHashString(t *testing.T) {
// Block 100000 hash.
wantStr := "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
hash := chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x06, 0xe5, 0x33, 0xfd, 0x1a, 0xda, 0x86, 0x39,
0x1f, 0x3f, 0x6c, 0x34, 0x32, 0x04, 0xb0, 0xd2,
0x78, 0xd4, 0xaa, 0xec, 0x1c, 0x0b, 0x20, 0xaa,
0x27, 0xba, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
})
hashStr := hash.String()
if hashStr != wantStr {
t.Errorf("String: wrong hash string - got %v, want %v",
hashStr, wantStr)
}
}
// TestInvalidFlagCombinations ensures the script engine returns the expected
// error when disallowed flag combinations are specified.
func TestInvalidFlagCombinations(t *testing.T) {
t.Parallel()
tests := []txscript.ScriptFlags{
txscript.ScriptVerifyCleanStack,
}
// tx with almost empty scripts.
tx := &wire.MsgTx{
Version: 1,
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a,
0x85, 0x2d, 0xd9, 0x06,
0x60, 0xa2, 0x0b, 0x2d,
0x9c, 0x35, 0x24, 0x23,
0xed, 0xce, 0x25, 0x85,
0x7f, 0xcd, 0x37, 0x04,
}),
Index: 0,
},
SignatureScript: []uint8{txscript.OP_NOP},
Sequence: 4294967295,
},
},
TxOut: []*wire.TxOut{
{
Value: 1000000000,
PkScript: nil,
},
},
LockTime: 0,
}
pkScript := []byte{txscript.OP_NOP}
for i, test := range tests {
_, err := txscript.NewEngine(pkScript, tx, 0, test, 0, nil)
if err != txscript.ErrInvalidFlags {
t.Fatalf("TestInvalidFlagCombinations #%d unexpected "+
"error: %v", i, err)
}
}
}
// safeGet fetches a pointer to the data for the key in the treap, then
// copies the value so that the original pointer to the key is never written
// to accidentally later.
// TODO This function could also check to make sure the states of the ticket
// treap value are valid.
func safeGet(t *tickettreap.Immutable, k tickettreap.Key) (*tickettreap.Value, error) {
v := t.Get(k)
if v == nil {
h := chainhash.Hash(k)
return nil, stakeRuleError(ErrMissingTicket, fmt.Sprintf(
"ticket %v was supposed to be in the passed "+
"treap, but could not be found", h))
}
return &tickettreap.Value{
Height: v.Height,
Missed: v.Missed,
Revoked: v.Revoked,
Spent: v.Spent,
Expired: v.Expired,
}, nil
}
// TestBadPC sets the pc to a deliberately bad result then confirms that Step()
// and Disasm fail correctly.
func TestBadPC(t *testing.T) {
t.Parallel()
type pcTest struct {
script, off int
}
pcTests := []pcTest{
{
script: 2,
off: 0,
},
{
script: 0,
off: 2,
},
}
// tx with almost empty scripts.
tx := &wire.MsgTx{
Version: 1,
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a,
0x85, 0x2d, 0xd9, 0x06,
0x60, 0xa2, 0x0b, 0x2d,
0x9c, 0x35, 0x24, 0x23,
0xed, 0xce, 0x25, 0x85,
0x7f, 0xcd, 0x37, 0x04,
}),
Index: 0,
},
SignatureScript: []uint8{txscript.OP_NOP},
Sequence: 4294967295,
},
},
TxOut: []*wire.TxOut{
{
Value: 1000000000,
PkScript: nil,
},
},
LockTime: 0,
}
pkScript := []byte{txscript.OP_NOP}
for _, test := range pcTests {
vm, err := txscript.NewEngine(pkScript, tx, 0, 0, 0, nil)
if err != nil {
t.Errorf("Failed to create script: %v", err)
}
// set to after all scripts
vm.TstSetPC(test.script, test.off)
_, err = vm.Step()
if err == nil {
t.Errorf("Step with invalid pc (%v) succeeds!", test)
continue
}
_, err = vm.DisasmPC()
if err == nil {
t.Errorf("DisasmPC with invalid pc (%v) succeeds!",
test)
}
}
}
"io"
"reflect"
"strings"
"testing"
"github.com/davecgh/go-spew/spew"
"github.com/decred/dcrd/chaincfg/chainhash"
"github.com/decred/dcrd/wire"
)
// mainNetGenesisHash is the hash of the first block in the block chain for the
// main network (genesis block).
var mainNetGenesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
})
// mainNetGenesisMerkleRoot is the hash of the first transaction in the genesis
// block for the main network.
var mainNetGenesisMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2,
0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
})
// fakeRandReader implements the io.Reader interface and is used to force
// errors in the RandomUint64 function.
type fakeRandReader struct {
Expiry: 0,
}
// simNetGenesisMerkleRoot is the hash of the first transaction in the genesis
// block for the simulation test network. It is the same as the merkle root for
// the main network.
var simNetGenesisMerkleRoot = genesisMerkleRoot
// simNetGenesisBlock defines the genesis block of the block chain which serves
// as the public transaction ledger for the simulation test network.
var simNetGenesisBlock = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
PrevBlock: chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}),
MerkleRoot: simNetGenesisMerkleRoot,
StakeRoot: chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}),
VoteBits: uint16(0x0000),
FinalState: [6]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
Voters: uint16(0x0000),
FreshStake: uint8(0x00),
Revocations: uint8(0x00),
Timestamp: time.Unix(1401292357, 0), // 2009-01-08 20:54:25 -0600 CST
b.SetBlockBytes(shortBytes)
_, _, err = b.TxLoc()
if err != io.EOF {
t.Errorf("TxLoc: did not get expected error - "+
"got %v, want %v", err, io.EOF)
}
}
// Block100000 defines block 100,000 of the block chain. It is used to
// test Block operations.
var Block100000 = wire.MsgBlock{
Header: wire.BlockHeader{
Version: 1,
PrevBlock: chainhash.Hash([32]byte{ // Make go vet happy.
0x50, 0x12, 0x01, 0x19, 0x17, 0x2a, 0x61, 0x04,
0x21, 0xa6, 0xc3, 0x01, 0x1d, 0xd3, 0x30, 0xd9,
0xdf, 0x07, 0xb6, 0x36, 0x16, 0xc2, 0xcc, 0x1f,
0x1c, 0xd0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
}), // 000000000002d01c1fccc21636b607dfd930d31d01c3a62104612a1719011250
MerkleRoot: chainhash.Hash([32]byte{ // Make go vet happy.
0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
}), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
Timestamp: time.Unix(1293623863, 0), // 2010-12-29 11:57:43 +0000 UTC
Bits: 0x1b04864c, // 453281356
Nonce: 0x10572b0f, // 274148111
},
Transactions: []*wire.MsgTx{
{
Version: 1,
// TestLiveDatabase tests various functions that require a live database.
func TestLiveDatabase(t *testing.T) {
// Create a new database to store the accepted stake node data into.
dbName := "ffldb_ticketdb_test"
dbPath := filepath.Join(testDbRoot, dbName)
_ = os.RemoveAll(dbPath)
testDb, err := database.Create(testDbType, dbPath, chaincfg.SimNetParams.Net)
if err != nil {
t.Fatalf("error creating db: %v", err)
}
// Setup a teardown.
defer os.RemoveAll(dbPath)
defer os.RemoveAll(testDbRoot)
defer testDb.Close()
// Initialize the database, then try to read the version.
err = testDb.Update(func(dbTx database.Tx) error {
return DbCreate(dbTx)
})
if err != nil {
t.Fatalf("%v", err.Error())
}
var dbi *DatabaseInfo
err = testDb.View(func(dbTx database.Tx) error {
dbi, err = DbFetchDatabaseInfo(dbTx)
if err != nil {
return err
}
return nil
})
if err != nil {
t.Fatalf("%v", err.Error())
}
if dbi.Version != currentDatabaseVersion {
t.Fatalf("bad version after reading from DB; want %v, got %v",
currentDatabaseVersion, dbi.Version)
}
// Test storing arbitrary ticket treaps.
ticketMap := make(map[tickettreap.Key]*tickettreap.Value)
tickets := make([]chainhash.Hash, 5)
for i := 0; i < 4; i++ {
h := chainhash.HashFuncH(bytes.Repeat([]byte{0x01}, i))
ticketMap[tickettreap.Key(h)] = &tickettreap.Value{
Height: 12345 + uint32(i),
Missed: i%2 == 0,
Revoked: i%2 != 0,
Spent: i%2 == 0,
Expired: i%2 != 0,
}
tickets[i] = h
}
err = testDb.Update(func(dbTx database.Tx) error {
for k, v := range ticketMap {
h := chainhash.Hash(k)
err = DbPutTicket(dbTx, dbnamespace.LiveTicketsBucketName, &h,
v.Height, v.Missed, v.Revoked, v.Spent, v.Expired)
if err != nil {
return err
}
}
return nil
})
if err != nil {
t.Fatalf("%v", err.Error())
}
var treap *tickettreap.Immutable
ticketMap2 := make(map[tickettreap.Key]*tickettreap.Value)
err = testDb.View(func(dbTx database.Tx) error {
treap, err = DbLoadAllTickets(dbTx, dbnamespace.LiveTicketsBucketName)
if err != nil {
return err
}
return nil
})
if err != nil {
t.Fatalf("%v", err.Error())
}
treap.ForEach(func(k tickettreap.Key, v *tickettreap.Value) bool {
ticketMap2[k] = v
return true
})
if !reflect.DeepEqual(ticketMap, ticketMap2) {
t.Fatalf("not same ticket maps")
}
}
func TestTicketDBLongChain(t *testing.T) {
// Declare some useful variables.
testBCHeight := int64(1001)
filename := filepath.Join("..", "/../blockchain/testdata", "testexpiry.bz2")
fi, err := os.Open(filename)
bcStream := bzip2.NewReader(fi)
defer fi.Close()
// Create a buffer of the read file.
bcBuf := new(bytes.Buffer)
bcBuf.ReadFrom(bcStream)
// Create decoder from the buffer and a map to store the data.
bcDecoder := gob.NewDecoder(bcBuf)
testBlockchainBytes := make(map[int64][]byte)
// Decode the blockchain into the map.
if err := bcDecoder.Decode(&testBlockchainBytes); err != nil {
t.Errorf("error decoding test blockchain")
}
testBlockchain := make(map[int64]*dcrutil.Block, len(testBlockchainBytes))
for k, v := range testBlockchainBytes {
bl, err := dcrutil.NewBlockFromBytes(v)
if err != nil {
t.Fatalf("couldn't decode block")
}
testBlockchain[k] = bl
}
// Connect to the best block (1001).
bestNode := genesisNode(simNetParams)
nodesForward := make([]*Node, testBCHeight+1)
nodesForward[0] = bestNode
for i := int64(1); i <= testBCHeight; i++ {
block := testBlockchain[i]
ticketsToAdd := make([]chainhash.Hash, 0)
if i >= simNetParams.StakeEnabledHeight {
matureHeight := (i - int64(simNetParams.TicketMaturity))
ticketsToAdd = ticketsInBlock(testBlockchain[matureHeight])
}
header := block.MsgBlock().Header
if int(header.PoolSize) != len(bestNode.LiveTickets()) {
t.Errorf("bad number of live tickets: want %v, got %v",
header.PoolSize, len(bestNode.LiveTickets()))
}
if header.FinalState != bestNode.FinalState() {
t.Errorf("bad final state: want %x, got %x",
header.FinalState, bestNode.FinalState())
}
// In memory addition test.
bestNode, err = bestNode.ConnectNode(header,
ticketsSpentInBlock(block), revokedTicketsInBlock(block),
ticketsToAdd)
if err != nil {
t.Fatalf("couldn't connect node: %v", err.Error())
}
nodesForward[i] = bestNode
}
// Disconnect all the way back to the genesis block.
for i := testBCHeight; i >= int64(1); i-- {
parentBlock := testBlockchain[i-1]
ticketsToAdd := make([]chainhash.Hash, 0)
if i >= simNetParams.StakeEnabledHeight {
matureHeight := (i - 1 - int64(simNetParams.TicketMaturity))
ticketsToAdd = ticketsInBlock(testBlockchain[matureHeight])
}
header := parentBlock.MsgBlock().Header
blockUndoData := nodesForward[i-1].UndoData()
// In memory disconnection test.
bestNode, err = bestNode.DisconnectNode(header, blockUndoData,
ticketsToAdd, nil)
if err != nil {
t.Errorf(err.Error())
}
}
// Test some accessory functions.
accessoryTestNode := nodesForward[450]
exists := accessoryTestNode.ExistsLiveTicket(accessoryTestNode.nextWinners[0])
if !exists {
t.Errorf("expected winner to exist in node live tickets")
}
missedExp := make([]chainhash.Hash, 0)
accessoryTestNode.missedTickets.ForEach(func(k tickettreap.Key,
v *tickettreap.Value) bool {
if v.Expired {
missedExp = append(missedExp, chainhash.Hash(k))
}
return true
})
revokedExp := make([]chainhash.Hash, 0)
accessoryTestNode.revokedTickets.ForEach(func(k tickettreap.Key,
v *tickettreap.Value) bool {
if v.Expired {
revokedExp = append(revokedExp, chainhash.Hash(k))
}
return true
})
exists = accessoryTestNode.ExistsMissedTicket(missedExp[0])
if !exists {
t.Errorf("expected expired and missed ticket to be missed")
}
exists = accessoryTestNode.ExistsExpiredTicket(missedExp[0])
if !exists {
t.Errorf("expected expired and missed ticket to be expired")
}
exists = accessoryTestNode.ExistsRevokedTicket(revokedExp[0])
if !exists {
t.Errorf("expected expired and revoked ticket to be revoked")
}
exists = accessoryTestNode.ExistsExpiredTicket(revokedExp[0])
if !exists {
t.Errorf("expected expired and revoked ticket to be expired")
}
exists = accessoryTestNode.ExistsExpiredTicket(
accessoryTestNode.nextWinners[0])
if exists {
t.Errorf("live ticket was expired")
}
// ----------------------------------------------------------------------------
// A longer, more strenuous test is given below. Uncomment to execute it.
// ----------------------------------------------------------------------------
/*
// Create a new database to store the accepted stake node data into.
dbName := "ffldb_staketest"
dbPath := filepath.Join(testDbRoot, dbName)
_ = os.RemoveAll(dbPath)
testDb, err := database.Create(testDbType, dbPath, simNetParams.Net)
if err != nil {
t.Fatalf("error creating db: %v", err)
}
// Setup a teardown.
defer os.RemoveAll(dbPath)
defer os.RemoveAll(testDbRoot)
defer testDb.Close()
// Load the genesis block and begin testing exported functions.
err = testDb.Update(func(dbTx database.Tx) error {
var errLocal error
bestNode, errLocal = InitDatabaseState(dbTx, simNetParams)
if errLocal != nil {
return errLocal
}
return nil
})
if err != nil {
t.Fatalf(err.Error())
}
// Cache all of our nodes so that we can check them when we start
// disconnecting and going backwards through the blockchain.
nodesForward = make([]*Node, testBCHeight+1)
loadedNodesForward := make([]*Node, testBCHeight+1)
nodesForward[0] = bestNode
loadedNodesForward[0] = bestNode
err = testDb.Update(func(dbTx database.Tx) error {
for i := int64(1); i <= testBCHeight; i++ {
block := testBlockchain[i]
ticketsToAdd := make([]chainhash.Hash, 0)
if i >= simNetParams.StakeEnabledHeight {
matureHeight := (i - int64(simNetParams.TicketMaturity))
ticketsToAdd = ticketsInBlock(testBlockchain[matureHeight])
}
header := block.MsgBlock().Header
if int(header.PoolSize) != len(bestNode.LiveTickets()) {
t.Errorf("bad number of live tickets: want %v, got %v",
header.PoolSize, len(bestNode.LiveTickets()))
}
if header.FinalState != bestNode.FinalState() {
t.Errorf("bad final state: want %x, got %x",
header.FinalState, bestNode.FinalState())
}
// In memory addition test.
bestNode, err = bestNode.ConnectNode(header,
ticketsSpentInBlock(block), revokedTicketsInBlock(block),
ticketsToAdd)
if err != nil {
return fmt.Errorf("couldn't connect node: %v", err.Error())
}
// Write the new node to db.
nodesForward[i] = bestNode
blockSha := block.Sha()
err := WriteConnectedBestNode(dbTx, bestNode, *blockSha)
if err != nil {
return fmt.Errorf("failure writing the best node: %v",
err.Error())
}
// Reload the node from DB and make sure it's the same.
blockHash := block.Sha()
loadedNode, err := LoadBestNode(dbTx, bestNode.Height(),
*blockHash, header, simNetParams)
if err != nil {
return fmt.Errorf("failed to load the best node: %v",
err.Error())
}
err = nodesEqual(loadedNode, bestNode)
if err != nil {
return fmt.Errorf("loaded best node was not same as "+
"in memory best node: %v", err.Error())
}
loadedNodesForward[i] = loadedNode
}
return nil
})
if err != nil {
t.Fatalf(err.Error())
}
nodesBackward := make([]*Node, testBCHeight+1)
nodesBackward[testBCHeight] = bestNode
for i := testBCHeight; i >= int64(1); i-- {
parentBlock := testBlockchain[i-1]
ticketsToAdd := make([]chainhash.Hash, 0)
if i >= simNetParams.StakeEnabledHeight {
matureHeight := (i - 1 - int64(simNetParams.TicketMaturity))
ticketsToAdd = ticketsInBlock(testBlockchain[matureHeight])
}
header := parentBlock.MsgBlock().Header
blockUndoData := nodesForward[i-1].UndoData()
formerBestNode := bestNode
// In memory disconnection test.
bestNode, err = bestNode.DisconnectNode(header, blockUndoData,
ticketsToAdd, nil)
if err != nil {
t.Errorf(err.Error())
}
err = nodesEqual(bestNode, nodesForward[i-1])
if err != nil {
t.Errorf("non-equiv stake nodes at height %v: %v", i-1, err.Error())
}
// Try again using the database instead of the in memory
// data to disconnect the node, too.
var bestNodeUsingDB *Node
err = testDb.View(func(dbTx database.Tx) error {
bestNodeUsingDB, err = formerBestNode.DisconnectNode(header, nil,
nil, dbTx)
if err != nil {
return err
}
return nil
})
if err != nil {
t.Errorf("couldn't disconnect using the database: %v",
err.Error())
}
err = nodesEqual(bestNode, bestNodeUsingDB)
if err != nil {
t.Errorf("non-equiv stake nodes using db when disconnecting: %v",
err.Error())
}
// Write the new best node to the database.
nodesBackward[i-1] = bestNode
err = testDb.Update(func(dbTx database.Tx) error {
nodesForward[i] = bestNode
parentBlockSha := parentBlock.Sha()
err := WriteDisconnectedBestNode(dbTx, bestNode,
*parentBlockSha, formerBestNode.UndoData())
if err != nil {
return fmt.Errorf("failure writing the best node: %v",
err.Error())
}
return nil
})
if err != nil {
t.Errorf("%s", err.Error())
}
// Check the best node against the loaded best node from
// the database after.
err = testDb.View(func(dbTx database.Tx) error {
parentBlockHash := parentBlock.Sha()
loadedNode, err := LoadBestNode(dbTx, bestNode.Height(),
*parentBlockHash, header, simNetParams)
if err != nil {
return fmt.Errorf("failed to load the best node: %v",
err.Error())
}
err = nodesEqual(loadedNode, bestNode)
if err != nil {
return fmt.Errorf("loaded best node %v was not same as "+
"in memory best node: %v", loadedNode.Height(), err.Error())
}
err = nodesEqual(loadedNode, loadedNodesForward[i-1])
if err != nil {
return fmt.Errorf("loaded best node %v was not same as "+
"cached best node: %v", loadedNode.Height(), err.Error())
}
return nil
})
if err != nil {
t.Errorf("%s", err.Error())
}
}
*/
}
// TestNewShaHashFromStr executes tests against the NewShaHashFromStr function.
func TestNewShaHashFromStr(t *testing.T) {
tests := []struct {
in string
want chainhash.Hash
err error
}{
// Genesis hash.
{
"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
mainNetGenesisHash,
nil,
},
// Genesis hash with stripped leading zeros.
{
"19d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
mainNetGenesisHash,
nil,
},
// Empty string.
{
"",
chainhash.Hash{},
nil,
},
// Single digit hash.
{
"1",
chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}),
nil,
},
// Block 203707 with stripped leading zeros.
{
"3264bc2ac36a60840790ba1d475d01367e7c723da941069e9dc",
chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0xdc, 0xe9, 0x69, 0x10, 0x94, 0xda, 0x23, 0xc7,
0xe7, 0x67, 0x13, 0xd0, 0x75, 0xd4, 0xa1, 0x0b,
0x79, 0x40, 0x08, 0xa6, 0x36, 0xac, 0xc2, 0x4b,
0x26, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}),
nil,
},
// Hash string that is too long.
{
"01234567890123456789012345678901234567890123456789012345678912345",
chainhash.Hash{},
chainhash.ErrHashStrSize,
},
// Hash string that is contains non-hex chars.
{
"abcdefg",
chainhash.Hash{},
hex.InvalidByteError('g'),
},
}
unexpectedErrStr := "NewShaHashFromStr #%d failed to detect expected error - got: %v want: %v"
unexpectedResultStr := "NewShaHashFromStr #%d got: %v want: %v"
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
result, err := chainhash.NewHashFromStr(test.in)
if err != test.err {
t.Errorf(unexpectedErrStr, i, err, test.err)
continue
} else if err != nil {
// Got expected error. Move on to the next test.
continue
}
if !test.want.IsEqual(result) {
t.Errorf(unexpectedResultStr, i, result, &test.want)
continue
}
}
}
// TestCheckErrorCondition tests the execute early test in CheckErrorCondition()
// since most code paths are tested elsewhere.
func TestCheckErrorCondition(t *testing.T) {
t.Parallel()
// tx with almost empty scripts.
tx := &wire.MsgTx{
Version: 1,
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash([32]byte{
0xc9, 0x97, 0xa5, 0xe5,
0x6e, 0x10, 0x41, 0x02,
0xfa, 0x20, 0x9c, 0x6a,
0x85, 0x2d, 0xd9, 0x06,
0x60, 0xa2, 0x0b, 0x2d,
0x9c, 0x35, 0x24, 0x23,
0xed, 0xce, 0x25, 0x85,
0x7f, 0xcd, 0x37, 0x04,
}),
Index: 0,
},
SignatureScript: []uint8{},
Sequence: 4294967295,
},
},
TxOut: []*wire.TxOut{
{
Value: 1000000000,
PkScript: nil,
},
},
LockTime: 0,
}
pkScript := []byte{
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_NOP,
txscript.OP_TRUE,
}
vm, err := txscript.NewEngine(pkScript, tx, 0, 0, 0, nil)
if err != nil {
t.Errorf("failed to create script: %v", err)
}
for i := 0; i < len(pkScript)-1; i++ {
done, err := vm.Step()
if err != nil {
t.Errorf("failed to step %dth time: %v", i, err)
return
}
if done {
t.Errorf("finshed early on %dth time", i)
return
}
err = vm.CheckErrorCondition(false)
if err != txscript.ErrStackScriptUnfinished {
t.Errorf("got unexepected error %v on %dth iteration",
err, i)
return
}
}
done, err := vm.Step()
if err != nil {
t.Errorf("final step failed %v", err)
return
}
if !done {
t.Errorf("final step isn't done!")
return
}
err = vm.CheckErrorCondition(false)
if err != nil {
t.Errorf("unexpected error %v on final check", err)
}
}
serializedSize := test.in.SerializeSize()
if serializedSize != test.size {
t.Errorf("MsgBlock.SerializeSize: #%d got: %d, want: "+
"%d", i, serializedSize, test.size)
continue
}
}
}
// testBlock is a basic normative block that is used throughout tests.
var testBlock = MsgBlock{
Header: BlockHeader{
Version: 1,
PrevBlock: chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
}),
MerkleRoot: chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44,
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
}),
StakeRoot: chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44,
0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
}),
VoteBits: uint16(0x0000),
// connectNode connects a child to a parent stake node, returning the
// modified stake node for the child. It is important to keep in mind that
// the argument node is the parent node, and that the child stake node is
// returned after subsequent modification of the parent node's immutable
// data.
func connectNode(node *Node, header wire.BlockHeader, ticketsSpentInBlock, revokedTickets, newTickets []chainhash.Hash) (*Node, error) {
if node == nil {
return nil, fmt.Errorf("missing stake node pointer input when connecting")
}
connectedNode := &Node{
height: node.height + 1,
liveTickets: node.liveTickets,
missedTickets: node.missedTickets,
revokedTickets: node.revokedTickets,
databaseUndoUpdate: make(UndoTicketDataSlice, 0),
databaseBlockTickets: newTickets,
nextWinners: make([]chainhash.Hash, 0),
params: node.params,
}
// We only have to deal with voted related issues and expiry after
// StakeEnabledHeight.
var err error
if connectedNode.height >= uint32(connectedNode.params.StakeEnabledHeight) {
// Basic sanity check.
for i := range ticketsSpentInBlock {
if !hashInSlice(ticketsSpentInBlock[i], node.nextWinners) {
return nil, stakeRuleError(ErrUnknownTicketSpent,
fmt.Sprintf("unknown ticket %v spent in block",
ticketsSpentInBlock[i]))
}
}
// Iterate through all possible winners and construct the undo data,
// updating the live and missed ticket treaps as necessary. We need
// to copy the value here so we don't modify it in the previous treap.
for _, ticket := range node.nextWinners {
k := tickettreap.Key(ticket)
v, err := safeGet(connectedNode.liveTickets, k)
if err != nil {
return nil, err
}
// If it's spent in this block, mark it as being spent. Otherwise,
// it was missed. Spent tickets are dropped from the live ticket
// bucket, while missed tickets are pushed to the missed ticket
// bucket. Because we already know from the above check that the
// ticket should still be in the live tickets treap, we probably
// do not have to use the safe delete functions, but do so anyway
// just to be safe.
if hashInSlice(ticket, ticketsSpentInBlock) {
v.Spent = true
v.Missed = false
connectedNode.liveTickets, err =
safeDelete(connectedNode.liveTickets, k)
if err != nil {
return nil, err
}
} else {
v.Spent = false
v.Missed = true
connectedNode.liveTickets, err =
safeDelete(connectedNode.liveTickets, k)
if err != nil {
return nil, err
}
connectedNode.missedTickets, err =
safePut(connectedNode.missedTickets, k, v)
if err != nil {
return nil, err
}
}
connectedNode.databaseUndoUpdate =
append(connectedNode.databaseUndoUpdate, ticketdb.UndoTicketData{
TicketHash: ticket,
TicketHeight: v.Height,
Missed: v.Missed,
Revoked: v.Revoked,
Spent: v.Spent,
Expired: v.Expired,
})
}
// Find the expiring tickets and drop them as well. We already know what
// the winners are from the cached information in the previous block, so
// no drop the results of that here.
toExpireHeight := uint32(0)
if connectedNode.height > uint32(connectedNode.params.TicketExpiry) {
toExpireHeight = connectedNode.height -
uint32(connectedNode.params.TicketExpiry)
}
expired := fetchExpired(toExpireHeight, connectedNode.liveTickets)
for _, treapKey := range expired {
v, err := safeGet(connectedNode.liveTickets, *treapKey)
if err != nil {
return nil, err
}
v.Missed = true
v.Expired = true
connectedNode.liveTickets, err =
safeDelete(connectedNode.liveTickets, *treapKey)
if err != nil {
return nil, err
}
connectedNode.missedTickets, err =
safePut(connectedNode.missedTickets, *treapKey, v)
if err != nil {
return nil, err
}
ticketHash := chainhash.Hash(*treapKey)
connectedNode.databaseUndoUpdate =
append(connectedNode.databaseUndoUpdate, ticketdb.UndoTicketData{
TicketHash: ticketHash,
TicketHeight: v.Height,
Missed: v.Missed,
Revoked: v.Revoked,
Spent: v.Spent,
Expired: v.Expired,
})
}
// Process all the revocations, moving them from the missed to the
// revoked treap and recording them in the undo data.
for _, revokedTicket := range revokedTickets {
v, err := safeGet(connectedNode.missedTickets,
tickettreap.Key(revokedTicket))
if err != nil {
return nil, err
}
v.Revoked = true
connectedNode.missedTickets, err =
safeDelete(connectedNode.missedTickets,
tickettreap.Key(revokedTicket))
if err != nil {
return nil, err
}
connectedNode.revokedTickets, err =
safePut(connectedNode.revokedTickets,
tickettreap.Key(revokedTicket), v)
if err != nil {
return nil, err
}
connectedNode.databaseUndoUpdate =
append(connectedNode.databaseUndoUpdate, ticketdb.UndoTicketData{
TicketHash: revokedTicket,
TicketHeight: v.Height,
Missed: v.Missed,
Revoked: v.Revoked,
Spent: v.Spent,
Expired: v.Expired,
})
}
}
// Add all the new tickets.
for _, newTicket := range newTickets {
k := tickettreap.Key(newTicket)
v := &tickettreap.Value{
Height: connectedNode.height,
Missed: false,
Revoked: false,
Spent: false,
Expired: false,
}
connectedNode.liveTickets, err =
safePut(connectedNode.liveTickets, k, v)
if err != nil {
return nil, err
}
connectedNode.databaseUndoUpdate =
append(connectedNode.databaseUndoUpdate, ticketdb.UndoTicketData{
TicketHash: newTicket,
TicketHeight: v.Height,
Missed: v.Missed,
Revoked: v.Revoked,
Spent: v.Spent,
Expired: v.Expired,
})
}
// The first block voted on is at StakeEnabledHeight, so begin calculating
// winners at the block before StakeEnabledHeight.
if connectedNode.height >=
uint32(connectedNode.params.StakeValidationHeight-1) {
// Find the next set of winners.
hB, err := header.Bytes()
if err != nil {
return nil, err
}
prng := NewHash256PRNG(hB)
idxs, err := findTicketIdxs(int64(connectedNode.liveTickets.Len()),
int(connectedNode.params.TicketsPerBlock), prng)
if err != nil {
return nil, err
}
stateBuffer := make([]byte, 0,
(connectedNode.params.TicketsPerBlock+1)*chainhash.HashSize)
nextWinnersKeys, err := fetchWinners(idxs, connectedNode.liveTickets)
if err != nil {
return nil, err
}
for _, treapKey := range nextWinnersKeys {
ticketHash := chainhash.Hash(*treapKey)
connectedNode.nextWinners = append(connectedNode.nextWinners,
ticketHash)
stateBuffer = append(stateBuffer, ticketHash[:]...)
}
lastHash := prng.StateHash()
stateBuffer = append(stateBuffer, lastHash[:]...)
copy(connectedNode.finalState[:], chainhash.HashFuncB(stateBuffer)[0:6])
}
return connectedNode, nil
}
