[NOD-1273] Order parents in PrepareBlockForTest (#872)

* [NOD-1271] Move version package to the top level

* [NOD-1271] Fix imports

README.md

@@ -4,7 +4,7 @@ Kaspad
 Warning: This is pre-alpha software. There's no guarantee anything works.
 ====
 
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad)
 
 Kaspad is the reference full node Kaspa implementation written in Go (golang).
@@ -75,5 +75,5 @@ The documentation is a work-in-progress. It is located in the [docs](https://git
 
 ## License
 
-Kaspad is licensed under the [copyfree](http://copyfree.org) ISC License.
+Kaspad is licensed under the copyfree [ISC License](https://choosealicense.com/licenses/isc/).
 

addrmgr/addrmanager_test.go

@@ -1,123 +0,0 @@
-// Copyright (c) 2013-2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package addrmgr
-
-import (
-	"net"
-	"testing"
-
-	"github.com/pkg/errors"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// naTest is used to describe a test to be performed against the NetAddressKey
-// method.
-type naTest struct {
-	in   wire.NetAddress
-	want string
-}
-
-// naTests houses all of the tests to be performed against the NetAddressKey
-// method.
-var naTests = make([]naTest, 0)
-
-// Put some IP in here for convenience. Points to google.
-var someIP = "173.194.115.66"
-
-// addNaTests
-func addNaTests() {
-	// IPv4
-	// Localhost
-	addNaTest("127.0.0.1", 16111, "127.0.0.1:16111")
-	addNaTest("127.0.0.1", 16110, "127.0.0.1:16110")
-
-	// Class A
-	addNaTest("1.0.0.1", 16111, "1.0.0.1:16111")
-	addNaTest("2.2.2.2", 16110, "2.2.2.2:16110")
-	addNaTest("27.253.252.251", 8335, "27.253.252.251:8335")
-	addNaTest("123.3.2.1", 8336, "123.3.2.1:8336")
-
-	// Private Class A
-	addNaTest("10.0.0.1", 16111, "10.0.0.1:16111")
-	addNaTest("10.1.1.1", 16110, "10.1.1.1:16110")
-	addNaTest("10.2.2.2", 8335, "10.2.2.2:8335")
-	addNaTest("10.10.10.10", 8336, "10.10.10.10:8336")
-
-	// Class B
-	addNaTest("128.0.0.1", 16111, "128.0.0.1:16111")
-	addNaTest("129.1.1.1", 16110, "129.1.1.1:16110")
-	addNaTest("180.2.2.2", 8335, "180.2.2.2:8335")
-	addNaTest("191.10.10.10", 8336, "191.10.10.10:8336")
-
-	// Private Class B
-	addNaTest("172.16.0.1", 16111, "172.16.0.1:16111")
-	addNaTest("172.16.1.1", 16110, "172.16.1.1:16110")
-	addNaTest("172.16.2.2", 8335, "172.16.2.2:8335")
-	addNaTest("172.16.172.172", 8336, "172.16.172.172:8336")
-
-	// Class C
-	addNaTest("193.0.0.1", 16111, "193.0.0.1:16111")
-	addNaTest("200.1.1.1", 16110, "200.1.1.1:16110")
-	addNaTest("205.2.2.2", 8335, "205.2.2.2:8335")
-	addNaTest("223.10.10.10", 8336, "223.10.10.10:8336")
-
-	// Private Class C
-	addNaTest("192.168.0.1", 16111, "192.168.0.1:16111")
-	addNaTest("192.168.1.1", 16110, "192.168.1.1:16110")
-	addNaTest("192.168.2.2", 8335, "192.168.2.2:8335")
-	addNaTest("192.168.192.192", 8336, "192.168.192.192:8336")
-
-	// IPv6
-	// Localhost
-	addNaTest("::1", 16111, "[::1]:16111")
-	addNaTest("fe80::1", 16110, "[fe80::1]:16110")
-
-	// Link-local
-	addNaTest("fe80::1:1", 16111, "[fe80::1:1]:16111")
-	addNaTest("fe91::2:2", 16110, "[fe91::2:2]:16110")
-	addNaTest("fea2::3:3", 8335, "[fea2::3:3]:8335")
-	addNaTest("feb3::4:4", 8336, "[feb3::4:4]:8336")
-
-	// Site-local
-	addNaTest("fec0::1:1", 16111, "[fec0::1:1]:16111")
-	addNaTest("fed1::2:2", 16110, "[fed1::2:2]:16110")
-	addNaTest("fee2::3:3", 8335, "[fee2::3:3]:8335")
-	addNaTest("fef3::4:4", 8336, "[fef3::4:4]:8336")
-}
-
-func addNaTest(ip string, port uint16, want string) {
-	nip := net.ParseIP(ip)
-	na := *wire.NewNetAddressIPPort(nip, port, wire.SFNodeNetwork)
-	test := naTest{na, want}
-	naTests = append(naTests, test)
-}
-
-func lookupFunc(host string) ([]net.IP, error) {
-	return nil, errors.New("not implemented")
-}
-
-func TestStartStop(t *testing.T) {
-	n := New("teststartstop", lookupFunc, nil)
-	n.Start()
-	err := n.Stop()
-	if err != nil {
-		t.Fatalf("Address Manager failed to stop: %v", err)
-	}
-}
-
-func TestNetAddressKey(t *testing.T) {
-	addNaTests()
-
-	t.Logf("Running %d tests", len(naTests))
-	for i, test := range naTests {
-		key := NetAddressKey(&test.in)
-		if key != test.want {
-			t.Errorf("NetAddressKey #%d\n got: %s want: %s", i, key, test.want)
-			continue
-		}
-	}
-
-}

addrmgr/internal_test.go

@@ -1,25 +0,0 @@
-// Copyright (c) 2013-2015 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package addrmgr
-
-import (
-	"time"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func TstKnownAddressIsBad(ka *KnownAddress) bool {
-	return ka.isBad()
-}
-
-func TstKnownAddressChance(ka *KnownAddress) float64 {
-	return ka.chance()
-}
-
-func TstNewKnownAddress(na *wire.NetAddress, attempts int,
-	lastattempt, lastsuccess time.Time, tried bool, refs int) *KnownAddress {
-	return &KnownAddress{na: na, attempts: attempts, lastattempt: lastattempt,
-		lastsuccess: lastsuccess, tried: tried, refs: refs}
-}

addrmgr/knownaddress_test.go

@@ -1,114 +0,0 @@
-// Copyright (c) 2013-2015 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package addrmgr_test
-
-import (
-	"math"
-	"testing"
-	"time"
-
-	"github.com/kaspanet/kaspad/addrmgr"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func TestChance(t *testing.T) {
-	now := time.Unix(time.Now().Unix(), 0)
-	var tests = []struct {
-		addr     *addrmgr.KnownAddress
-		expected float64
-	}{
-		{
-			//Test normal case
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1.0,
-		}, {
-			//Test case in which lastseen < 0
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(20 * time.Second)},
-				0, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1.0,
-		}, {
-			//Test case in which lastattempt < 0
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(30*time.Minute), time.Now(), false, 0),
-			1.0 * .01,
-		}, {
-			//Test case in which lastattempt < ten minutes
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(-5*time.Minute), time.Now(), false, 0),
-			1.0 * .01,
-		}, {
-			//Test case with several failed attempts.
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				2, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1 / 1.5 / 1.5,
-		},
-	}
-
-	err := .0001
-	for i, test := range tests {
-		chance := addrmgr.TstKnownAddressChance(test.addr)
-		if math.Abs(test.expected-chance) >= err {
-			t.Errorf("case %d: got %f, expected %f", i, chance, test.expected)
-		}
-	}
-}
-
-func TestIsBad(t *testing.T) {
-	now := time.Unix(time.Now().Unix(), 0)
-	future := now.Add(35 * time.Minute)
-	monthOld := now.Add(-43 * time.Hour * 24)
-	secondsOld := now.Add(-2 * time.Second)
-	minutesOld := now.Add(-27 * time.Minute)
-	hoursOld := now.Add(-5 * time.Hour)
-	zeroTime := time.Time{}
-
-	futureNa := &wire.NetAddress{Timestamp: future}
-	minutesOldNa := &wire.NetAddress{Timestamp: minutesOld}
-	monthOldNa := &wire.NetAddress{Timestamp: monthOld}
-	currentNa := &wire.NetAddress{Timestamp: secondsOld}
-
-	//Test addresses that have been tried in the last minute.
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 1: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 2: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 3: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, monthOld, true, 0)) {
-		t.Errorf("test case 4: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 2, secondsOld, secondsOld, true, 0)) {
-		t.Errorf("test case 5: addresses that have been tried in the last minute are not bad.")
-	}
-
-	//Test address that claims to be from the future.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 0, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 6: addresses that claim to be from the future are bad.")
-	}
-
-	//Test address that has not been seen in over a month.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 0, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 7: addresses more than a month old are bad.")
-	}
-
-	//It has failed at least three times and never succeeded.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 3, minutesOld, zeroTime, true, 0)) {
-		t.Errorf("test case 8: addresses that have never succeeded are bad.")
-	}
-
-	//It has failed ten times in the last week
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 10, minutesOld, monthOld, true, 0)) {
-		t.Errorf("test case 9: addresses that have not succeeded in too long are bad.")
-	}
-
-	//Test an address that should work.
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 2, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 10: This should be a valid address.")
-	}
-}

app/app.go

@@ -0,0 +1,247 @@
+package app
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/network/addressmanager"
+
+	"github.com/kaspanet/kaspad/network/netadapter/id"
+
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/domain/mining"
+	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/dbaccess"
+	"github.com/kaspanet/kaspad/infrastructure/signal"
+	"github.com/kaspanet/kaspad/network/connmanager"
+	"github.com/kaspanet/kaspad/network/dnsseed"
+	"github.com/kaspanet/kaspad/network/domainmessage"
+	"github.com/kaspanet/kaspad/network/netadapter"
+	"github.com/kaspanet/kaspad/network/protocol"
+	"github.com/kaspanet/kaspad/network/rpc"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+// App is a wrapper for all the kaspad services
+type App struct {
+	cfg               *config.Config
+	rpcServer         *rpc.Server
+	addressManager    *addressmanager.AddressManager
+	protocolManager   *protocol.Manager
+	connectionManager *connmanager.ConnectionManager
+	netAdapter        *netadapter.NetAdapter
+
+	started, shutdown int32
+}
+
+// Start launches all the kaspad services.
+func (a *App) Start() {
+	// Already started?
+	if atomic.AddInt32(&a.started, 1) != 1 {
+		return
+	}
+
+	log.Trace("Starting kaspad")
+
+	err := a.protocolManager.Start()
+	if err != nil {
+		panics.Exit(log, fmt.Sprintf("Error starting the p2p protocol: %+v", err))
+	}
+
+	a.maybeSeedFromDNS()
+
+	a.connectionManager.Start()
+
+	if !a.cfg.DisableRPC {
+		a.rpcServer.Start()
+	}
+}
+
+// Stop gracefully shuts down all the kaspad services.
+func (a *App) Stop() {
+	// Make sure this only happens once.
+	if atomic.AddInt32(&a.shutdown, 1) != 1 {
+		log.Infof("Kaspad is already in the process of shutting down")
+		return
+	}
+
+	log.Warnf("Kaspad shutting down")
+
+	a.connectionManager.Stop()
+
+	err := a.protocolManager.Stop()
+	if err != nil {
+		log.Errorf("Error stopping the p2p protocol: %+v", err)
+	}
+
+	// Shutdown the RPC server if it's not disabled.
+	if !a.cfg.DisableRPC {
+		err := a.rpcServer.Stop()
+		if err != nil {
+			log.Errorf("Error stopping rpcServer: %+v", err)
+		}
+	}
+
+	err = a.addressManager.Stop()
+	if err != nil {
+		log.Errorf("Error stopping address manager: %s", err)
+	}
+
+	return
+}
+
+// New returns a new App instance configured to listen on addr for the
+// kaspa network type specified by dagParams. Use start to begin accepting
+// connections from peers.
+func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{}) (*App, error) {
+	indexManager, acceptanceIndex := setupIndexes(cfg)
+
+	sigCache := txscript.NewSigCache(cfg.SigCacheMaxSize)
+
+	// Create a new block DAG instance with the appropriate configuration.
+	dag, err := setupDAG(cfg, databaseContext, interrupt, sigCache, indexManager)
+	if err != nil {
+		return nil, err
+	}
+
+	txMempool := setupMempool(cfg, dag, sigCache)
+
+	netAdapter, err := netadapter.NewNetAdapter(cfg)
+	if err != nil {
+		return nil, err
+	}
+	addressManager := addressmanager.New(cfg, databaseContext)
+
+	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
+	if err != nil {
+		return nil, err
+	}
+
+	protocolManager, err := protocol.NewManager(cfg, dag, netAdapter, addressManager, txMempool, connectionManager)
+	if err != nil {
+		return nil, err
+	}
+	rpcServer, err := setupRPC(
+		cfg, dag, txMempool, sigCache, acceptanceIndex, connectionManager, addressManager, protocolManager)
+	if err != nil {
+		return nil, err
+	}
+
+	return &App{
+		cfg:               cfg,
+		rpcServer:         rpcServer,
+		protocolManager:   protocolManager,
+		connectionManager: connectionManager,
+		netAdapter:        netAdapter,
+		addressManager:    addressManager,
+	}, nil
+}
+
+func (a *App) maybeSeedFromDNS() {
+	if !a.cfg.DisableDNSSeed {
+		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, domainmessage.SFNodeNetwork, false, nil,
+			a.cfg.Lookup, func(addresses []*domainmessage.NetAddress) {
+				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
+				// IPs of nodes and not its own IP, we can not know real IP of
+				// source. So we'll take first returned address as source.
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
+			})
+	}
+}
+func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{},
+	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
+
+	dag, err := blockdag.New(&blockdag.Config{
+		Interrupt:       interrupt,
+		DatabaseContext: databaseContext,
+		DAGParams:       cfg.NetParams(),
+		TimeSource:      blockdag.NewTimeSource(),
+		SigCache:        sigCache,
+		IndexManager:    indexManager,
+		SubnetworkID:    cfg.SubnetworkID,
+	})
+	return dag, err
+}
+
+func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.AcceptanceIndex) {
+	// Create indexes if needed.
+	var indexes []indexers.Indexer
+	var acceptanceIndex *indexers.AcceptanceIndex
+	if cfg.AcceptanceIndex {
+		log.Info("acceptance index is enabled")
+		acceptanceIndex = indexers.NewAcceptanceIndex()
+		indexes = append(indexes, acceptanceIndex)
+	}
+
+	// Create an index manager if any of the optional indexes are enabled.
+	if len(indexes) < 0 {
+		return nil, nil
+	}
+	indexManager := indexers.NewManager(indexes)
+	return indexManager, acceptanceIndex
+}
+
+func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript.SigCache) *mempool.TxPool {
+	mempoolConfig := mempool.Config{
+		Policy: mempool.Policy{
+			AcceptNonStd:    cfg.RelayNonStd,
+			MaxOrphanTxs:    cfg.MaxOrphanTxs,
+			MaxOrphanTxSize: config.DefaultMaxOrphanTxSize,
+			MinRelayTxFee:   cfg.MinRelayTxFee,
+			MaxTxVersion:    1,
+		},
+		CalcSequenceLockNoLock: func(tx *util.Tx, utxoSet blockdag.UTXOSet) (*blockdag.SequenceLock, error) {
+			return dag.CalcSequenceLockNoLock(tx, utxoSet)
+		},
+		SigCache: sigCache,
+		DAG:      dag,
+	}
+
+	return mempool.New(&mempoolConfig)
+}
+
+func setupRPC(cfg *config.Config,
+	dag *blockdag.BlockDAG,
+	txMempool *mempool.TxPool,
+	sigCache *txscript.SigCache,
+	acceptanceIndex *indexers.AcceptanceIndex,
+	connectionManager *connmanager.ConnectionManager,
+	addressManager *addressmanager.AddressManager,
+	protocolManager *protocol.Manager) (*rpc.Server, error) {
+
+	if !cfg.DisableRPC {
+		policy := mining.Policy{
+			BlockMaxMass: cfg.BlockMaxMass,
+		}
+		blockTemplateGenerator := mining.NewBlkTmplGenerator(&policy, txMempool, dag, sigCache)
+
+		rpcServer, err := rpc.NewRPCServer(cfg, dag, txMempool, acceptanceIndex, blockTemplateGenerator,
+			connectionManager, addressManager, protocolManager)
+		if err != nil {
+			return nil, err
+		}
+
+		// Signal process shutdown when the RPC server requests it.
+		spawn("setupRPC-handleShutdownRequest", func() {
+			<-rpcServer.RequestedProcessShutdown()
+			signal.ShutdownRequestChannel <- struct{}{}
+		})
+
+		return rpcServer, nil
+	}
+	return nil, nil
+}
+
+// P2PNodeID returns the network ID associated with this App
+func (a *App) P2PNodeID() *id.ID {
+	return a.netAdapter.ID()
+}
+
+// AddressManager returns the AddressManager associated with this App
+func (a *App) AddressManager() *addressmanager.AddressManager {
+	return a.addressManager
+}

app/log.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2013-2017 The btcsuite developers
+// Copyright (c) 2017 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package app
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.KASD)
+var spawn = panics.GoroutineWrapperFunc(log)

blockdag/accept.go

@@ -1,130 +0,0 @@
-// Copyright (c) 2013-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-)
-
-func (dag *BlockDAG) addNodeToIndexWithInvalidAncestor(block *util.Block) error {
-	blockHeader := &block.MsgBlock().Header
-	newNode, _ := dag.newBlockNode(blockHeader, newSet())
-	newNode.status = statusInvalidAncestor
-	dag.index.AddNode(newNode)
-	return dag.index.flushToDB()
-}
-
-// maybeAcceptBlock potentially accepts a block into the block DAG. It
-// performs several validation checks which depend on its position within
-// the block DAG before adding it. The block is expected to have already
-// gone through ProcessBlock before calling this function with it.
-//
-// The flags are also passed to checkBlockContext and connectToDAG. See
-// their documentation for how the flags modify their behavior.
-//
-// This function MUST be called with the dagLock held (for writes).
-func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) error {
-	parents, err := lookupParentNodes(block, dag)
-	if err != nil {
-		if rErr, ok := err.(RuleError); ok && rErr.ErrorCode == ErrInvalidAncestorBlock {
-			err := dag.addNodeToIndexWithInvalidAncestor(block)
-			if err != nil {
-				return err
-			}
-		}
-		return err
-	}
-
-	// The block must pass all of the validation rules which depend on the
-	// position of the block within the block DAG.
-	err = dag.checkBlockContext(block, parents, flags)
-	if err != nil {
-		return err
-	}
-
-	// Create a new block node for the block and add it to the node index.
-	newNode, selectedParentAnticone := dag.newBlockNode(&block.MsgBlock().Header, parents)
-	newNode.status = statusDataStored
-	dag.index.AddNode(newNode)
-
-	// Insert the block into the database if it's not already there. Even
-	// though it is possible the block will ultimately fail to connect, it
-	// has already passed all proof-of-work and validity tests which means
-	// it would be prohibitively expensive for an attacker to fill up the
-	// disk with a bunch of blocks that fail to connect. This is necessary
-	// since it allows block download to be decoupled from the much more
-	// expensive connection logic. It also has some other nice properties
-	// such as making blocks that never become part of the DAG or
-	// blocks that fail to connect available for further analysis.
-	err = dag.db.Update(func(dbTx database.Tx) error {
-		err := dbStoreBlock(dbTx, block)
-		if err != nil {
-			return err
-		}
-		return dag.index.flushToDBWithTx(dbTx)
-	})
-	if err != nil {
-		return err
-	}
-
-	// Make sure that all the block's transactions are finalized
-	fastAdd := flags&BFFastAdd == BFFastAdd
-	bluestParent := parents.bluest()
-	if !fastAdd {
-		if err := dag.validateAllTxsFinalized(block, newNode, bluestParent); err != nil {
-			return err
-		}
-	}
-
-	block.SetBlueScore(newNode.blueScore)
-
-	// Connect the passed block to the DAG. This also handles validation of the
-	// transaction scripts.
-	chainUpdates, err := dag.addBlock(newNode, block, selectedParentAnticone, flags)
-	if err != nil {
-		return err
-	}
-
-	// Notify the caller that the new block was accepted into the block
-	// DAG. The caller would typically want to react by relaying the
-	// inventory to other peers.
-	dag.dagLock.Unlock()
-	dag.sendNotification(NTBlockAdded, &BlockAddedNotificationData{
-		Block:         block,
-		WasUnorphaned: flags&BFWasUnorphaned != 0,
-	})
-	if len(chainUpdates.addedChainBlockHashes) > 0 {
-		dag.sendNotification(NTChainChanged, &ChainChangedNotificationData{
-			RemovedChainBlockHashes: chainUpdates.removedChainBlockHashes,
-			AddedChainBlockHashes:   chainUpdates.addedChainBlockHashes,
-		})
-	}
-	dag.dagLock.Lock()
-
-	return nil
-}
-
-func lookupParentNodes(block *util.Block, blockDAG *BlockDAG) (blockSet, error) {
-	header := block.MsgBlock().Header
-	parentHashes := header.ParentHashes
-
-	nodes := newSet()
-	for _, parentHash := range parentHashes {
-		node := blockDAG.index.LookupNode(parentHash)
-		if node == nil {
-			str := fmt.Sprintf("parent block %s is unknown", parentHashes)
-			return nil, ruleError(ErrParentBlockUnknown, str)
-		} else if blockDAG.index.NodeStatus(node).KnownInvalid() {
-			str := fmt.Sprintf("parent block %s is known to be invalid", parentHashes)
-			return nil, ruleError(ErrInvalidAncestorBlock, str)
-		}
-
-		nodes.add(node)
-	}
-
-	return nodes, nil
-}

blockdag/accept_test.go

@@ -1,105 +0,0 @@
-package blockdag
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-)
-
-func TestMaybeAcceptBlockErrors(t *testing.T) {
-	// Create a new database and DAG instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("TestMaybeAcceptBlockErrors", Config{
-		DAGParams: &dagconfig.SimnetParams,
-	})
-	if err != nil {
-		t.Fatalf("TestMaybeAcceptBlockErrors: Failed to setup DAG instance: %v", err)
-	}
-	defer teardownFunc()
-
-	dag.TestSetCoinbaseMaturity(0)
-
-	// Test rejecting the block if its parents are missing
-	orphanBlockFile := "blk_3B.dat"
-	loadedBlocks, err := LoadBlocks(filepath.Join("testdata/", orphanBlockFile))
-	if err != nil {
-		t.Fatalf("TestMaybeAcceptBlockErrors: "+
-			"Error loading file '%s': %s\n", orphanBlockFile, err)
-	}
-	block := loadedBlocks[0]
-
-	err = dag.maybeAcceptBlock(block, BFNone)
-	if err == nil {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+
-			"Expected: %s, got: <nil>", ErrParentBlockUnknown)
-	}
-	ruleErr, ok := err.(RuleError)
-	if !ok {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+
-			"Expected RuleError but got %s", err)
-	} else if ruleErr.ErrorCode != ErrParentBlockUnknown {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+
-			"Unexpected error code. Want: %s, got: %s", ErrParentBlockUnknown, ruleErr.ErrorCode)
-	}
-
-	// Test rejecting the block if its parents are invalid
-	blocksFile := "blk_0_to_4.dat"
-	blocks, err := LoadBlocks(filepath.Join("testdata/", blocksFile))
-	if err != nil {
-		t.Fatalf("TestMaybeAcceptBlockErrors: "+
-			"Error loading file '%s': %s\n", blocksFile, err)
-	}
-
-	// Add a valid block and mark it as invalid
-	block1 := blocks[1]
-	isOrphan, isDelayed, err := dag.ProcessBlock(block1, BFNone)
-	if err != nil {
-		t.Fatalf("TestMaybeAcceptBlockErrors: Valid block unexpectedly returned an error: %s", err)
-	}
-	if isDelayed {
-		t.Fatalf("TestMaybeAcceptBlockErrors: block 1 is too far in the future")
-	}
-	if isOrphan {
-		t.Fatalf("TestMaybeAcceptBlockErrors: incorrectly returned block 1 is an orphan")
-	}
-	blockNode1 := dag.index.LookupNode(block1.Hash())
-	dag.index.SetStatusFlags(blockNode1, statusValidateFailed)
-
-	block2 := blocks[2]
-	err = dag.maybeAcceptBlock(block2, BFNone)
-	if err == nil {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+
-			"Expected: %s, got: <nil>", ErrInvalidAncestorBlock)
-	}
-	ruleErr, ok = err.(RuleError)
-	if !ok {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+
-			"Expected RuleError but got %s", err)
-	} else if ruleErr.ErrorCode != ErrInvalidAncestorBlock {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+
-			"Unexpected error. Want: %s, got: %s", ErrInvalidAncestorBlock, ruleErr.ErrorCode)
-	}
-
-	// Set block1's status back to valid for next tests
-	dag.index.UnsetStatusFlags(blockNode1, statusValidateFailed)
-
-	// Test rejecting the block due to bad context
-	originalBits := block2.MsgBlock().Header.Bits
-	block2.MsgBlock().Header.Bits = 0
-	err = dag.maybeAcceptBlock(block2, BFNone)
-	if err == nil {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block due to bad context: "+
-			"Expected: %s, got: <nil>", ErrUnexpectedDifficulty)
-	}
-	ruleErr, ok = err.(RuleError)
-	if !ok {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block due to bad context: "+
-			"Expected RuleError but got %s", err)
-	} else if ruleErr.ErrorCode != ErrUnexpectedDifficulty {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block due to bad context: "+
-			"Unexpected error. Want: %s, got: %s", ErrUnexpectedDifficulty, ruleErr.ErrorCode)
-	}
-
-	// Set block2's bits back to valid for next tests
-	block2.MsgBlock().Header.Bits = originalBits
-}

blockdag/blockidhash.go

@@ -1,136 +0,0 @@
-package blockdag
-
-import (
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/pkg/errors"
-)
-
-var (
-	// idByHashIndexBucketName is the name of the db bucket used to house
-	// the block hash -> block id index.
-	idByHashIndexBucketName = []byte("idbyhashidx")
-
-	// hashByIDIndexBucketName is the name of the db bucket used to house
-	// the block id -> block hash index.
-	hashByIDIndexBucketName = []byte("hashbyididx")
-
-	currentBlockIDKey = []byte("currentblockid")
-)
-
-// -----------------------------------------------------------------------------
-// This is a mapping between block hashes and unique IDs. The ID
-// is simply a sequentially incremented uint64 that is used instead of block hash
-// for the indexers. This is useful because it is only 8 bytes versus 32 bytes
-// hashes and thus saves a ton of space when a block is referenced in an index.
-// It consists of three buckets: the first bucket maps the hash of each
-// block to the unique ID and the second maps that ID back to the block hash.
-// The third bucket contains the last received block ID, and is used
-// when starting the node to check that the enabled indexes are up to date
-// with the latest received block, and if not, initiate recovery process.
-//
-// The serialized format for keys and values in the block hash to ID bucket is:
-//   <hash> = <ID>
-//
-//   Field           Type              Size
-//   hash            daghash.Hash     32 bytes
-//   ID              uint64            8 bytes
-//   -----
-//   Total: 40 bytes
-//
-// The serialized format for keys and values in the ID to block hash bucket is:
-//   <ID> = <hash>
-//
-//   Field           Type              Size
-//   ID              uint64            8 bytes
-//   hash            daghash.Hash     32 bytes
-//   -----
-//   Total: 40 bytes
-//
-// -----------------------------------------------------------------------------
-
-const blockIDSize = 8 // 8 bytes for block ID
-
-// DBFetchBlockIDByHash uses an existing database transaction to retrieve the
-// block id for the provided hash from the index.
-func DBFetchBlockIDByHash(dbTx database.Tx, hash *daghash.Hash) (uint64, error) {
-	hashIndex := dbTx.Metadata().Bucket(idByHashIndexBucketName)
-	serializedID := hashIndex.Get(hash[:])
-	if serializedID == nil {
-		return 0, errors.Errorf("no entry in the block ID index for block with hash %s", hash)
-	}
-
-	return DeserializeBlockID(serializedID), nil
-}
-
-// DBFetchBlockHashBySerializedID uses an existing database transaction to
-// retrieve the hash for the provided serialized block id from the index.
-func DBFetchBlockHashBySerializedID(dbTx database.Tx, serializedID []byte) (*daghash.Hash, error) {
-	idIndex := dbTx.Metadata().Bucket(hashByIDIndexBucketName)
-	hashBytes := idIndex.Get(serializedID)
-	if hashBytes == nil {
-		return nil, errors.Errorf("no entry in the block ID index for block with id %d", byteOrder.Uint64(serializedID))
-	}
-
-	var hash daghash.Hash
-	copy(hash[:], hashBytes)
-	return &hash, nil
-}
-
-// dbPutBlockIDIndexEntry uses an existing database transaction to update or add
-// the index entries for the hash to id and id to hash mappings for the provided
-// values.
-func dbPutBlockIDIndexEntry(dbTx database.Tx, hash *daghash.Hash, serializedID []byte) error {
-	// Add the block hash to ID mapping to the index.
-	meta := dbTx.Metadata()
-	hashIndex := meta.Bucket(idByHashIndexBucketName)
-	if err := hashIndex.Put(hash[:], serializedID[:]); err != nil {
-		return err
-	}
-
-	// Add the block ID to hash mapping to the index.
-	idIndex := meta.Bucket(hashByIDIndexBucketName)
-	return idIndex.Put(serializedID[:], hash[:])
-}
-
-// DBFetchCurrentBlockID returns the last known block ID.
-func DBFetchCurrentBlockID(dbTx database.Tx) uint64 {
-	serializedID := dbTx.Metadata().Get(currentBlockIDKey)
-	if serializedID == nil {
-		return 0
-	}
-	return DeserializeBlockID(serializedID)
-}
-
-// DeserializeBlockID returns a deserialized block id
-func DeserializeBlockID(serializedID []byte) uint64 {
-	return byteOrder.Uint64(serializedID)
-}
-
-// SerializeBlockID returns a serialized block id
-func SerializeBlockID(blockID uint64) []byte {
-	serializedBlockID := make([]byte, blockIDSize)
-	byteOrder.PutUint64(serializedBlockID, blockID)
-	return serializedBlockID
-}
-
-// DBFetchBlockHashByID uses an existing database transaction to retrieve the
-// hash for the provided block id from the index.
-func DBFetchBlockHashByID(dbTx database.Tx, id uint64) (*daghash.Hash, error) {
-	return DBFetchBlockHashBySerializedID(dbTx, SerializeBlockID(id))
-}
-
-func createBlockID(dbTx database.Tx, blockHash *daghash.Hash) (uint64, error) {
-	currentBlockID := DBFetchCurrentBlockID(dbTx)
-	newBlockID := currentBlockID + 1
-	serializedNewBlockID := SerializeBlockID(newBlockID)
-	err := dbTx.Metadata().Put(currentBlockIDKey, serializedNewBlockID)
-	if err != nil {
-		return 0, err
-	}
-	err = dbPutBlockIDIndexEntry(dbTx, blockHash, serializedNewBlockID)
-	if err != nil {
-		return 0, err
-	}
-	return newBlockID, nil
-}

blockdag/blocklocator.go

@@ -1,102 +0,0 @@
-package blockdag
-
-import (
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/pkg/errors"
-)
-
-// BlockLocator is used to help locate a specific block. The algorithm for
-// building the block locator is to add block hashes in reverse order on the
-// block's selected parent chain until the desired stop block is reached.
-// In order to keep the list of locator hashes to a reasonable number of entries,
-// the step between each entry is doubled each loop iteration to exponentially
-// decrease the number of hashes as a function of the distance from the block
-// being located.
-//
-// For example, assume a selected parent chain with IDs as depicted below, and the
-// stop block is genesis:
-// 	genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
-//
-// The block locator for block 17 would be the hashes of blocks:
-//  [17 16 14 11 7 2 genesis]
-type BlockLocator []*daghash.Hash
-
-// BlockLocatorFromHashes returns a block locator from high and low hash.
-// See BlockLocator for details on the algorithm used to create a block locator.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) BlockLocatorFromHashes(highHash, lowHash *daghash.Hash) (BlockLocator, error) {
-	dag.dagLock.RLock()
-	defer dag.dagLock.RUnlock()
-
-	highNode := dag.index.LookupNode(highHash)
-	lowNode := dag.index.LookupNode(lowHash)
-
-	return dag.blockLocator(highNode, lowNode)
-}
-
-// blockLocator returns a block locator for the passed high and low nodes.
-// See the BlockLocator type comments for more details.
-//
-// This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) blockLocator(highNode, lowNode *blockNode) (BlockLocator, error) {
-	// We use the selected parent of the high node, so the
-	// block locator won't contain the high node.
-	highNode = highNode.selectedParent
-
-	node := highNode
-	step := uint64(1)
-	locator := make(BlockLocator, 0)
-	for node != nil {
-		locator = append(locator, node.hash)
-
-		// Nothing more to add once the low node has been added.
-		if node.blueScore <= lowNode.blueScore {
-			if node != lowNode {
-				return nil, errors.Errorf("highNode and lowNode are " +
-					"not in the same selected parent chain.")
-			}
-			break
-		}
-
-		// Calculate blueScore of previous node to include ensuring the
-		// final node is lowNode.
-		nextBlueScore := node.blueScore - step
-		if nextBlueScore < lowNode.blueScore {
-			nextBlueScore = lowNode.blueScore
-		}
-
-		// walk backwards through the nodes to the correct ancestor.
-		node = node.SelectedAncestor(nextBlueScore)
-
-		// Double the distance between included hashes.
-		step *= 2
-	}
-
-	return locator, nil
-}
-
-// FindNextLocatorBoundaries returns the lowest unknown block locator, hash
-// and the highest known block locator hash. This is used to create the
-// next block locator to find the highest shared known chain block with the
-// sync peer.
-//
-// This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) FindNextLocatorBoundaries(locator BlockLocator) (highHash, lowHash *daghash.Hash) {
-	// Find the most recent locator block hash in the DAG. In the case none of
-	// the hashes in the locator are in the DAG, fall back to the genesis block.
-	lowNode := dag.genesis
-	nextBlockLocatorIndex := int64(len(locator) - 1)
-	for i, hash := range locator {
-		node := dag.index.LookupNode(hash)
-		if node != nil {
-			lowNode = node
-			nextBlockLocatorIndex = int64(i) - 1
-			break
-		}
-	}
-	if nextBlockLocatorIndex < 0 {
-		return nil, lowNode.hash
-	}
-	return locator[nextBlockLocatorIndex], lowNode.hash
-}

blockdag/compress.go

@@ -1,584 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/txscript"
-)
-
-// -----------------------------------------------------------------------------
-// A variable length quantity (VLQ) is an encoding that uses an arbitrary number
-// of binary octets to represent an arbitrarily large integer. The scheme
-// employs a most significant byte (MSB) base-128 encoding where the high bit in
-// each byte indicates whether or not the byte is the final one. In addition,
-// to ensure there are no redundant encodings, an offset is subtracted every
-// time a group of 7 bits is shifted out. Therefore each integer can be
-// represented in exactly one way, and each representation stands for exactly
-// one integer.
-//
-// Another nice property of this encoding is that it provides a compact
-// representation of values that are typically used to indicate sizes. For
-// example, the values 0 - 127 are represented with a single byte, 128 - 16511
-// with two bytes, and 16512 - 2113663 with three bytes.
-//
-// While the encoding allows arbitrarily large integers, it is artificially
-// limited in this code to an unsigned 64-bit integer for efficiency purposes.
-//
-// Example encodings:
-//           0 -> [0x00]
-//         127 -> [0x7f]                 * Max 1-byte value
-//         128 -> [0x80 0x00]
-//         129 -> [0x80 0x01]
-//         255 -> [0x80 0x7f]
-//         256 -> [0x81 0x00]
-//       16511 -> [0xff 0x7f]            * Max 2-byte value
-//       16512 -> [0x80 0x80 0x00]
-//       32895 -> [0x80 0xff 0x7f]
-//     2113663 -> [0xff 0xff 0x7f]       * Max 3-byte value
-//   270549119 -> [0xff 0xff 0xff 0x7f]  * Max 4-byte value
-//      2^64-1 -> [0x80 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0x7f]
-//
-// References:
-//   https://en.wikipedia.org/wiki/Variable-length_quantity
-//   http://www.codecodex.com/wiki/Variable-Length_Integers
-// -----------------------------------------------------------------------------
-
-// serializeSizeVLQ returns the number of bytes it would take to serialize the
-// passed number as a variable-length quantity according to the format described
-// above.
-func serializeSizeVLQ(n uint64) int {
-	size := 1
-	for ; n > 0x7f; n = (n >> 7) - 1 {
-		size++
-	}
-
-	return size
-}
-
-// putVLQ serializes the provided number to a variable-length quantity according
-// to the format described above and returns the number of bytes of the encoded
-// value. The result is placed directly into the passed byte slice which must
-// be at least large enough to handle the number of bytes returned by the
-// serializeSizeVLQ function or it will panic.
-func putVLQ(target []byte, n uint64) int {
-	offset := 0
-	for ; ; offset++ {
-		// The high bit is set when another byte follows.
-		highBitMask := byte(0x80)
-		if offset == 0 {
-			highBitMask = 0x00
-		}
-
-		target[offset] = byte(n&0x7f) | highBitMask
-		if n <= 0x7f {
-			break
-		}
-		n = (n >> 7) - 1
-	}
-
-	// Reverse the bytes so it is MSB-encoded.
-	for i, j := 0, offset; i < j; i, j = i+1, j-1 {
-		target[i], target[j] = target[j], target[i]
-	}
-
-	return offset + 1
-}
-
-// deserializeVLQ deserializes the provided variable-length quantity according
-// to the format described above. It also returns the number of bytes
-// deserialized.
-func deserializeVLQ(serialized []byte) (uint64, int) {
-	var n uint64
-	var size int
-	for _, val := range serialized {
-		size++
-		n = (n << 7) | uint64(val&0x7f)
-		if val&0x80 != 0x80 {
-			break
-		}
-		n++
-	}
-
-	return n, size
-}
-
-// -----------------------------------------------------------------------------
-// In order to reduce the size of stored scripts, a domain specific compression
-// algorithm is used which recognizes standard scripts and stores them using
-// less bytes than the original script.
-//
-// The general serialized format is:
-//
-//   <script size or type><script data>
-//
-//   Field                 Type     Size
-//   script size or type   VLQ      variable
-//   script data           []byte   variable
-//
-// The specific serialized format for each recognized standard script is:
-//
-// - Pay-to-pubkey-hash: (21 bytes) - <0><20-byte pubkey hash>
-// - Pay-to-script-hash: (21 bytes) - <1><20-byte script hash>
-// - Pay-to-pubkey**:    (33 bytes) - <2, 3, 4, or 5><32-byte pubkey X value>
-//   2, 3 = compressed pubkey with bit 0 specifying the y coordinate to use
-//   4, 5 = uncompressed pubkey with bit 0 specifying the y coordinate to use
-//   ** Only valid public keys starting with 0x02, 0x03, and 0x04 are supported.
-//
-// Any scripts which are not recognized as one of the aforementioned standard
-// scripts are encoded using the general serialized format and encode the script
-// size as the sum of the actual size of the script and the number of special
-// cases.
-// -----------------------------------------------------------------------------
-
-// The following constants specify the special constants used to identify a
-// special script type in the domain-specific compressed script encoding.
-//
-// NOTE: This section specifically does not use iota since these values are
-// serialized and must be stable for long-term storage.
-const (
-	// cstPayToPubKeyHash identifies a compressed pay-to-pubkey-hash script.
-	cstPayToPubKeyHash = 0
-
-	// cstPayToScriptHash identifies a compressed pay-to-script-hash script.
-	cstPayToScriptHash = 1
-
-	// cstPayToPubKeyComp2 identifies a compressed pay-to-pubkey script to
-	// a compressed pubkey. Bit 0 specifies which y-coordinate to use
-	// to reconstruct the full uncompressed pubkey.
-	cstPayToPubKeyComp2 = 2
-
-	// cstPayToPubKeyComp3 identifies a compressed pay-to-pubkey script to
-	// a compressed pubkey. Bit 0 specifies which y-coordinate to use
-	// to reconstruct the full uncompressed pubkey.
-	cstPayToPubKeyComp3 = 3
-
-	// cstPayToPubKeyUncomp4 identifies a compressed pay-to-pubkey script to
-	// an uncompressed pubkey. Bit 0 specifies which y-coordinate to use
-	// to reconstruct the full uncompressed pubkey.
-	cstPayToPubKeyUncomp4 = 4
-
-	// cstPayToPubKeyUncomp5 identifies a compressed pay-to-pubkey script to
-	// an uncompressed pubkey. Bit 0 specifies which y-coordinate to use
-	// to reconstruct the full uncompressed pubkey.
-	cstPayToPubKeyUncomp5 = 5
-
-	// numSpecialScripts is the number of special scripts recognized by the
-	// domain-specific script compression algorithm.
-	numSpecialScripts = 6
-)
-
-// isPubKeyHash returns whether or not the passed public key script is a
-// standard pay-to-pubkey-hash script along with the pubkey hash it is paying to
-// if it is.
-func isPubKeyHash(script []byte) (bool, []byte) {
-	if len(script) == 25 && script[0] == txscript.OpDup &&
-		script[1] == txscript.OpHash160 &&
-		script[2] == txscript.OpData20 &&
-		script[23] == txscript.OpEqualVerify &&
-		script[24] == txscript.OpCheckSig {
-
-		return true, script[3:23]
-	}
-
-	return false, nil
-}
-
-// isScriptHash returns whether or not the passed public key script is a
-// standard pay-to-script-hash script along with the script hash it is paying to
-// if it is.
-func isScriptHash(script []byte) (bool, []byte) {
-	if len(script) == 23 && script[0] == txscript.OpHash160 &&
-		script[1] == txscript.OpData20 &&
-		script[22] == txscript.OpEqual {
-
-		return true, script[2:22]
-	}
-
-	return false, nil
-}
-
-// isPubKey returns whether or not the passed public key script is a standard
-// pay-to-pubkey script that pays to a valid compressed or uncompressed public
-// key along with the serialized pubkey it is paying to if it is.
-//
-// NOTE: This function ensures the public key is actually valid since the
-// compression algorithm requires valid pubkeys. It does not support hybrid
-// pubkeys. This means that even if the script has the correct form for a
-// pay-to-pubkey script, this function will only return true when it is paying
-// to a valid compressed or uncompressed pubkey.
-func isPubKey(script []byte) (bool, []byte) {
-	// Pay-to-compressed-pubkey script.
-	if len(script) == 35 && script[0] == txscript.OpData33 &&
-		script[34] == txscript.OpCheckSig && (script[1] == 0x02 ||
-		script[1] == 0x03) {
-
-		// Ensure the public key is valid.
-		serializedPubKey := script[1:34]
-		_, err := ecc.ParsePubKey(serializedPubKey, ecc.S256())
-		if err == nil {
-			return true, serializedPubKey
-		}
-	}
-
-	// Pay-to-uncompressed-pubkey script.
-	if len(script) == 67 && script[0] == txscript.OpData65 &&
-		script[66] == txscript.OpCheckSig && script[1] == 0x04 {
-
-		// Ensure the public key is valid.
-		serializedPubKey := script[1:66]
-		_, err := ecc.ParsePubKey(serializedPubKey, ecc.S256())
-		if err == nil {
-			return true, serializedPubKey
-		}
-	}
-
-	return false, nil
-}
-
-// compressedScriptSize returns the number of bytes the passed script would take
-// when encoded with the domain specific compression algorithm described above.
-func compressedScriptSize(scriptPubKey []byte) int {
-	// Pay-to-pubkey-hash script.
-	if valid, _ := isPubKeyHash(scriptPubKey); valid {
-		return 21
-	}
-
-	// Pay-to-script-hash script.
-	if valid, _ := isScriptHash(scriptPubKey); valid {
-		return 21
-	}
-
-	// Pay-to-pubkey (compressed or uncompressed) script.
-	if valid, _ := isPubKey(scriptPubKey); valid {
-		return 33
-	}
-
-	// When none of the above special cases apply, encode the script as is
-	// preceded by the sum of its size and the number of special cases
-	// encoded as a variable length quantity.
-	return serializeSizeVLQ(uint64(len(scriptPubKey)+numSpecialScripts)) +
-		len(scriptPubKey)
-}
-
-// decodeCompressedScriptSize treats the passed serialized bytes as a compressed
-// script, possibly followed by other data, and returns the number of bytes it
-// occupies taking into account the special encoding of the script size by the
-// domain specific compression algorithm described above.
-func decodeCompressedScriptSize(serialized []byte) int {
-	scriptSize, bytesRead := deserializeVLQ(serialized)
-	if bytesRead == 0 {
-		return 0
-	}
-
-	switch scriptSize {
-	case cstPayToPubKeyHash:
-		return 21
-
-	case cstPayToScriptHash:
-		return 21
-
-	case cstPayToPubKeyComp2, cstPayToPubKeyComp3, cstPayToPubKeyUncomp4,
-		cstPayToPubKeyUncomp5:
-		return 33
-	}
-
-	scriptSize -= numSpecialScripts
-	scriptSize += uint64(bytesRead)
-	return int(scriptSize)
-}
-
-// putCompressedScript compresses the passed script according to the domain
-// specific compression algorithm described above directly into the passed
-// target byte slice. The target byte slice must be at least large enough to
-// handle the number of bytes returned by the compressedScriptSize function or
-// it will panic.
-func putCompressedScript(target, scriptPubKey []byte) int {
-	// Pay-to-pubkey-hash script.
-	if valid, hash := isPubKeyHash(scriptPubKey); valid {
-		target[0] = cstPayToPubKeyHash
-		copy(target[1:21], hash)
-		return 21
-	}
-
-	// Pay-to-script-hash script.
-	if valid, hash := isScriptHash(scriptPubKey); valid {
-		target[0] = cstPayToScriptHash
-		copy(target[1:21], hash)
-		return 21
-	}
-
-	// Pay-to-pubkey (compressed or uncompressed) script.
-	if valid, serializedPubKey := isPubKey(scriptPubKey); valid {
-		pubKeyFormat := serializedPubKey[0]
-		switch pubKeyFormat {
-		case 0x02, 0x03:
-			target[0] = pubKeyFormat
-			copy(target[1:33], serializedPubKey[1:33])
-			return 33
-		case 0x04:
-			// Encode the oddness of the serialized pubkey into the
-			// compressed script type.
-			target[0] = pubKeyFormat | (serializedPubKey[64] & 0x01)
-			copy(target[1:33], serializedPubKey[1:33])
-			return 33
-		}
-	}
-
-	// When none of the above special cases apply, encode the unmodified
-	// script preceded by the sum of its size and the number of special
-	// cases encoded as a variable length quantity.
-	encodedSize := uint64(len(scriptPubKey) + numSpecialScripts)
-	vlqSizeLen := putVLQ(target, encodedSize)
-	copy(target[vlqSizeLen:], scriptPubKey)
-	return vlqSizeLen + len(scriptPubKey)
-}
-
-// decompressScript returns the original script obtained by decompressing the
-// passed compressed script according to the domain specific compression
-// algorithm described above.
-//
-// NOTE: The script parameter must already have been proven to be long enough
-// to contain the number of bytes returned by decodeCompressedScriptSize or it
-// will panic. This is acceptable since it is only an internal function.
-func decompressScript(compressedScriptPubKey []byte) []byte {
-	// In practice this function will not be called with a zero-length or
-	// nil script since the nil script encoding includes the length, however
-	// the code below assumes the length exists, so just return nil now if
-	// the function ever ends up being called with a nil script in the
-	// future.
-	if len(compressedScriptPubKey) == 0 {
-		return nil
-	}
-
-	// Decode the script size and examine it for the special cases.
-	encodedScriptSize, bytesRead := deserializeVLQ(compressedScriptPubKey)
-	switch encodedScriptSize {
-	// Pay-to-pubkey-hash script. The resulting script is:
-	// <OP_DUP><OP_HASH160><20 byte hash><OP_EQUALVERIFY><OP_CHECKSIG>
-	case cstPayToPubKeyHash:
-		scriptPubKey := make([]byte, 25)
-		scriptPubKey[0] = txscript.OpDup
-		scriptPubKey[1] = txscript.OpHash160
-		scriptPubKey[2] = txscript.OpData20
-		copy(scriptPubKey[3:], compressedScriptPubKey[bytesRead:bytesRead+20])
-		scriptPubKey[23] = txscript.OpEqualVerify
-		scriptPubKey[24] = txscript.OpCheckSig
-		return scriptPubKey
-
-	// Pay-to-script-hash script. The resulting script is:
-	// <OP_HASH160><20 byte script hash><OP_EQUAL>
-	case cstPayToScriptHash:
-		scriptPubKey := make([]byte, 23)
-		scriptPubKey[0] = txscript.OpHash160
-		scriptPubKey[1] = txscript.OpData20
-		copy(scriptPubKey[2:], compressedScriptPubKey[bytesRead:bytesRead+20])
-		scriptPubKey[22] = txscript.OpEqual
-		return scriptPubKey
-
-	// Pay-to-compressed-pubkey script. The resulting script is:
-	// <OP_DATA_33><33 byte compressed pubkey><OP_CHECKSIG>
-	case cstPayToPubKeyComp2, cstPayToPubKeyComp3:
-		scriptPubKey := make([]byte, 35)
-		scriptPubKey[0] = txscript.OpData33
-		scriptPubKey[1] = byte(encodedScriptSize)
-		copy(scriptPubKey[2:], compressedScriptPubKey[bytesRead:bytesRead+32])
-		scriptPubKey[34] = txscript.OpCheckSig
-		return scriptPubKey
-
-	// Pay-to-uncompressed-pubkey script. The resulting script is:
-	// <OP_DATA_65><65 byte uncompressed pubkey><OP_CHECKSIG>
-	case cstPayToPubKeyUncomp4, cstPayToPubKeyUncomp5:
-		// Change the leading byte to the appropriate compressed pubkey
-		// identifier (0x02 or 0x03) so it can be decoded as a
-		// compressed pubkey. This really should never fail since the
-		// encoding ensures it is valid before compressing to this type.
-		compressedKey := make([]byte, 33)
-		compressedKey[0] = byte(encodedScriptSize - 2)
-		copy(compressedKey[1:], compressedScriptPubKey[1:])
-		key, err := ecc.ParsePubKey(compressedKey, ecc.S256())
-		if err != nil {
-			return nil
-		}
-
-		scriptPubKey := make([]byte, 67)
-		scriptPubKey[0] = txscript.OpData65
-		copy(scriptPubKey[1:], key.SerializeUncompressed())
-		scriptPubKey[66] = txscript.OpCheckSig
-		return scriptPubKey
-	}
-
-	// When none of the special cases apply, the script was encoded using
-	// the general format, so reduce the script size by the number of
-	// special cases and return the unmodified script.
-	scriptSize := int(encodedScriptSize - numSpecialScripts)
-	scriptPubKey := make([]byte, scriptSize)
-	copy(scriptPubKey, compressedScriptPubKey[bytesRead:bytesRead+scriptSize])
-	return scriptPubKey
-}
-
-// -----------------------------------------------------------------------------
-// In order to reduce the size of stored amounts, a domain specific compression
-// algorithm is used which relies on there typically being a lot of zeroes at
-// end of the amounts.
-//
-// While this is simply exchanging one uint64 for another, the resulting value
-// for typical amounts has a much smaller magnitude which results in fewer bytes
-// when encoded as variable length quantity. For example, consider the amount
-// of 0.1 KAS which is 10000000 sompi. Encoding 10000000 as a VLQ would take
-// 4 bytes while encoding the compressed value of 8 as a VLQ only takes 1 byte.
-//
-// Essentially the compression is achieved by splitting the value into an
-// exponent in the range [0-9] and a digit in the range [1-9], when possible,
-// and encoding them in a way that can be decoded. More specifically, the
-// encoding is as follows:
-// - 0 is 0
-// - Find the exponent, e, as the largest power of 10 that evenly divides the
-//   value up to a maximum of 9
-// - When e < 9, the final digit can't be 0 so store it as d and remove it by
-//   dividing the value by 10 (call the result n). The encoded value is thus:
-//   1 + 10*(9*n + d-1) + e
-// - When e==9, the only thing known is the amount is not 0. The encoded value
-//   is thus:
-//   1 + 10*(n-1) + e   ==   10 + 10*(n-1)
-//
-// Example encodings:
-// (The numbers in parenthesis are the number of bytes when serialized as a VLQ)
-//            0 (1) -> 0        (1)           *  0.00000000 KAS
-//         1000 (2) -> 4        (1)           *  0.00001000 KAS
-//        10000 (2) -> 5        (1)           *  0.00010000 KAS
-//     12345678 (4) -> 111111101(4)           *  0.12345678 KAS
-//     50000000 (4) -> 47       (1)           *  0.50000000 KAS
-//    100000000 (4) -> 9        (1)           *  1.00000000 KAS
-//    500000000 (5) -> 49       (1)           *  5.00000000 KAS
-//   1000000000 (5) -> 10       (1)           * 10.00000000 KAS
-// -----------------------------------------------------------------------------
-
-// compressTxOutAmount compresses the passed amount according to the domain
-// specific compression algorithm described above.
-func compressTxOutAmount(amount uint64) uint64 {
-	// No need to do any work if it's zero.
-	if amount == 0 {
-		return 0
-	}
-
-	// Find the largest power of 10 (max of 9) that evenly divides the
-	// value.
-	exponent := uint64(0)
-	for amount%10 == 0 && exponent < 9 {
-		amount /= 10
-		exponent++
-	}
-
-	// The compressed result for exponents less than 9 is:
-	// 1 + 10*(9*n + d-1) + e
-	if exponent < 9 {
-		lastDigit := amount % 10
-		amount /= 10
-		return 1 + 10*(9*amount+lastDigit-1) + exponent
-	}
-
-	// The compressed result for an exponent of 9 is:
-	// 1 + 10*(n-1) + e   ==   10 + 10*(n-1)
-	return 10 + 10*(amount-1)
-}
-
-// decompressTxOutAmount returns the original amount the passed compressed
-// amount represents according to the domain specific compression algorithm
-// described above.
-func decompressTxOutAmount(amount uint64) uint64 {
-	// No need to do any work if it's zero.
-	if amount == 0 {
-		return 0
-	}
-
-	// The decompressed amount is either of the following two equations:
-	// x = 1 + 10*(9*n + d - 1) + e
-	// x = 1 + 10*(n - 1)       + 9
-	amount--
-
-	// The decompressed amount is now one of the following two equations:
-	// x = 10*(9*n + d - 1) + e
-	// x = 10*(n - 1)       + 9
-	exponent := amount % 10
-	amount /= 10
-
-	// The decompressed amount is now one of the following two equations:
-	// x = 9*n + d - 1  | where e < 9
-	// x = n - 1        | where e = 9
-	n := uint64(0)
-	if exponent < 9 {
-		lastDigit := amount%9 + 1
-		amount /= 9
-		n = amount*10 + lastDigit
-	} else {
-		n = amount + 1
-	}
-
-	// Apply the exponent.
-	for ; exponent > 0; exponent-- {
-		n *= 10
-	}
-
-	return n
-}
-
-// -----------------------------------------------------------------------------
-// Compressed transaction outputs consist of an amount and a public key script
-// both compressed using the domain specific compression algorithms previously
-// described.
-//
-// The serialized format is:
-//
-//   <compressed amount><compressed script>
-//
-//   Field                 Type     Size
-//     compressed amount   VLQ      variable
-//     compressed script   []byte   variable
-// -----------------------------------------------------------------------------
-
-// compressedTxOutSize returns the number of bytes the passed transaction output
-// fields would take when encoded with the format described above.
-func compressedTxOutSize(amount uint64, scriptPubKey []byte) int {
-	return serializeSizeVLQ(compressTxOutAmount(amount)) +
-		compressedScriptSize(scriptPubKey)
-}
-
-// putCompressedTxOut compresses the passed amount and script according to their
-// domain specific compression algorithms and encodes them directly into the
-// passed target byte slice with the format described above. The target byte
-// slice must be at least large enough to handle the number of bytes returned by
-// the compressedTxOutSize function or it will panic.
-func putCompressedTxOut(target []byte, amount uint64, scriptPubKey []byte) int {
-	offset := putVLQ(target, compressTxOutAmount(amount))
-	offset += putCompressedScript(target[offset:], scriptPubKey)
-	return offset
-}
-
-// decodeCompressedTxOut decodes the passed compressed txout, possibly followed
-// by other data, into its uncompressed amount and script and returns them along
-// with the number of bytes they occupied prior to decompression.
-func decodeCompressedTxOut(serialized []byte) (uint64, []byte, int, error) {
-	// Deserialize the compressed amount and ensure there are bytes
-	// remaining for the compressed script.
-	compressedAmount, bytesRead := deserializeVLQ(serialized)
-	if bytesRead >= len(serialized) {
-		return 0, nil, bytesRead, errDeserialize("unexpected end of " +
-			"data after compressed amount")
-	}
-
-	// Decode the compressed script size and ensure there are enough bytes
-	// left in the slice for it.
-	scriptSize := decodeCompressedScriptSize(serialized[bytesRead:])
-	if len(serialized[bytesRead:]) < scriptSize {
-		return 0, nil, bytesRead, errDeserialize("unexpected end of " +
-			"data after script size")
-	}
-
-	// Decompress and return the amount and script.
-	amount := decompressTxOutAmount(compressedAmount)
-	script := decompressScript(serialized[bytesRead : bytesRead+scriptSize])
-	return amount, script, bytesRead + scriptSize, nil
-}

blockdag/compress_test.go

@@ -1,436 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-)
-
-// hexToBytes converts the passed hex string into bytes and will panic if 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 called with
-// hard-coded values.
-func hexToBytes(s string) []byte {
-	b, err := hex.DecodeString(s)
-	if err != nil {
-		panic("invalid hex in source file: " + s)
-	}
-	return b
-}
-
-// TestVLQ ensures the variable length quantity serialization, deserialization,
-// and size calculation works as expected.
-func TestVLQ(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		val        uint64
-		serialized []byte
-	}{
-		{0, hexToBytes("00")},
-		{1, hexToBytes("01")},
-		{127, hexToBytes("7f")},
-		{128, hexToBytes("8000")},
-		{129, hexToBytes("8001")},
-		{255, hexToBytes("807f")},
-		{256, hexToBytes("8100")},
-		{16383, hexToBytes("fe7f")},
-		{16384, hexToBytes("ff00")},
-		{16511, hexToBytes("ff7f")}, // Max 2-byte value
-		{16512, hexToBytes("808000")},
-		{16513, hexToBytes("808001")},
-		{16639, hexToBytes("80807f")},
-		{32895, hexToBytes("80ff7f")},
-		{2113663, hexToBytes("ffff7f")}, // Max 3-byte value
-		{2113664, hexToBytes("80808000")},
-		{270549119, hexToBytes("ffffff7f")}, // Max 4-byte value
-		{270549120, hexToBytes("8080808000")},
-		{2147483647, hexToBytes("86fefefe7f")},
-		{2147483648, hexToBytes("86fefeff00")},
-		{4294967295, hexToBytes("8efefefe7f")}, // Max uint32, 5 bytes
-		// Max uint64, 10 bytes
-		{18446744073709551615, hexToBytes("80fefefefefefefefe7f")},
-	}
-
-	for _, test := range tests {
-		// Ensure the function to calculate the serialized size without
-		// actually serializing the value is calculated properly.
-		gotSize := serializeSizeVLQ(test.val)
-		if gotSize != len(test.serialized) {
-			t.Errorf("serializeSizeVLQ: did not get expected size "+
-				"for %d - got %d, want %d", test.val, gotSize,
-				len(test.serialized))
-			continue
-		}
-
-		// Ensure the value serializes to the expected bytes.
-		gotBytes := make([]byte, gotSize)
-		gotBytesWritten := putVLQ(gotBytes, test.val)
-		if !bytes.Equal(gotBytes, test.serialized) {
-			t.Errorf("putVLQUnchecked: did not get expected bytes "+
-				"for %d - got %x, want %x", test.val, gotBytes,
-				test.serialized)
-			continue
-		}
-		if gotBytesWritten != len(test.serialized) {
-			t.Errorf("putVLQUnchecked: did not get expected number "+
-				"of bytes written for %d - got %d, want %d",
-				test.val, gotBytesWritten, len(test.serialized))
-			continue
-		}
-
-		// Ensure the serialized bytes deserialize to the expected
-		// value.
-		gotVal, gotBytesRead := deserializeVLQ(test.serialized)
-		if gotVal != test.val {
-			t.Errorf("deserializeVLQ: did not get expected value "+
-				"for %x - got %d, want %d", test.serialized,
-				gotVal, test.val)
-			continue
-		}
-		if gotBytesRead != len(test.serialized) {
-			t.Errorf("deserializeVLQ: did not get expected number "+
-				"of bytes read for %d - got %d, want %d",
-				test.serialized, gotBytesRead,
-				len(test.serialized))
-			continue
-		}
-	}
-}
-
-// TestScriptCompression ensures the domain-specific script compression and
-// decompression works as expected.
-func TestScriptCompression(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name         string
-		uncompressed []byte
-		compressed   []byte
-	}{
-		{
-			name:         "nil",
-			uncompressed: nil,
-			compressed:   hexToBytes("06"),
-		},
-		{
-			name:         "pay-to-pubkey-hash 1",
-			uncompressed: hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),
-			compressed:   hexToBytes("001018853670f9f3b0582c5b9ee8ce93764ac32b93"),
-		},
-		{
-			name:         "pay-to-pubkey-hash 2",
-			uncompressed: hexToBytes("76a914e34cce70c86373273efcc54ce7d2a491bb4a0e8488ac"),
-			compressed:   hexToBytes("00e34cce70c86373273efcc54ce7d2a491bb4a0e84"),
-		},
-		{
-			name:         "pay-to-script-hash 1",
-			uncompressed: hexToBytes("a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87"),
-			compressed:   hexToBytes("01da1745e9b549bd0bfa1a569971c77eba30cd5a4b"),
-		},
-		{
-			name:         "pay-to-script-hash 2",
-			uncompressed: hexToBytes("a914f815b036d9bbbce5e9f2a00abd1bf3dc91e9551087"),
-			compressed:   hexToBytes("01f815b036d9bbbce5e9f2a00abd1bf3dc91e95510"),
-		},
-		{
-			name:         "pay-to-pubkey compressed 0x02",
-			uncompressed: hexToBytes("2102192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4ac"),
-			compressed:   hexToBytes("02192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
-		},
-		{
-			name:         "pay-to-pubkey compressed 0x03",
-			uncompressed: hexToBytes("2103b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65ac"),
-			compressed:   hexToBytes("03b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65"),
-		},
-		{
-			name:         "pay-to-pubkey uncompressed 0x04 even",
-			uncompressed: hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),
-			compressed:   hexToBytes("04192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
-		},
-		{
-			name:         "pay-to-pubkey uncompressed 0x04 odd",
-			uncompressed: hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),
-			compressed:   hexToBytes("0511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"),
-		},
-		{
-			name:         "pay-to-pubkey invalid pubkey",
-			uncompressed: hexToBytes("3302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),
-			compressed:   hexToBytes("293302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),
-		},
-		{
-			name:         "requires 2 size bytes - data push 200 bytes",
-			uncompressed: append(hexToBytes("4cc8"), bytes.Repeat([]byte{0x00}, 200)...),
-			// [0x80, 0x50] = 208 as a variable length quantity
-			// [0x4c, 0xc8] = OP_PUSHDATA1 200
-			compressed: append(hexToBytes("80504cc8"), bytes.Repeat([]byte{0x00}, 200)...),
-		},
-	}
-
-	for _, test := range tests {
-		// Ensure the function to calculate the serialized size without
-		// actually serializing the value is calculated properly.
-		gotSize := compressedScriptSize(test.uncompressed)
-		if gotSize != len(test.compressed) {
-			t.Errorf("compressedScriptSize (%s): did not get "+
-				"expected size - got %d, want %d", test.name,
-				gotSize, len(test.compressed))
-			continue
-		}
-
-		// Ensure the script compresses to the expected bytes.
-		gotCompressed := make([]byte, gotSize)
-		gotBytesWritten := putCompressedScript(gotCompressed,
-			test.uncompressed)
-		if !bytes.Equal(gotCompressed, test.compressed) {
-			t.Errorf("putCompressedScript (%s): did not get "+
-				"expected bytes - got %x, want %x", test.name,
-				gotCompressed, test.compressed)
-			continue
-		}
-		if gotBytesWritten != len(test.compressed) {
-			t.Errorf("putCompressedScript (%s): did not get "+
-				"expected number of bytes written - got %d, "+
-				"want %d", test.name, gotBytesWritten,
-				len(test.compressed))
-			continue
-		}
-
-		// Ensure the compressed script size is properly decoded from
-		// the compressed script.
-		gotDecodedSize := decodeCompressedScriptSize(test.compressed)
-		if gotDecodedSize != len(test.compressed) {
-			t.Errorf("decodeCompressedScriptSize (%s): did not get "+
-				"expected size - got %d, want %d", test.name,
-				gotDecodedSize, len(test.compressed))
-			continue
-		}
-
-		// Ensure the script decompresses to the expected bytes.
-		gotDecompressed := decompressScript(test.compressed)
-		if !bytes.Equal(gotDecompressed, test.uncompressed) {
-			t.Errorf("decompressScript (%s): did not get expected "+
-				"bytes - got %x, want %x", test.name,
-				gotDecompressed, test.uncompressed)
-			continue
-		}
-	}
-}
-
-// TestScriptCompressionErrors ensures calling various functions related to
-// script compression with incorrect data returns the expected results.
-func TestScriptCompressionErrors(t *testing.T) {
-	t.Parallel()
-
-	// A nil script must result in a decoded size of 0.
-	if gotSize := decodeCompressedScriptSize(nil); gotSize != 0 {
-		t.Fatalf("decodeCompressedScriptSize with nil script did not "+
-			"return 0 - got %d", gotSize)
-	}
-
-	// A nil script must result in a nil decompressed script.
-	if gotScript := decompressScript(nil); gotScript != nil {
-		t.Fatalf("decompressScript with nil script did not return nil "+
-			"decompressed script - got %x", gotScript)
-	}
-
-	// A compressed script for a pay-to-pubkey (uncompressed) that results
-	// in an invalid pubkey must result in a nil decompressed script.
-	compressedScript := hexToBytes("04012d74d0cb94344c9569c2e77901573d8d" +
-		"7903c3ebec3a957724895dca52c6b4")
-	if gotScript := decompressScript(compressedScript); gotScript != nil {
-		t.Fatalf("decompressScript with compressed pay-to-"+
-			"uncompressed-pubkey that is invalid did not return "+
-			"nil decompressed script - got %x", gotScript)
-	}
-}
-
-// TestAmountCompression ensures the domain-specific transaction output amount
-// compression and decompression works as expected.
-func TestAmountCompression(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name         string
-		uncompressed uint64
-		compressed   uint64
-	}{
-		{
-			name:         "0 KAS",
-			uncompressed: 0,
-			compressed:   0,
-		},
-		{
-			name:         "546 Sompi (current network dust value)",
-			uncompressed: 546,
-			compressed:   4911,
-		},
-		{
-			name:         "0.00001 KAS (typical transaction fee)",
-			uncompressed: 1000,
-			compressed:   4,
-		},
-		{
-			name:         "0.0001 KAS (typical transaction fee)",
-			uncompressed: 10000,
-			compressed:   5,
-		},
-		{
-			name:         "0.12345678 KAS",
-			uncompressed: 12345678,
-			compressed:   111111101,
-		},
-		{
-			name:         "0.5 KAS",
-			uncompressed: 50000000,
-			compressed:   48,
-		},
-		{
-			name:         "1 KAS",
-			uncompressed: 100000000,
-			compressed:   9,
-		},
-		{
-			name:         "5 KAS",
-			uncompressed: 500000000,
-			compressed:   49,
-		},
-		{
-			name:         "21000000 KAS (max minted coins)",
-			uncompressed: 2100000000000000,
-			compressed:   21000000,
-		},
-	}
-
-	for _, test := range tests {
-		// Ensure the amount compresses to the expected value.
-		gotCompressed := compressTxOutAmount(test.uncompressed)
-		if gotCompressed != test.compressed {
-			t.Errorf("compressTxOutAmount (%s): did not get "+
-				"expected value - got %d, want %d", test.name,
-				gotCompressed, test.compressed)
-			continue
-		}
-
-		// Ensure the value decompresses to the expected value.
-		gotDecompressed := decompressTxOutAmount(test.compressed)
-		if gotDecompressed != test.uncompressed {
-			t.Errorf("decompressTxOutAmount (%s): did not get "+
-				"expected value - got %d, want %d", test.name,
-				gotDecompressed, test.uncompressed)
-			continue
-		}
-	}
-}
-
-// TestCompressedTxOut ensures the transaction output serialization and
-// deserialization works as expected.
-func TestCompressedTxOut(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name         string
-		amount       uint64
-		scriptPubKey []byte
-		compressed   []byte
-	}{
-		{
-			name:         "pay-to-pubkey-hash dust",
-			amount:       546,
-			scriptPubKey: hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),
-			compressed:   hexToBytes("a52f001018853670f9f3b0582c5b9ee8ce93764ac32b93"),
-		},
-		{
-			name:         "pay-to-pubkey uncompressed 1 KAS",
-			amount:       100000000,
-			scriptPubKey: hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),
-			compressed:   hexToBytes("0904192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
-		},
-	}
-
-	for _, test := range tests {
-		// Ensure the function to calculate the serialized size without
-		// actually serializing the txout is calculated properly.
-		gotSize := compressedTxOutSize(test.amount, test.scriptPubKey)
-		if gotSize != len(test.compressed) {
-			t.Errorf("compressedTxOutSize (%s): did not get "+
-				"expected size - got %d, want %d", test.name,
-				gotSize, len(test.compressed))
-			continue
-		}
-
-		// Ensure the txout compresses to the expected value.
-		gotCompressed := make([]byte, gotSize)
-		gotBytesWritten := putCompressedTxOut(gotCompressed,
-			test.amount, test.scriptPubKey)
-		if !bytes.Equal(gotCompressed, test.compressed) {
-			t.Errorf("compressTxOut (%s): did not get expected "+
-				"bytes - got %x, want %x", test.name,
-				gotCompressed, test.compressed)
-			continue
-		}
-		if gotBytesWritten != len(test.compressed) {
-			t.Errorf("compressTxOut (%s): did not get expected "+
-				"number of bytes written - got %d, want %d",
-				test.name, gotBytesWritten,
-				len(test.compressed))
-			continue
-		}
-
-		// Ensure the serialized bytes are decoded back to the expected
-		// uncompressed values.
-		gotAmount, gotScript, gotBytesRead, err := decodeCompressedTxOut(
-			test.compressed)
-		if err != nil {
-			t.Errorf("decodeCompressedTxOut (%s): unexpected "+
-				"error: %v", test.name, err)
-			continue
-		}
-		if gotAmount != test.amount {
-			t.Errorf("decodeCompressedTxOut (%s): did not get "+
-				"expected amount - got %d, want %d",
-				test.name, gotAmount, test.amount)
-			continue
-		}
-		if !bytes.Equal(gotScript, test.scriptPubKey) {
-			t.Errorf("decodeCompressedTxOut (%s): did not get "+
-				"expected script - got %x, want %x",
-				test.name, gotScript, test.scriptPubKey)
-			continue
-		}
-		if gotBytesRead != len(test.compressed) {
-			t.Errorf("decodeCompressedTxOut (%s): did not get "+
-				"expected number of bytes read - got %d, want %d",
-				test.name, gotBytesRead, len(test.compressed))
-			continue
-		}
-	}
-}
-
-// TestTxOutCompressionErrors ensures calling various functions related to
-// txout compression with incorrect data returns the expected results.
-func TestTxOutCompressionErrors(t *testing.T) {
-	t.Parallel()
-
-	// A compressed txout with missing compressed script must error.
-	compressedTxOut := hexToBytes("00")
-	_, _, _, err := decodeCompressedTxOut(compressedTxOut)
-	if !isDeserializeErr(err) {
-		t.Fatalf("decodeCompressedTxOut with missing compressed script "+
-			"did not return expected error type - got %T, want "+
-			"errDeserialize", err)
-	}
-
-	// A compressed txout with short compressed script must error.
-	compressedTxOut = hexToBytes("0010")
-	_, _, _, err = decodeCompressedTxOut(compressedTxOut)
-	if !isDeserializeErr(err) {
-		t.Fatalf("decodeCompressedTxOut with short compressed script "+
-			"did not return expected error type - got %T, want "+
-			"errDeserialize", err)
-	}
-}

blockdag/dagio.go

@@ -1,907 +0,0 @@
-// 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 blockdag
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/json"
-	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/pkg/errors"
-	"io"
-	"sync"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/binaryserializer"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const (
-	// blockHdrSize is the size of a block header. This is simply the
-	// constant from wire and is only provided here for convenience since
-	// wire.MaxBlockHeaderPayload is quite long.
-	blockHdrSize = wire.MaxBlockHeaderPayload
-
-	// latestUTXOSetBucketVersion is the current version of the UTXO set
-	// bucket that is used to track all unspent outputs.
-	latestUTXOSetBucketVersion = 1
-)
-
-var (
-	// blockIndexBucketName is the name of the database bucket used to house the
-	// block headers and contextual information.
-	blockIndexBucketName = []byte("blockheaderidx")
-
-	// dagStateKeyName is the name of the db key used to store the DAG
-	// tip hashes.
-	dagStateKeyName = []byte("dagstate")
-
-	// utxoSetVersionKeyName is the name of the db key used to store the
-	// version of the utxo set currently in the database.
-	utxoSetVersionKeyName = []byte("utxosetversion")
-
-	// utxoSetBucketName is the name of the database bucket used to house the
-	// unspent transaction output set.
-	utxoSetBucketName = []byte("utxoset")
-
-	// utxoDiffsBucketName is the name of the database bucket used to house the
-	// diffs and diff children of blocks.
-	utxoDiffsBucketName = []byte("utxodiffs")
-
-	// reachabilityDataBucketName is the name of the database bucket used to house the
-	// reachability tree nodes and future covering sets of blocks.
-	reachabilityDataBucketName = []byte("reachability")
-
-	// subnetworksBucketName is the name of the database bucket used to store the
-	// subnetwork registry.
-	subnetworksBucketName = []byte("subnetworks")
-
-	// localSubnetworkKeyName is the name of the db key used to store the
-	// node's local subnetwork ID.
-	localSubnetworkKeyName = []byte("localsubnetworkidkey")
-
-	// byteOrder is the preferred byte order used for serializing numeric
-	// fields for storage in the database.
-	byteOrder = binary.LittleEndian
-)
-
-// errNotInDAG signifies that a block hash or height that is not in the
-// DAG was requested.
-type errNotInDAG string
-
-// Error implements the error interface.
-func (e errNotInDAG) Error() string {
-	return string(e)
-}
-
-// isNotInDAGErr returns whether or not the passed error is an
-// errNotInDAG error.
-func isNotInDAGErr(err error) bool {
-	_, ok := err.(errNotInDAG)
-	return ok
-}
-
-// errDeserialize signifies that a problem was encountered when deserializing
-// data.
-type errDeserialize string
-
-// Error implements the error interface.
-func (e errDeserialize) Error() string {
-	return string(e)
-}
-
-// isDeserializeErr returns whether or not the passed error is an errDeserialize
-// error.
-func isDeserializeErr(err error) bool {
-	_, ok := err.(errDeserialize)
-	return ok
-}
-
-// dbPutVersion uses an existing database transaction to update the provided
-// key in the metadata bucket to the given version. It is primarily used to
-// track versions on entities such as buckets.
-func dbPutVersion(dbTx database.Tx, key []byte, version uint32) error {
-	var serialized [4]byte
-	byteOrder.PutUint32(serialized[:], version)
-	return dbTx.Metadata().Put(key, serialized[:])
-}
-
-// -----------------------------------------------------------------------------
-// The unspent transaction output (UTXO) set consists of an entry for each
-// unspent output using a format that is optimized to reduce space using domain
-// specific compression algorithms.
-//
-// Each entry is keyed by an outpoint as specified below. It is important to
-// note that the key encoding uses a VLQ, which employs an MSB encoding so
-// iteration of UTXOs when doing byte-wise comparisons will produce them in
-// order.
-//
-// The serialized key format is:
-//   <hash><output index>
-//
-//   Field                Type             Size
-//   hash                 daghash.Hash   daghash.HashSize
-//   output index         VLQ              variable
-//
-// The serialized value format is:
-//
-//   <header code><compressed txout>
-//
-//   Field                Type     Size
-//   header code          VLQ      variable
-//   compressed txout
-//     compressed amount  VLQ      variable
-//     compressed script  []byte   variable
-//
-// The serialized header code format is:
-//   bit 0 - containing transaction is a coinbase
-//   bits 1-x - height of the block that contains the unspent txout
-//
-// Example 1:
-// b7c3332bc138e2c9429818f5fed500bcc1746544218772389054dc8047d7cd3f:0
-//
-//    03320496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52
-//    <><------------------------------------------------------------------>
-//     |                                          |
-//   header code                         compressed txout
-//
-//  - header code: 0x03 (coinbase, height 1)
-//  - compressed txout:
-//    - 0x32: VLQ-encoded compressed amount for 5000000000 (50 KAS)
-//    - 0x04: special script type pay-to-pubkey
-//    - 0x96...52: x-coordinate of the pubkey
-//
-// Example 2:
-// 4a16969aa4764dd7507fc1de7f0baa4850a246de90c45e59a3207f9a26b5036f:2
-//
-//    8cf316800900b8025be1b3efc63b0ad48e7f9f10e87544528d58
-//    <----><------------------------------------------>
-//      |                             |
-//   header code             compressed txout
-//
-//  - header code: 0x8cf316 (not coinbase, height 113931)
-//  - compressed txout:
-//    - 0x8009: VLQ-encoded compressed amount for 15000000 (0.15 KAS)
-//    - 0x00: special script type pay-to-pubkey-hash
-//    - 0xb8...58: pubkey hash
-//
-// Example 3:
-// 1b02d1c8cfef60a189017b9a420c682cf4a0028175f2f563209e4ff61c8c3620:22
-//
-//    a8a2588ba5b9e763011dd46a006572d820e448e12d2bbb38640bc718e6
-//    <----><-------------------------------------------------->
-//      |                             |
-//   header code             compressed txout
-//
-//  - header code: 0xa8a258 (not coinbase, height 338156)
-//  - compressed txout:
-//    - 0x8ba5b9e763: VLQ-encoded compressed amount for 366875659 (3.66875659 KAS)
-//    - 0x01: special script type pay-to-script-hash
-//    - 0x1d...e6: script hash
-// -----------------------------------------------------------------------------
-
-// maxUint32VLQSerializeSize is the maximum number of bytes a max uint32 takes
-// to serialize as a VLQ.
-var maxUint32VLQSerializeSize = serializeSizeVLQ(1<<32 - 1)
-
-// outpointKeyPool defines a concurrent safe free list of byte slices used to
-// provide temporary buffers for outpoint database keys.
-var outpointKeyPool = sync.Pool{
-	New: func() interface{} {
-		b := make([]byte, daghash.HashSize+maxUint32VLQSerializeSize)
-		return &b // Pointer to slice to avoid boxing alloc.
-	},
-}
-
-// outpointKey returns a key suitable for use as a database key in the UTXO set
-// while making use of a free list. A new buffer is allocated if there are not
-// already any available on the free list. The returned byte slice should be
-// returned to the free list by using the recycleOutpointKey function when the
-// caller is done with it _unless_ the slice will need to live for longer than
-// the caller can calculate such as when used to write to the database.
-func outpointKey(outpoint wire.Outpoint) *[]byte {
-	// A VLQ employs an MSB encoding, so they are useful not only to reduce
-	// the amount of storage space, but also so iteration of UTXOs when
-	// doing byte-wise comparisons will produce them in order.
-	key := outpointKeyPool.Get().(*[]byte)
-	idx := uint64(outpoint.Index)
-	*key = (*key)[:daghash.HashSize+serializeSizeVLQ(idx)]
-	copy(*key, outpoint.TxID[:])
-	putVLQ((*key)[daghash.HashSize:], idx)
-	return key
-}
-
-// recycleOutpointKey puts the provided byte slice, which should have been
-// obtained via the outpointKey function, back on the free list.
-func recycleOutpointKey(key *[]byte) {
-	outpointKeyPool.Put(key)
-}
-
-// dbPutUTXODiff uses an existing database transaction to update the UTXO set
-// in the database based on the provided UTXO view contents and state. In
-// particular, only the entries that have been marked as modified are written
-// to the database.
-func dbPutUTXODiff(dbTx database.Tx, diff *UTXODiff) error {
-	utxoBucket := dbTx.Metadata().Bucket(utxoSetBucketName)
-	for outpoint := range diff.toRemove {
-		key := outpointKey(outpoint)
-		err := utxoBucket.Delete(*key)
-		recycleOutpointKey(key)
-		if err != nil {
-			return err
-		}
-	}
-
-	for outpoint, entry := range diff.toAdd {
-		// Serialize and store the UTXO entry.
-		serialized := serializeUTXOEntry(entry)
-
-		key := outpointKey(outpoint)
-		err := utxoBucket.Put(*key, serialized)
-		// NOTE: The key is intentionally not recycled here since the
-		// database interface contract prohibits modifications. It will
-		// be garbage collected normally when the database is done with
-		// it.
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-type dagState struct {
-	TipHashes         []*daghash.Hash
-	LastFinalityPoint *daghash.Hash
-}
-
-// serializeDAGState returns the serialization of the DAG state.
-// This is data to be stored in the DAG state bucket.
-func serializeDAGState(state *dagState) ([]byte, error) {
-	return json.Marshal(state)
-}
-
-// deserializeDAGState deserializes the passed serialized DAG state.
-// This is data stored in the DAG state bucket and is updated after
-// every block is connected to the DAG.
-func deserializeDAGState(serializedData []byte) (*dagState, error) {
-	var state *dagState
-	err := json.Unmarshal(serializedData, &state)
-	if err != nil {
-		return nil, database.Error{
-			ErrorCode:   database.ErrCorruption,
-			Description: "corrupt DAG state",
-		}
-	}
-
-	return state, nil
-}
-
-// dbPutDAGState uses an existing database transaction to store the latest
-// tip hashes of the DAG.
-func dbPutDAGState(dbTx database.Tx, state *dagState) error {
-	serializedData, err := serializeDAGState(state)
-
-	if err != nil {
-		return err
-	}
-
-	return dbTx.Metadata().Put(dagStateKeyName, serializedData)
-}
-
-// createDAGState initializes both the database and the DAG state to the
-// genesis block. This includes creating the necessary buckets, so it
-// must only be called on an uninitialized database.
-func (dag *BlockDAG) createDAGState() error {
-	// Create the initial the database DAG state including creating the
-	// necessary index buckets and inserting the genesis block.
-	err := dag.db.Update(func(dbTx database.Tx) error {
-		meta := dbTx.Metadata()
-
-		// Create the bucket that houses the block index data.
-		_, err := meta.CreateBucket(blockIndexBucketName)
-		if err != nil {
-			return err
-		}
-
-		// Create the buckets that house the utxo set, the utxo diffs, and their
-		// version.
-		_, err = meta.CreateBucket(utxoSetBucketName)
-		if err != nil {
-			return err
-		}
-
-		_, err = meta.CreateBucket(utxoDiffsBucketName)
-		if err != nil {
-			return err
-		}
-
-		_, err = meta.CreateBucket(reachabilityDataBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = dbPutVersion(dbTx, utxoSetVersionKeyName,
-			latestUTXOSetBucketVersion)
-		if err != nil {
-			return err
-		}
-
-		// Create the bucket that houses the registered subnetworks.
-		_, err = meta.CreateBucket(subnetworksBucketName)
-		if err != nil {
-			return err
-		}
-
-		if err := dbPutLocalSubnetworkID(dbTx, dag.subnetworkID); err != nil {
-			return err
-		}
-
-		if _, err := meta.CreateBucketIfNotExists(idByHashIndexBucketName); err != nil {
-			return err
-		}
-		if _, err := meta.CreateBucketIfNotExists(hashByIDIndexBucketName); err != nil {
-			return err
-		}
-		return nil
-	})
-
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (dag *BlockDAG) removeDAGState() error {
-	err := dag.db.Update(func(dbTx database.Tx) error {
-		meta := dbTx.Metadata()
-
-		err := meta.DeleteBucket(blockIndexBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = meta.DeleteBucket(utxoSetBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = meta.DeleteBucket(utxoDiffsBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = meta.DeleteBucket(reachabilityDataBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = dbTx.Metadata().Delete(utxoSetVersionKeyName)
-		if err != nil {
-			return err
-		}
-
-		err = meta.DeleteBucket(subnetworksBucketName)
-		if err != nil {
-			return err
-		}
-
-		err = dbTx.Metadata().Delete(localSubnetworkKeyName)
-		if err != nil {
-			return err
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func dbPutLocalSubnetworkID(dbTx database.Tx, subnetworkID *subnetworkid.SubnetworkID) error {
-	if subnetworkID == nil {
-		return dbTx.Metadata().Put(localSubnetworkKeyName, []byte{})
-	}
-	return dbTx.Metadata().Put(localSubnetworkKeyName, subnetworkID[:])
-}
-
-// initDAGState attempts to load and initialize the DAG state from the
-// database. When the db does not yet contain any DAG state, both it and the
-// DAG state are initialized to the genesis block.
-func (dag *BlockDAG) initDAGState() error {
-	// Determine the state of the DAG database. We may need to initialize
-	// everything from scratch or upgrade certain buckets.
-	var initialized bool
-	err := dag.db.View(func(dbTx database.Tx) error {
-		initialized = dbTx.Metadata().Get(dagStateKeyName) != nil
-		if initialized {
-			var localSubnetworkID *subnetworkid.SubnetworkID
-			localSubnetworkIDBytes := dbTx.Metadata().Get(localSubnetworkKeyName)
-			if len(localSubnetworkIDBytes) != 0 {
-				localSubnetworkID = &subnetworkid.SubnetworkID{}
-				localSubnetworkID.SetBytes(localSubnetworkIDBytes)
-			}
-			if !localSubnetworkID.IsEqual(dag.subnetworkID) {
-				return errors.Errorf("Cannot start kaspad with subnetwork ID %s because"+
-					" its database is already built with subnetwork ID %s. If you"+
-					" want to switch to a new database, please reset the"+
-					" database by starting kaspad with --reset-db flag", dag.subnetworkID, localSubnetworkID)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	if !initialized {
-		// At this point the database has not already been initialized, so
-		// initialize both it and the DAG state to the genesis block.
-		return dag.createDAGState()
-	}
-
-	// Attempt to load the DAG state from the database.
-	return dag.db.View(func(dbTx database.Tx) error {
-		// Fetch the stored DAG tipHashes from the database metadata.
-		// When it doesn't exist, it means the database hasn't been
-		// initialized for use with the DAG yet, so break out now to allow
-		// that to happen under a writable database transaction.
-		serializedData := dbTx.Metadata().Get(dagStateKeyName)
-		log.Tracef("Serialized DAG tip hashes: %x", serializedData)
-		state, err := deserializeDAGState(serializedData)
-		if err != nil {
-			return err
-		}
-
-		// Load all of the headers from the data for the known DAG
-		// and construct the block index accordingly. Since the
-		// number of nodes are already known, perform a single alloc
-		// for them versus a whole bunch of little ones to reduce
-		// pressure on the GC.
-		log.Infof("Loading block index...")
-
-		blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)
-
-		var unprocessedBlockNodes []*blockNode
-		cursor := blockIndexBucket.Cursor()
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-			node, err := dag.deserializeBlockNode(cursor.Value())
-			if err != nil {
-				return err
-			}
-
-			// Check to see if this node had been stored in the the block DB
-			// but not yet accepted. If so, add it to a slice to be processed later.
-			if node.status == statusDataStored {
-				unprocessedBlockNodes = append(unprocessedBlockNodes, node)
-				continue
-			}
-
-			// If the node is known to be invalid add it as-is to the block
-			// index and continue.
-			if node.status.KnownInvalid() {
-				dag.index.addNode(node)
-				continue
-			}
-
-			if dag.blockCount == 0 {
-				if !node.hash.IsEqual(dag.dagParams.GenesisHash) {
-					return AssertError(fmt.Sprintf("initDAGState: Expected "+
-						"first entry in block index to be genesis block, "+
-						"found %s", node.hash))
-				}
-			} else {
-				if len(node.parents) == 0 {
-					return AssertError(fmt.Sprintf("initDAGState: Could "+
-						"not find any parent for block %s", node.hash))
-				}
-			}
-
-			// Add the node to its parents children, connect it,
-			// and add it to the block index.
-			node.updateParentsChildren()
-			dag.index.addNode(node)
-
-			dag.blockCount++
-		}
-
-		// Load all of the known UTXO entries and construct the full
-		// UTXO set accordingly. Since the number of entries is already
-		// known, perform a single alloc for them versus a whole bunch
-		// of little ones to reduce pressure on the GC.
-		log.Infof("Loading UTXO set...")
-
-		utxoEntryBucket := dbTx.Metadata().Bucket(utxoSetBucketName)
-
-		// Determine how many UTXO entries will be loaded into the index so we can
-		// allocate the right amount.
-		var utxoEntryCount int32
-		cursor = utxoEntryBucket.Cursor()
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-			utxoEntryCount++
-		}
-
-		fullUTXOCollection := make(utxoCollection, utxoEntryCount)
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-			// Deserialize the outpoint
-			outpoint, err := deserializeOutpoint(cursor.Key())
-			if err != nil {
-				// Ensure any deserialization errors are returned as database
-				// corruption errors.
-				if isDeserializeErr(err) {
-					return database.Error{
-						ErrorCode:   database.ErrCorruption,
-						Description: fmt.Sprintf("corrupt outpoint: %s", err),
-					}
-				}
-
-				return err
-			}
-
-			// Deserialize the utxo entry
-			entry, err := deserializeUTXOEntry(cursor.Value())
-			if err != nil {
-				// Ensure any deserialization errors are returned as database
-				// corruption errors.
-				if isDeserializeErr(err) {
-					return database.Error{
-						ErrorCode:   database.ErrCorruption,
-						Description: fmt.Sprintf("corrupt utxo entry: %s", err),
-					}
-				}
-
-				return err
-			}
-
-			fullUTXOCollection[*outpoint] = entry
-		}
-
-		// Initialize the reachability store
-		err = dag.reachabilityStore.init(dbTx)
-		if err != nil {
-			return err
-		}
-
-		// Apply the loaded utxoCollection to the virtual block.
-		dag.virtual.utxoSet, err = newFullUTXOSetFromUTXOCollection(fullUTXOCollection)
-		if err != nil {
-			return AssertError(fmt.Sprintf("Error loading UTXOSet: %s", err))
-		}
-
-		// Apply the stored tips to the virtual block.
-		tips := newSet()
-		for _, tipHash := range state.TipHashes {
-			tip := dag.index.LookupNode(tipHash)
-			if tip == nil {
-				return AssertError(fmt.Sprintf("initDAGState: cannot find "+
-					"DAG tip %s in block index", state.TipHashes))
-			}
-			tips.add(tip)
-		}
-		dag.virtual.SetTips(tips)
-
-		// Set the last finality point
-		dag.lastFinalityPoint = dag.index.LookupNode(state.LastFinalityPoint)
-		dag.finalizeNodesBelowFinalityPoint(false)
-
-		// Go over any unprocessed blockNodes and process them now.
-		for _, node := range unprocessedBlockNodes {
-			// Check to see if the block exists in the block DB. If it
-			// doesn't, the database has certainly been corrupted.
-			blockExists, err := dbTx.HasBlock(node.hash)
-			if err != nil {
-				return AssertError(fmt.Sprintf("initDAGState: HasBlock "+
-					"for block %s failed: %s", node.hash, err))
-			}
-			if !blockExists {
-				return AssertError(fmt.Sprintf("initDAGState: block %s "+
-					"exists in block index but not in block db", node.hash))
-			}
-
-			// Attempt to accept the block.
-			block, err := dbFetchBlockByNode(dbTx, node)
-			isOrphan, isDelayed, err := dag.ProcessBlock(block, BFWasStored)
-			if err != nil {
-				log.Warnf("Block %s, which was not previously processed, "+
-					"failed to be accepted to the DAG: %s", node.hash, err)
-				continue
-			}
-
-			// If the block is an orphan or is delayed then it couldn't have
-			// possibly been written to the block index in the first place.
-			if isOrphan {
-				return AssertError(fmt.Sprintf("Block %s, which was not "+
-					"previously processed, turned out to be an orphan, which is "+
-					"impossible.", node.hash))
-			}
-			if isDelayed {
-				return AssertError(fmt.Sprintf("Block %s, which was not "+
-					"previously processed, turned out to be delayed, which is "+
-					"impossible.", node.hash))
-			}
-		}
-
-		return nil
-	})
-}
-
-// deserializeBlockNode parses a value in the block index bucket and returns a block node.
-func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
-	buffer := bytes.NewReader(blockRow)
-
-	var header wire.BlockHeader
-	err := header.Deserialize(buffer)
-	if err != nil {
-		return nil, err
-	}
-
-	node := &blockNode{
-		hash:                 header.BlockHash(),
-		version:              header.Version,
-		bits:                 header.Bits,
-		nonce:                header.Nonce,
-		timestamp:            header.Timestamp.Unix(),
-		hashMerkleRoot:       header.HashMerkleRoot,
-		acceptedIDMerkleRoot: header.AcceptedIDMerkleRoot,
-		utxoCommitment:       header.UTXOCommitment,
-	}
-
-	node.children = newSet()
-	node.parents = newSet()
-
-	for _, hash := range header.ParentHashes {
-		parent := dag.index.LookupNode(hash)
-		if parent == nil {
-			return nil, AssertError(fmt.Sprintf("deserializeBlockNode: Could "+
-				"not find parent %s for block %s", hash, header.BlockHash()))
-		}
-		node.parents.add(parent)
-	}
-
-	statusByte, err := buffer.ReadByte()
-	if err != nil {
-		return nil, err
-	}
-	node.status = blockStatus(statusByte)
-
-	selectedParentHash := &daghash.Hash{}
-	if _, err := io.ReadFull(buffer, selectedParentHash[:]); err != nil {
-		return nil, err
-	}
-
-	// Because genesis doesn't have selected parent, it's serialized as zero hash
-	if !selectedParentHash.IsEqual(&daghash.ZeroHash) {
-		node.selectedParent = dag.index.LookupNode(selectedParentHash)
-	}
-
-	node.blueScore, err = binaryserializer.Uint64(buffer, byteOrder)
-	if err != nil {
-		return nil, err
-	}
-
-	bluesCount, err := wire.ReadVarInt(buffer)
-	if err != nil {
-		return nil, err
-	}
-
-	node.blues = make([]*blockNode, bluesCount)
-	for i := uint64(0); i < bluesCount; i++ {
-		hash := &daghash.Hash{}
-		if _, err := io.ReadFull(buffer, hash[:]); err != nil {
-			return nil, err
-		}
-		node.blues[i] = dag.index.LookupNode(hash)
-	}
-
-	bluesAnticoneSizesLen, err := wire.ReadVarInt(buffer)
-	if err != nil {
-		return nil, err
-	}
-
-	node.bluesAnticoneSizes = make(map[daghash.Hash]dagconfig.KType)
-	for i := uint64(0); i < bluesAnticoneSizesLen; i++ {
-		hash := &daghash.Hash{}
-		if _, err := io.ReadFull(buffer, hash[:]); err != nil {
-			return nil, err
-		}
-		bluesAnticoneSize, err := binaryserializer.Uint8(buffer)
-		node.bluesAnticoneSizes[*hash] = dagconfig.KType(bluesAnticoneSize)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return node, nil
-}
-
-// dbFetchBlockByNode uses an existing database transaction to retrieve the
-// raw block for the provided node, deserialize it, and return a util.Block
-// of it.
-func dbFetchBlockByNode(dbTx database.Tx, node *blockNode) (*util.Block, error) {
-	// Load the raw block bytes from the database.
-	blockBytes, err := dbTx.FetchBlock(node.hash)
-	if err != nil {
-		return nil, err
-	}
-
-	// Create the encapsulated block.
-	block, err := util.NewBlockFromBytes(blockBytes)
-	if err != nil {
-		return nil, err
-	}
-	return block, nil
-}
-
-func serializeBlockNode(node *blockNode) ([]byte, error) {
-	w := bytes.NewBuffer(make([]byte, 0, blockHdrSize+1))
-	header := node.Header()
-	err := header.Serialize(w)
-	if err != nil {
-		return nil, err
-	}
-
-	err = w.WriteByte(byte(node.status))
-	if err != nil {
-		return nil, err
-	}
-
-	// Because genesis doesn't have selected parent, it's serialized as zero hash
-	selectedParentHash := &daghash.ZeroHash
-	if node.selectedParent != nil {
-		selectedParentHash = node.selectedParent.hash
-	}
-	_, err = w.Write(selectedParentHash[:])
-	if err != nil {
-		return nil, err
-	}
-
-	err = binaryserializer.PutUint64(w, byteOrder, node.blueScore)
-	if err != nil {
-		return nil, err
-	}
-
-	err = wire.WriteVarInt(w, uint64(len(node.blues)))
-	if err != nil {
-		return nil, err
-	}
-
-	for _, blue := range node.blues {
-		_, err = w.Write(blue.hash[:])
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	err = wire.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
-	if err != nil {
-		return nil, err
-	}
-	for blockHash, blueAnticoneSize := range node.bluesAnticoneSizes {
-		_, err = w.Write(blockHash[:])
-		if err != nil {
-			return nil, err
-		}
-
-		err = binaryserializer.PutUint8(w, uint8(blueAnticoneSize))
-		if err != nil {
-			return nil, err
-		}
-	}
-	return w.Bytes(), nil
-}
-
-// dbStoreBlockNode stores the block node data into the block
-// index bucket. This overwrites the current entry if there exists one.
-func dbStoreBlockNode(dbTx database.Tx, node *blockNode) error {
-	serializedNode, err := serializeBlockNode(node)
-	if err != nil {
-		return err
-	}
-	// Write block header data to block index bucket.
-	blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)
-	key := BlockIndexKey(node.hash, node.blueScore)
-	return blockIndexBucket.Put(key, serializedNode)
-}
-
-// dbStoreBlock stores the provided block in the database if it is not already
-// there. The full block data is written to ffldb.
-func dbStoreBlock(dbTx database.Tx, block *util.Block) error {
-	hasBlock, err := dbTx.HasBlock(block.Hash())
-	if err != nil {
-		return err
-	}
-	if hasBlock {
-		return nil
-	}
-	return dbTx.StoreBlock(block)
-}
-
-// BlockIndexKey generates the binary key for an entry in the block index
-// bucket. The key is composed of the block blue score encoded as a big-endian
-// 64-bit unsigned int followed by the 32 byte block hash.
-// The blue score component is important for iteration order.
-func BlockIndexKey(blockHash *daghash.Hash, blueScore uint64) []byte {
-	indexKey := make([]byte, daghash.HashSize+8)
-	binary.BigEndian.PutUint64(indexKey[0:8], blueScore)
-	copy(indexKey[8:daghash.HashSize+8], blockHash[:])
-	return indexKey
-}
-
-func blockHashFromBlockIndexKey(BlockIndexKey []byte) (*daghash.Hash, error) {
-	return daghash.NewHash(BlockIndexKey[8 : daghash.HashSize+8])
-}
-
-// BlockByHash returns the block from the DAG with the given hash.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) BlockByHash(hash *daghash.Hash) (*util.Block, error) {
-	// Lookup the block hash in block index and ensure it is in the DAG
-	node := dag.index.LookupNode(hash)
-	if node == nil {
-		str := fmt.Sprintf("block %s is not in the DAG", hash)
-		return nil, errNotInDAG(str)
-	}
-
-	// Load the block from the database and return it.
-	var block *util.Block
-	err := dag.db.View(func(dbTx database.Tx) error {
-		var err error
-		block, err = dbFetchBlockByNode(dbTx, node)
-		return err
-	})
-	return block, err
-}
-
-// BlockHashesFrom returns a slice of blocks starting from lowHash
-// ordered by blueScore. If lowHash is nil then the genesis block is used.
-//
-// This method MUST be called with the DAG lock held
-func (dag *BlockDAG) BlockHashesFrom(lowHash *daghash.Hash, limit int) ([]*daghash.Hash, error) {
-	blockHashes := make([]*daghash.Hash, 0, limit)
-	if lowHash == nil {
-		lowHash = dag.genesis.hash
-
-		// If we're starting from the beginning we should include the
-		// genesis hash in the result
-		blockHashes = append(blockHashes, dag.genesis.hash)
-	}
-	if !dag.BlockExists(lowHash) {
-		return nil, errors.Errorf("block %s not found", lowHash)
-	}
-	blueScore, err := dag.BlueScoreByBlockHash(lowHash)
-	if err != nil {
-		return nil, err
-	}
-
-	err = dag.index.db.View(func(dbTx database.Tx) error {
-		blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)
-		lowKey := BlockIndexKey(lowHash, blueScore)
-
-		cursor := blockIndexBucket.Cursor()
-		cursor.Seek(lowKey)
-		for ok := cursor.Next(); ok; ok = cursor.Next() {
-			key := cursor.Key()
-			blockHash, err := blockHashFromBlockIndexKey(key)
-			if err != nil {
-				return err
-			}
-			blockHashes = append(blockHashes, blockHash)
-			if len(blockHashes) == limit {
-				break
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return blockHashes, nil
-}

blockdag/indexers/addrindex.go

@@ -1,902 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"fmt"
-	"github.com/pkg/errors"
-	"sync"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const (
-	// addrIndexName is the human-readable name for the index.
-	addrIndexName = "address index"
-
-	// level0MaxEntries is the maximum number of transactions that are
-	// stored in level 0 of an address index entry. Subsequent levels store
-	// 2^n * level0MaxEntries entries, or in words, double the maximum of
-	// the previous level.
-	level0MaxEntries = 8
-
-	// addrKeySize is the number of bytes an address key consumes in the
-	// index. It consists of 1 byte address type + 20 bytes hash160.
-	addrKeySize = 1 + 20
-
-	// levelKeySize is the number of bytes a level key in the address index
-	// consumes. It consists of the address key + 1 byte for the level.
-	levelKeySize = addrKeySize + 1
-
-	// levelOffset is the offset in the level key which identifes the level.
-	levelOffset = levelKeySize - 1
-
-	// addrKeyTypePubKeyHash is the address type in an address key which
-	// represents both a pay-to-pubkey-hash and a pay-to-pubkey address.
-	// This is done because both are identical for the purposes of the
-	// address index.
-	addrKeyTypePubKeyHash = 0
-
-	// addrKeyTypeScriptHash is the address type in an address key which
-	// represents a pay-to-script-hash address. This is necessary because
-	// the hash of a pubkey address might be the same as that of a script
-	// hash.
-	addrKeyTypeScriptHash = 1
-
-	// Size of a transaction entry. It consists of 8 bytes block id + 4
-	// bytes offset + 4 bytes length.
-	txEntrySize = 8 + 4 + 4
-)
-
-var (
-	// addrIndexKey is the key of the address index and the db bucket used
-	// to house it.
-	addrIndexKey = []byte("txbyaddridx")
-
-	// errUnsupportedAddressType is an error that is used to signal an
-	// unsupported address type has been used.
-	errUnsupportedAddressType = errors.New("address type is not supported " +
-		"by the address index")
-)
-
-// -----------------------------------------------------------------------------
-// The address index maps addresses referenced in the blockDAG to a list of
-// all the transactions involving that address. Transactions are stored
-// according to their order of appearance in the blockDAG. That is to say
-// first by block height and then by offset inside the block. It is also
-// important to note that this implementation requires the transaction index
-// since it is needed in order to catch up old blocks due to the fact the spent
-// outputs will already be pruned from the utxo set.
-//
-// The approach used to store the index is similar to a log-structured merge
-// tree (LSM tree) and is thus similar to how leveldb works internally.
-//
-// Every address consists of one or more entries identified by a level starting
-// from 0 where each level holds a maximum number of entries such that each
-// subsequent level holds double the maximum of the previous one. In equation
-// form, the number of entries each level holds is 2^n * firstLevelMaxSize.
-//
-// New transactions are appended to level 0 until it becomes full at which point
-// the entire level 0 entry is appended to the level 1 entry and level 0 is
-// cleared. This process continues until level 1 becomes full at which point it
-// will be appended to level 2 and cleared and so on.
-//
-// The result of this is the lower levels contain newer transactions and the
-// transactions within each level are ordered from oldest to newest.
-//
-// The intent of this approach is to provide a balance between space efficiency
-// and indexing cost. Storing one entry per transaction would have the lowest
-// indexing cost, but would waste a lot of space because the same address hash
-// would be duplicated for every transaction key. On the other hand, storing a
-// single entry with all transactions would be the most space efficient, but
-// would cause indexing cost to grow quadratically with the number of
-// transactions involving the same address. The approach used here provides
-// logarithmic insertion and retrieval.
-//
-// The serialized key format is:
-//
-//   <addr type><addr hash><level>
-//
-//   Field           Type      Size
-//   addr type       uint8     1 byte
-//   addr hash       hash160   20 bytes
-//   level           uint8     1 byte
-//   -----
-//   Total: 22 bytes
-//
-// The serialized value format is:
-//
-//   [<block id><start offset><tx length>,...]
-//
-//   Field           Type      Size
-//   block id        uint64    8 bytes
-//   start offset    uint32    4 bytes
-//   tx length       uint32    4 bytes
-//   -----
-//   Total: 16 bytes per indexed tx
-// -----------------------------------------------------------------------------
-
-// fetchBlockHashFunc defines a callback function to use in order to convert a
-// serialized block ID to an associated block hash.
-type fetchBlockHashFunc func(serializedID []byte) (*daghash.Hash, error)
-
-// serializeAddrIndexEntry serializes the provided block id and transaction
-// location according to the format described in detail above.
-func serializeAddrIndexEntry(blockID uint64, txLoc wire.TxLoc) []byte {
-	// Serialize the entry.
-	serialized := make([]byte, 16)
-	byteOrder.PutUint64(serialized, blockID)
-	byteOrder.PutUint32(serialized[8:], uint32(txLoc.TxStart))
-	byteOrder.PutUint32(serialized[12:], uint32(txLoc.TxLen))
-	return serialized
-}
-
-// deserializeAddrIndexEntry decodes the passed serialized byte slice into the
-// provided region struct according to the format described in detail above and
-// uses the passed block hash fetching function in order to conver the block ID
-// to the associated block hash.
-func deserializeAddrIndexEntry(serialized []byte, region *database.BlockRegion, fetchBlockHash fetchBlockHashFunc) error {
-	// Ensure there are enough bytes to decode.
-	if len(serialized) < txEntrySize {
-		return errDeserialize("unexpected end of data")
-	}
-
-	hash, err := fetchBlockHash(serialized[0:8])
-	if err != nil {
-		return err
-	}
-	region.Hash = hash
-	region.Offset = byteOrder.Uint32(serialized[8:12])
-	region.Len = byteOrder.Uint32(serialized[12:16])
-	return nil
-}
-
-// keyForLevel returns the key for a specific address and level in the address
-// index entry.
-func keyForLevel(addrKey [addrKeySize]byte, level uint8) [levelKeySize]byte {
-	var key [levelKeySize]byte
-	copy(key[:], addrKey[:])
-	key[levelOffset] = level
-	return key
-}
-
-// dbPutAddrIndexEntry updates the address index to include the provided entry
-// according to the level-based scheme described in detail above.
-func dbPutAddrIndexEntry(bucket internalBucket, addrKey [addrKeySize]byte, blockID uint64, txLoc wire.TxLoc) error {
-	// Start with level 0 and its initial max number of entries.
-	curLevel := uint8(0)
-	maxLevelBytes := level0MaxEntries * txEntrySize
-
-	// Simply append the new entry to level 0 and return now when it will
-	// fit. This is the most common path.
-	newData := serializeAddrIndexEntry(blockID, txLoc)
-	level0Key := keyForLevel(addrKey, 0)
-	level0Data := bucket.Get(level0Key[:])
-	if len(level0Data)+len(newData) <= maxLevelBytes {
-		mergedData := newData
-		if len(level0Data) > 0 {
-			mergedData = make([]byte, len(level0Data)+len(newData))
-			copy(mergedData, level0Data)
-			copy(mergedData[len(level0Data):], newData)
-		}
-		return bucket.Put(level0Key[:], mergedData)
-	}
-
-	// At this point, level 0 is full, so merge each level into higher
-	// levels as many times as needed to free up level 0.
-	prevLevelData := level0Data
-	for {
-		// Each new level holds twice as much as the previous one.
-		curLevel++
-		maxLevelBytes *= 2
-
-		// Move to the next level as long as the current level is full.
-		curLevelKey := keyForLevel(addrKey, curLevel)
-		curLevelData := bucket.Get(curLevelKey[:])
-		if len(curLevelData) == maxLevelBytes {
-			prevLevelData = curLevelData
-			continue
-		}
-
-		// The current level has room for the data in the previous one,
-		// so merge the data from previous level into it.
-		mergedData := prevLevelData
-		if len(curLevelData) > 0 {
-			mergedData = make([]byte, len(curLevelData)+
-				len(prevLevelData))
-			copy(mergedData, curLevelData)
-			copy(mergedData[len(curLevelData):], prevLevelData)
-		}
-		err := bucket.Put(curLevelKey[:], mergedData)
-		if err != nil {
-			return err
-		}
-
-		// Move all of the levels before the previous one up a level.
-		for mergeLevel := curLevel - 1; mergeLevel > 0; mergeLevel-- {
-			mergeLevelKey := keyForLevel(addrKey, mergeLevel)
-			prevLevelKey := keyForLevel(addrKey, mergeLevel-1)
-			prevData := bucket.Get(prevLevelKey[:])
-			err := bucket.Put(mergeLevelKey[:], prevData)
-			if err != nil {
-				return err
-			}
-		}
-		break
-	}
-
-	// Finally, insert the new entry into level 0 now that it is empty.
-	return bucket.Put(level0Key[:], newData)
-}
-
-// dbFetchAddrIndexEntries returns block regions for transactions referenced by
-// the given address key and the number of entries skipped since it could have
-// been less in the case where there are less total entries than the requested
-// number of entries to skip.
-func dbFetchAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, numToSkip, numRequested uint32, reverse bool, fetchBlockHash fetchBlockHashFunc) ([]database.BlockRegion, uint32, error) {
-	// When the reverse flag is not set, all levels need to be fetched
-	// because numToSkip and numRequested are counted from the oldest
-	// transactions (highest level) and thus the total count is needed.
-	// However, when the reverse flag is set, only enough records to satisfy
-	// the requested amount are needed.
-	var level uint8
-	var serialized []byte
-	for !reverse || len(serialized) < int(numToSkip+numRequested)*txEntrySize {
-		curLevelKey := keyForLevel(addrKey, level)
-		levelData := bucket.Get(curLevelKey[:])
-		if levelData == nil {
-			// Stop when there are no more levels.
-			break
-		}
-
-		// Higher levels contain older transactions, so prepend them.
-		prepended := make([]byte, len(serialized)+len(levelData))
-		copy(prepended, levelData)
-		copy(prepended[len(levelData):], serialized)
-		serialized = prepended
-		level++
-	}
-
-	// When the requested number of entries to skip is larger than the
-	// number available, skip them all and return now with the actual number
-	// skipped.
-	numEntries := uint32(len(serialized) / txEntrySize)
-	if numToSkip >= numEntries {
-		return nil, numEntries, nil
-	}
-
-	// Nothing more to do when there are no requested entries.
-	if numRequested == 0 {
-		return nil, numToSkip, nil
-	}
-
-	// Limit the number to load based on the number of available entries,
-	// the number to skip, and the number requested.
-	numToLoad := numEntries - numToSkip
-	if numToLoad > numRequested {
-		numToLoad = numRequested
-	}
-
-	// Start the offset after all skipped entries and load the calculated
-	// number.
-	results := make([]database.BlockRegion, numToLoad)
-	for i := uint32(0); i < numToLoad; i++ {
-		// Calculate the read offset according to the reverse flag.
-		var offset uint32
-		if reverse {
-			offset = (numEntries - numToSkip - i - 1) * txEntrySize
-		} else {
-			offset = (numToSkip + i) * txEntrySize
-		}
-
-		// Deserialize and populate the result.
-		err := deserializeAddrIndexEntry(serialized[offset:],
-			&results[i], fetchBlockHash)
-		if err != nil {
-			// Ensure any deserialization errors are returned as
-			// database corruption errors.
-			if isDeserializeErr(err) {
-				err = database.Error{
-					ErrorCode: database.ErrCorruption,
-					Description: fmt.Sprintf("failed to "+
-						"deserialized address index "+
-						"for key %x: %s", addrKey, err),
-				}
-			}
-
-			return nil, 0, err
-		}
-	}
-
-	return results, numToSkip, nil
-}
-
-// minEntriesToReachLevel returns the minimum number of entries that are
-// required to reach the given address index level.
-func minEntriesToReachLevel(level uint8) int {
-	maxEntriesForLevel := level0MaxEntries
-	minRequired := 1
-	for l := uint8(1); l <= level; l++ {
-		minRequired += maxEntriesForLevel
-		maxEntriesForLevel *= 2
-	}
-	return minRequired
-}
-
-// maxEntriesForLevel returns the maximum number of entries allowed for the
-// given address index level.
-func maxEntriesForLevel(level uint8) int {
-	numEntries := level0MaxEntries
-	for l := level; l > 0; l-- {
-		numEntries *= 2
-	}
-	return numEntries
-}
-
-// dbRemoveAddrIndexEntries removes the specified number of entries from from
-// the address index for the provided key. An assertion error will be returned
-// if the count exceeds the total number of entries in the index.
-func dbRemoveAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, count int) error {
-	// Nothing to do if no entries are being deleted.
-	if count <= 0 {
-		return nil
-	}
-
-	// Make use of a local map to track pending updates and define a closure
-	// to apply it to the database. This is done in order to reduce the
-	// number of database reads and because there is more than one exit
-	// path that needs to apply the updates.
-	pendingUpdates := make(map[uint8][]byte)
-	applyPending := func() error {
-		for level, data := range pendingUpdates {
-			curLevelKey := keyForLevel(addrKey, level)
-			if len(data) == 0 {
-				err := bucket.Delete(curLevelKey[:])
-				if err != nil {
-					return err
-				}
-				continue
-			}
-			err := bucket.Put(curLevelKey[:], data)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	// Loop forwards through the levels while removing entries until the
-	// specified number has been removed. This will potentially result in
-	// entirely empty lower levels which will be backfilled below.
-	var highestLoadedLevel uint8
-	numRemaining := count
-	for level := uint8(0); numRemaining > 0; level++ {
-		// Load the data for the level from the database.
-		curLevelKey := keyForLevel(addrKey, level)
-		curLevelData := bucket.Get(curLevelKey[:])
-		if len(curLevelData) == 0 && numRemaining > 0 {
-			return AssertError(fmt.Sprintf("dbRemoveAddrIndexEntries "+
-				"not enough entries for address key %x to "+
-				"delete %d entries", addrKey, count))
-		}
-		pendingUpdates[level] = curLevelData
-		highestLoadedLevel = level
-
-		// Delete the entire level as needed.
-		numEntries := len(curLevelData) / txEntrySize
-		if numRemaining >= numEntries {
-			pendingUpdates[level] = nil
-			numRemaining -= numEntries
-			continue
-		}
-
-		// Remove remaining entries to delete from the level.
-		offsetEnd := len(curLevelData) - (numRemaining * txEntrySize)
-		pendingUpdates[level] = curLevelData[:offsetEnd]
-		break
-	}
-
-	// When all elements in level 0 were not removed there is nothing left
-	// to do other than updating the database.
-	if len(pendingUpdates[0]) != 0 {
-		return applyPending()
-	}
-
-	// At this point there are one or more empty levels before the current
-	// level which need to be backfilled and the current level might have
-	// had some entries deleted from it as well. Since all levels after
-	// level 0 are required to either be empty, half full, or completely
-	// full, the current level must be adjusted accordingly by backfilling
-	// each previous levels in a way which satisfies the requirements. Any
-	// entries that are left are assigned to level 0 after the loop as they
-	// are guaranteed to fit by the logic in the loop. In other words, this
-	// effectively squashes all remaining entries in the current level into
-	// the lowest possible levels while following the level rules.
-	//
-	// Note that the level after the current level might also have entries
-	// and gaps are not allowed, so this also keeps track of the lowest
-	// empty level so the code below knows how far to backfill in case it is
-	// required.
-	lowestEmptyLevel := uint8(255)
-	curLevelData := pendingUpdates[highestLoadedLevel]
-	curLevelMaxEntries := maxEntriesForLevel(highestLoadedLevel)
-	for level := highestLoadedLevel; level > 0; level-- {
-		// When there are not enough entries left in the current level
-		// for the number that would be required to reach it, clear the
-		// the current level which effectively moves them all up to the
-		// previous level on the next iteration. Otherwise, there are
-		// are sufficient entries, so update the current level to
-		// contain as many entries as possible while still leaving
-		// enough remaining entries required to reach the level.
-		numEntries := len(curLevelData) / txEntrySize
-		prevLevelMaxEntries := curLevelMaxEntries / 2
-		minPrevRequired := minEntriesToReachLevel(level - 1)
-		if numEntries < prevLevelMaxEntries+minPrevRequired {
-			lowestEmptyLevel = level
-			pendingUpdates[level] = nil
-		} else {
-			// This level can only be completely full or half full,
-			// so choose the appropriate offset to ensure enough
-			// entries remain to reach the level.
-			var offset int
-			if numEntries-curLevelMaxEntries >= minPrevRequired {
-				offset = curLevelMaxEntries * txEntrySize
-			} else {
-				offset = prevLevelMaxEntries * txEntrySize
-			}
-			pendingUpdates[level] = curLevelData[:offset]
-			curLevelData = curLevelData[offset:]
-		}
-
-		curLevelMaxEntries = prevLevelMaxEntries
-	}
-	pendingUpdates[0] = curLevelData
-	if len(curLevelData) == 0 {
-		lowestEmptyLevel = 0
-	}
-
-	// When the highest loaded level is empty, it's possible the level after
-	// it still has data and thus that data needs to be backfilled as well.
-	for len(pendingUpdates[highestLoadedLevel]) == 0 {
-		// When the next level is empty too, the is no data left to
-		// continue backfilling, so there is nothing left to do.
-		// Otherwise, populate the pending updates map with the newly
-		// loaded data and update the highest loaded level accordingly.
-		level := highestLoadedLevel + 1
-		curLevelKey := keyForLevel(addrKey, level)
-		levelData := bucket.Get(curLevelKey[:])
-		if len(levelData) == 0 {
-			break
-		}
-		pendingUpdates[level] = levelData
-		highestLoadedLevel = level
-
-		// At this point the highest level is not empty, but it might
-		// be half full. When that is the case, move it up a level to
-		// simplify the code below which backfills all lower levels that
-		// are still empty. This also means the current level will be
-		// empty, so the loop will perform another another iteration to
-		// potentially backfill this level with data from the next one.
-		curLevelMaxEntries := maxEntriesForLevel(level)
-		if len(levelData)/txEntrySize != curLevelMaxEntries {
-			pendingUpdates[level] = nil
-			pendingUpdates[level-1] = levelData
-			level--
-			curLevelMaxEntries /= 2
-		}
-
-		// Backfill all lower levels that are still empty by iteratively
-		// halfing the data until the lowest empty level is filled.
-		for level > lowestEmptyLevel {
-			offset := (curLevelMaxEntries / 2) * txEntrySize
-			pendingUpdates[level] = levelData[:offset]
-			levelData = levelData[offset:]
-			pendingUpdates[level-1] = levelData
-			level--
-			curLevelMaxEntries /= 2
-		}
-
-		// The lowest possible empty level is now the highest loaded
-		// level.
-		lowestEmptyLevel = highestLoadedLevel
-	}
-
-	// Apply the pending updates.
-	return applyPending()
-}
-
-// addrToKey converts known address types to an addrindex key. An error is
-// returned for unsupported types.
-func addrToKey(addr util.Address) ([addrKeySize]byte, error) {
-	switch addr := addr.(type) {
-	case *util.AddressPubKeyHash:
-		var result [addrKeySize]byte
-		result[0] = addrKeyTypePubKeyHash
-		copy(result[1:], addr.Hash160()[:])
-		return result, nil
-
-	case *util.AddressScriptHash:
-		var result [addrKeySize]byte
-		result[0] = addrKeyTypeScriptHash
-		copy(result[1:], addr.Hash160()[:])
-		return result, nil
-	}
-
-	return [addrKeySize]byte{}, errUnsupportedAddressType
-}
-
-// AddrIndex implements a transaction by address index. That is to say, it
-// supports querying all transactions that reference a given address because
-// they are either crediting or debiting the address. The returned transactions
-// are ordered according to their order of appearance in the blockDAG. In
-// other words, first by block height and then by offset inside the block.
-//
-// In addition, support is provided for a memory-only index of unconfirmed
-// transactions such as those which are kept in the memory pool before inclusion
-// in a block.
-type AddrIndex struct {
-	// The following fields are set when the instance is created and can't
-	// be changed afterwards, so there is no need to protect them with a
-	// separate mutex.
-	db        database.DB
-	dagParams *dagconfig.Params
-
-	// The following fields are used to quickly link transactions and
-	// addresses that have not been included into a block yet when an
-	// address index is being maintained. The are protected by the
-	// unconfirmedLock field.
-	//
-	// The txnsByAddr field is used to keep an index of all transactions
-	// which either create an output to a given address or spend from a
-	// previous output to it keyed by the address.
-	//
-	// The addrsByTx field is essentially the reverse and is used to
-	// keep an index of all addresses which a given transaction involves.
-	// This allows fairly efficient updates when transactions are removed
-	// once they are included into a block.
-	unconfirmedLock sync.RWMutex
-	txnsByAddr      map[[addrKeySize]byte]map[daghash.TxID]*util.Tx
-	addrsByTx       map[daghash.TxID]map[[addrKeySize]byte]struct{}
-}
-
-// Ensure the AddrIndex type implements the Indexer interface.
-var _ Indexer = (*AddrIndex)(nil)
-
-// Ensure the AddrIndex type implements the NeedsInputser interface.
-var _ NeedsInputser = (*AddrIndex)(nil)
-
-// NeedsInputs signals that the index requires the referenced inputs in order
-// to properly create the index.
-//
-// This implements the NeedsInputser interface.
-func (idx *AddrIndex) NeedsInputs() bool {
-	return true
-}
-
-// Init is only provided to satisfy the Indexer interface as there is nothing to
-// initialize for this index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Init(db database.DB, _ *blockdag.BlockDAG) error {
-	idx.db = db
-	return nil
-}
-
-// Key returns the database key to use for the index as a byte slice.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Key() []byte {
-	return addrIndexKey
-}
-
-// Name returns the human-readable name of the index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Name() string {
-	return addrIndexName
-}
-
-// Create is invoked when the indexer manager determines the index needs
-// to be created for the first time. It creates the bucket for the address
-// index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Create(dbTx database.Tx) error {
-	_, err := dbTx.Metadata().CreateBucket(addrIndexKey)
-	return err
-}
-
-// writeIndexData represents the address index data to be written for one block.
-// It consists of the address mapped to an ordered list of the transactions
-// that involve the address in block. It is ordered so the transactions can be
-// stored in the order they appear in the block.
-type writeIndexData map[[addrKeySize]byte][]int
-
-// indexScriptPubKey extracts all standard addresses from the passed public key
-// script and maps each of them to the associated transaction using the passed
-// map.
-func (idx *AddrIndex) indexScriptPubKey(data writeIndexData, scriptPubKey []byte, txIdx int) {
-	// Nothing to index if the script is non-standard or otherwise doesn't
-	// contain any addresses.
-	_, addr, err := txscript.ExtractScriptPubKeyAddress(scriptPubKey,
-		idx.dagParams)
-	if err != nil || addr == nil {
-		return
-	}
-
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		// Ignore unsupported address types.
-		return
-	}
-
-	// Avoid inserting the transaction more than once. Since the
-	// transactions are indexed serially any duplicates will be
-	// indexed in a row, so checking the most recent entry for the
-	// address is enough to detect duplicates.
-	indexedTxns := data[addrKey]
-	numTxns := len(indexedTxns)
-	if numTxns > 0 && indexedTxns[numTxns-1] == txIdx {
-		return
-	}
-	indexedTxns = append(indexedTxns, txIdx)
-	data[addrKey] = indexedTxns
-}
-
-// indexBlock extract all of the standard addresses from all of the transactions
-// in the passed block and maps each of them to the associated transaction using
-// the passed map.
-func (idx *AddrIndex) indexBlock(data writeIndexData, block *util.Block, dag *blockdag.BlockDAG) {
-	for txIdx, tx := range block.Transactions() {
-		// Coinbases do not reference any inputs. Since the block is
-		// required to have already gone through full validation, it has
-		// already been proven on the first transaction in the block is
-		// a coinbase.
-		if txIdx > util.CoinbaseTransactionIndex {
-			for _, txIn := range tx.MsgTx().TxIn {
-				// The UTXO should always have the input since
-				// the index contract requires it, however, be
-				// safe and simply ignore any missing entries.
-				entry, ok := dag.GetUTXOEntry(txIn.PreviousOutpoint)
-				if !ok {
-					continue
-				}
-
-				idx.indexScriptPubKey(data, entry.ScriptPubKey(), txIdx)
-			}
-		}
-
-		for _, txOut := range tx.MsgTx().TxOut {
-			idx.indexScriptPubKey(data, txOut.ScriptPubKey, txIdx)
-		}
-	}
-}
-
-// ConnectBlock is invoked by the index manager when a new block has been
-// connected to the DAG. This indexer adds a mapping for each address
-// the transactions in the block involve.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) ConnectBlock(dbTx database.Tx, block *util.Block, blockID uint64, dag *blockdag.BlockDAG,
-	_ blockdag.MultiBlockTxsAcceptanceData, _ blockdag.MultiBlockTxsAcceptanceData) error {
-
-	// The offset and length of the transactions within the serialized
-	// block.
-	txLocs, err := block.TxLoc()
-	if err != nil {
-		return err
-	}
-
-	// Build all of the address to transaction mappings in a local map.
-	addrsToTxns := make(writeIndexData)
-	idx.indexBlock(addrsToTxns, block, dag)
-
-	// Add all of the index entries for each address.
-	addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
-	for addrKey, txIdxs := range addrsToTxns {
-		for _, txIdx := range txIdxs {
-			err := dbPutAddrIndexEntry(addrIdxBucket, addrKey,
-				blockID, txLocs[txIdx])
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// TxRegionsForAddress returns a slice of block regions which identify each
-// transaction that involves the passed address according to the specified
-// number to skip, number requested, and whether or not the results should be
-// reversed. It also returns the number actually skipped since it could be less
-// in the case where there are not enough entries.
-//
-// NOTE: These results only include transactions confirmed in blocks. See the
-// UnconfirmedTxnsForAddress method for obtaining unconfirmed transactions
-// that involve a given address.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) TxRegionsForAddress(dbTx database.Tx, addr util.Address, numToSkip, numRequested uint32, reverse bool) ([]database.BlockRegion, uint32, error) {
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	var regions []database.BlockRegion
-	var skipped uint32
-	err = idx.db.View(func(dbTx database.Tx) error {
-		// Create closure to lookup the block hash given the ID using
-		// the database transaction.
-		fetchBlockHash := func(id []byte) (*daghash.Hash, error) {
-			// Deserialize and populate the result.
-			return blockdag.DBFetchBlockHashBySerializedID(dbTx, id)
-		}
-
-		var err error
-		addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
-		regions, skipped, err = dbFetchAddrIndexEntries(addrIdxBucket,
-			addrKey, numToSkip, numRequested, reverse,
-			fetchBlockHash)
-		return err
-	})
-
-	return regions, skipped, err
-}
-
-// indexUnconfirmedAddresses modifies the unconfirmed (memory-only) address
-// index to include mappings for the addresses encoded by the passed public key
-// script to the transaction.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) indexUnconfirmedAddresses(scriptPubKey []byte, tx *util.Tx) {
-	// The error is ignored here since the only reason it can fail is if the
-	// script fails to parse and it was already validated before being
-	// admitted to the mempool.
-	_, addr, _ := txscript.ExtractScriptPubKeyAddress(scriptPubKey,
-		idx.dagParams)
-	// Ignore unsupported address types.
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return
-	}
-
-	// Add a mapping from the address to the transaction.
-	idx.unconfirmedLock.Lock()
-	addrIndexEntry := idx.txnsByAddr[addrKey]
-	if addrIndexEntry == nil {
-		addrIndexEntry = make(map[daghash.TxID]*util.Tx)
-		idx.txnsByAddr[addrKey] = addrIndexEntry
-	}
-	addrIndexEntry[*tx.ID()] = tx
-
-	// Add a mapping from the transaction to the address.
-	addrsByTxEntry := idx.addrsByTx[*tx.ID()]
-	if addrsByTxEntry == nil {
-		addrsByTxEntry = make(map[[addrKeySize]byte]struct{})
-		idx.addrsByTx[*tx.ID()] = addrsByTxEntry
-	}
-	addrsByTxEntry[addrKey] = struct{}{}
-	idx.unconfirmedLock.Unlock()
-}
-
-// AddUnconfirmedTx adds all addresses related to the transaction to the
-// unconfirmed (memory-only) address index.
-//
-// NOTE: This transaction MUST have already been validated by the memory pool
-// before calling this function with it and have all of the inputs available in
-// the provided utxo view. Failure to do so could result in some or all
-// addresses not being indexed.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) AddUnconfirmedTx(tx *util.Tx, utxoSet blockdag.UTXOSet) {
-	// Index addresses of all referenced previous transaction outputs.
-	//
-	// The existence checks are elided since this is only called after the
-	// transaction has already been validated and thus all inputs are
-	// already known to exist.
-	for _, txIn := range tx.MsgTx().TxIn {
-		entry, ok := utxoSet.Get(txIn.PreviousOutpoint)
-		if !ok {
-			// Ignore missing entries. This should never happen
-			// in practice since the function comments specifically
-			// call out all inputs must be available.
-			continue
-		}
-		idx.indexUnconfirmedAddresses(entry.ScriptPubKey(), tx)
-	}
-
-	// Index addresses of all created outputs.
-	for _, txOut := range tx.MsgTx().TxOut {
-		idx.indexUnconfirmedAddresses(txOut.ScriptPubKey, tx)
-	}
-}
-
-// RemoveUnconfirmedTx removes the passed transaction from the unconfirmed
-// (memory-only) address index.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) RemoveUnconfirmedTx(txID *daghash.TxID) {
-	idx.unconfirmedLock.Lock()
-	defer idx.unconfirmedLock.Unlock()
-
-	// Remove all address references to the transaction from the address
-	// index and remove the entry for the address altogether if it no longer
-	// references any transactions.
-	for addrKey := range idx.addrsByTx[*txID] {
-		delete(idx.txnsByAddr[addrKey], *txID)
-		if len(idx.txnsByAddr[addrKey]) == 0 {
-			delete(idx.txnsByAddr, addrKey)
-		}
-	}
-
-	// Remove the entry from the transaction to address lookup map as well.
-	delete(idx.addrsByTx, *txID)
-}
-
-// UnconfirmedTxnsForAddress returns all transactions currently in the
-// unconfirmed (memory-only) address index that involve the passed address.
-// Unsupported address types are ignored and will result in no results.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) UnconfirmedTxnsForAddress(addr util.Address) []*util.Tx {
-	// Ignore unsupported address types.
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return nil
-	}
-
-	// Protect concurrent access.
-	idx.unconfirmedLock.RLock()
-	defer idx.unconfirmedLock.RUnlock()
-
-	// Return a new slice with the results if there are any. This ensures
-	// safe concurrency.
-	if txns, exists := idx.txnsByAddr[addrKey]; exists {
-		addressTxns := make([]*util.Tx, 0, len(txns))
-		for _, tx := range txns {
-			addressTxns = append(addressTxns, tx)
-		}
-		return addressTxns
-	}
-
-	return nil
-}
-
-// Recover is invoked when the indexer wasn't turned on for several blocks
-// and the indexer needs to close the gaps.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Recover(dbTx database.Tx, currentBlockID, lastKnownBlockID uint64) error {
-	return errors.Errorf("addrindex was turned off for %d blocks and can't be recovered."+
-		" To resume working drop the addrindex with --dropaddrindex", lastKnownBlockID-currentBlockID)
-}
-
-// NewAddrIndex returns a new instance of an indexer that is used to create a
-// mapping of all addresses in the blockDAG to the respective transactions
-// that involve them.
-//
-// It implements the Indexer interface which plugs into the IndexManager that in
-// turn is used by the blockDAG package. This allows the index to be
-// seamlessly maintained along with the DAG.
-func NewAddrIndex(dagParams *dagconfig.Params) *AddrIndex {
-	return &AddrIndex{
-		dagParams:  dagParams,
-		txnsByAddr: make(map[[addrKeySize]byte]map[daghash.TxID]*util.Tx),
-		addrsByTx:  make(map[daghash.TxID]map[[addrKeySize]byte]struct{}),
-	}
-}
-
-// DropAddrIndex drops the address index from the provided database if it
-// exists.
-func DropAddrIndex(db database.DB, interrupt <-chan struct{}) error {
-	return dropIndex(db, addrIndexKey, addrIndexName, interrupt)
-}

blockdag/indexers/addrindex_test.go

@@ -1,277 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/pkg/errors"
-	"testing"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// addrIndexBucket provides a mock address index database bucket by implementing
-// the internalBucket interface.
-type addrIndexBucket struct {
-	levels map[[levelKeySize]byte][]byte
-}
-
-// Clone returns a deep copy of the mock address index bucket.
-func (b *addrIndexBucket) Clone() *addrIndexBucket {
-	levels := make(map[[levelKeySize]byte][]byte)
-	for k, v := range b.levels {
-		vCopy := make([]byte, len(v))
-		copy(vCopy, v)
-		levels[k] = vCopy
-	}
-	return &addrIndexBucket{levels: levels}
-}
-
-// Get returns the value associated with the key from the mock address index
-// bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Get(key []byte) []byte {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	return b.levels[levelKey]
-}
-
-// Put stores the provided key/value pair to the mock address index bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Put(key []byte, value []byte) error {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	b.levels[levelKey] = value
-	return nil
-}
-
-// Delete removes the provided key from the mock address index bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Delete(key []byte) error {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	delete(b.levels, levelKey)
-	return nil
-}
-
-// printLevels returns a string with a visual representation of the provided
-// address key taking into account the max size of each level. It is useful
-// when creating and debugging test cases.
-func (b *addrIndexBucket) printLevels(addrKey [addrKeySize]byte) string {
-	highestLevel := uint8(0)
-	for k := range b.levels {
-		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
-			continue
-		}
-		level := uint8(k[levelOffset])
-		if level > highestLevel {
-			highestLevel = level
-		}
-	}
-
-	var levelBuf bytes.Buffer
-	_, _ = levelBuf.WriteString("\n")
-	maxEntries := level0MaxEntries
-	for level := uint8(0); level <= highestLevel; level++ {
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		for i := 0; i < numEntries; i++ {
-			start := i * txEntrySize
-			num := byteOrder.Uint32(data[start:])
-			_, _ = levelBuf.WriteString(fmt.Sprintf("%02d ", num))
-		}
-		for i := numEntries; i < maxEntries; i++ {
-			_, _ = levelBuf.WriteString("_  ")
-		}
-		_, _ = levelBuf.WriteString("\n")
-		maxEntries *= 2
-	}
-
-	return levelBuf.String()
-}
-
-// sanityCheck ensures that all data stored in the bucket for the given address
-// adheres to the level-based rules described by the address index
-// documentation.
-func (b *addrIndexBucket) sanityCheck(addrKey [addrKeySize]byte, expectedTotal int) error {
-	// Find the highest level for the key.
-	highestLevel := uint8(0)
-	for k := range b.levels {
-		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
-			continue
-		}
-		level := uint8(k[levelOffset])
-		if level > highestLevel {
-			highestLevel = level
-		}
-	}
-
-	// Ensure the expected total number of entries are present and that
-	// all levels adhere to the rules described in the address index
-	// documentation.
-	var totalEntries int
-	maxEntries := level0MaxEntries
-	for level := uint8(0); level <= highestLevel; level++ {
-		// Level 0 can'have more entries than the max allowed if the
-		// levels after it have data and it can't be empty. All other
-		// levels must either be half full or full.
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		totalEntries += numEntries
-		if level == 0 {
-			if (highestLevel != 0 && numEntries == 0) ||
-				numEntries > maxEntries {
-
-				return errors.Errorf("level %d has %d entries",
-					level, numEntries)
-			}
-		} else if numEntries != maxEntries && numEntries != maxEntries/2 {
-			return errors.Errorf("level %d has %d entries", level,
-				numEntries)
-		}
-		maxEntries *= 2
-	}
-	if totalEntries != expectedTotal {
-		return errors.Errorf("expected %d entries - got %d", expectedTotal,
-			totalEntries)
-	}
-
-	// Ensure all of the numbers are in order starting from the highest
-	// level moving to the lowest level.
-	expectedNum := uint32(0)
-	for level := highestLevel + 1; level > 0; level-- {
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		for i := 0; i < numEntries; i++ {
-			start := i * txEntrySize
-			num := byteOrder.Uint32(data[start:])
-			if num != expectedNum {
-				return errors.Errorf("level %d offset %d does "+
-					"not contain the expected number of "+
-					"%d - got %d", level, i, num,
-					expectedNum)
-			}
-			expectedNum++
-		}
-	}
-
-	return nil
-}
-
-// TestAddrIndexLevels ensures that adding and deleting entries to the address
-// index creates multiple levels as described by the address index
-// documentation.
-func TestAddrIndexLevels(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		key         [addrKeySize]byte
-		numInsert   int
-		printLevels bool // Set to help debug a specific test.
-	}{
-		{
-			name:      "level 0 not full",
-			numInsert: level0MaxEntries - 1,
-		},
-		{
-			name:      "level 1 half",
-			numInsert: level0MaxEntries + 1,
-		},
-		{
-			name:      "level 1 full",
-			numInsert: level0MaxEntries*2 + 1,
-		},
-		{
-			name:      "level 2 half, level 1 half",
-			numInsert: level0MaxEntries*3 + 1,
-		},
-		{
-			name:      "level 2 half, level 1 full",
-			numInsert: level0MaxEntries*4 + 1,
-		},
-		{
-			name:      "level 2 full, level 1 half",
-			numInsert: level0MaxEntries*5 + 1,
-		},
-		{
-			name:      "level 2 full, level 1 full",
-			numInsert: level0MaxEntries*6 + 1,
-		},
-		{
-			name:      "level 3 half, level 2 half, level 1 half",
-			numInsert: level0MaxEntries*7 + 1,
-		},
-		{
-			name:      "level 3 full, level 2 half, level 1 full",
-			numInsert: level0MaxEntries*12 + 1,
-		},
-	}
-
-nextTest:
-	for testNum, test := range tests {
-		// Insert entries in order.
-		populatedBucket := &addrIndexBucket{
-			levels: make(map[[levelKeySize]byte][]byte),
-		}
-		for i := 0; i < test.numInsert; i++ {
-			txLoc := wire.TxLoc{TxStart: i * 2}
-			err := dbPutAddrIndexEntry(populatedBucket, test.key,
-				uint64(i), txLoc)
-			if err != nil {
-				t.Errorf("dbPutAddrIndexEntry #%d (%s) - "+
-					"unexpected error: %v", testNum,
-					test.name, err)
-				continue nextTest
-			}
-		}
-		if test.printLevels {
-			t.Log(populatedBucket.printLevels(test.key))
-		}
-
-		// Delete entries from the populated bucket until all entries
-		// have been deleted. The bucket is reset to the fully
-		// populated bucket on each iteration so every combination is
-		// tested. Notice the upper limit purposes exceeds the number
-		// of entries to ensure attempting to delete more entries than
-		// there are works correctly.
-		for numDelete := 0; numDelete <= test.numInsert+1; numDelete++ {
-			// Clone populated bucket to run each delete against.
-			bucket := populatedBucket.Clone()
-
-			// Remove the number of entries for this iteration.
-			err := dbRemoveAddrIndexEntries(bucket, test.key,
-				numDelete)
-			if err != nil {
-				if numDelete <= test.numInsert {
-					t.Errorf("dbRemoveAddrIndexEntries (%s) "+
-						" delete %d - unexpected error: "+
-						"%v", test.name, numDelete, err)
-					continue nextTest
-				}
-			}
-			if test.printLevels {
-				t.Log(bucket.printLevels(test.key))
-			}
-
-			// Sanity check the levels to ensure the adhere to all
-			// rules.
-			numExpected := test.numInsert
-			if numDelete <= test.numInsert {
-				numExpected -= numDelete
-			}
-			err = bucket.sanityCheck(test.key, numExpected)
-			if err != nil {
-				t.Errorf("sanity check fail (%s) delete %d: %v",
-					test.name, numDelete, err)
-				continue nextTest
-			}
-		}
-	}
-}

blockdag/indexers/common.go

@@ -1,112 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-/*
-Package indexers implements optional block DAG indexes.
-*/
-package indexers
-
-import (
-	"encoding/binary"
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/pkg/errors"
-)
-
-var (
-	// byteOrder is the preferred byte order used for serializing numeric
-	// fields for storage in the database.
-	byteOrder = binary.LittleEndian
-
-	// errInterruptRequested indicates that an operation was cancelled due
-	// to a user-requested interrupt.
-	errInterruptRequested = errors.New("interrupt requested")
-)
-
-// NeedsInputser provides a generic interface for an indexer to specify the it
-// requires the ability to look up inputs for a transaction.
-type NeedsInputser interface {
-	NeedsInputs() bool
-}
-
-// Indexer provides a generic interface for an indexer that is managed by an
-// index manager such as the Manager type provided by this package.
-type Indexer interface {
-	// Key returns the key of the index as a byte slice.
-	Key() []byte
-
-	// Name returns the human-readable name of the index.
-	Name() string
-
-	// Create is invoked when the indexer manager determines the index needs
-	// to be created for the first time.
-	Create(dbTx database.Tx) error
-
-	// Init is invoked when the index manager is first initializing the
-	// index. This differs from the Create method in that it is called on
-	// every load, including the case the index was just created.
-	Init(db database.DB, dag *blockdag.BlockDAG) error
-
-	// ConnectBlock is invoked when the index manager is notified that a new
-	// block has been connected to the DAG.
-	ConnectBlock(dbTx database.Tx,
-		block *util.Block,
-		blockID uint64,
-		dag *blockdag.BlockDAG,
-		acceptedTxsData blockdag.MultiBlockTxsAcceptanceData,
-		virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error
-
-	// Recover is invoked when the indexer wasn't turned on for several blocks
-	// and the indexer needs to close the gaps.
-	Recover(dbTx database.Tx, currentBlockID, lastKnownBlockID uint64) error
-}
-
-// AssertError identifies an error that indicates an internal code consistency
-// issue and should be treated as a critical and unrecoverable error.
-type AssertError string
-
-// Error returns the assertion error as a huma-readable string and satisfies
-// the error interface.
-func (e AssertError) Error() string {
-	return "assertion failed: " + string(e)
-}
-
-// errDeserialize signifies that a problem was encountered when deserializing
-// data.
-type errDeserialize string
-
-// Error implements the error interface.
-func (e errDeserialize) Error() string {
-	return string(e)
-}
-
-// isDeserializeErr returns whether or not the passed error is an errDeserialize
-// error.
-func isDeserializeErr(err error) bool {
-	_, ok := err.(errDeserialize)
-	return ok
-}
-
-// internalBucket is an abstraction over a database bucket. It is used to make
-// the code easier to test since it allows mock objects in the tests to only
-// implement these functions instead of everything a database.Bucket supports.
-type internalBucket interface {
-	Get(key []byte) []byte
-	Put(key []byte, value []byte) error
-	Delete(key []byte) error
-}
-
-// interruptRequested returns true when the provided channel has been closed.
-// This simplifies early shutdown slightly since the caller can just use an if
-// statement instead of a select.
-func interruptRequested(interrupted <-chan struct{}) bool {
-	select {
-	case <-interrupted:
-		return true
-	default:
-	}
-
-	return false
-}

blockdag/indexers/manager.go

@@ -1,389 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-var (
-	// indexTipsBucketName is the name of the db bucket used to house the
-	// current tip of each index.
-	indexTipsBucketName = []byte("idxtips")
-
-	indexCurrentBlockIDBucketName = []byte("idxcurrentblockid")
-)
-
-// Manager defines an index manager that manages multiple optional indexes and
-// implements the blockdag.IndexManager interface so it can be seamlessly
-// plugged into normal DAG processing.
-type Manager struct {
-	db             database.DB
-	enabledIndexes []Indexer
-}
-
-// Ensure the Manager type implements the blockdag.IndexManager interface.
-var _ blockdag.IndexManager = (*Manager)(nil)
-
-// indexDropKey returns the key for an index which indicates it is in the
-// process of being dropped.
-func indexDropKey(idxKey []byte) []byte {
-	dropKey := make([]byte, len(idxKey)+1)
-	dropKey[0] = 'd'
-	copy(dropKey[1:], idxKey)
-	return dropKey
-}
-
-// maybeFinishDrops determines if each of the enabled indexes are in the middle
-// of being dropped and finishes dropping them when the are. This is necessary
-// because dropping and index has to be done in several atomic steps rather than
-// one big atomic step due to the massive number of entries.
-func (m *Manager) maybeFinishDrops(interrupt <-chan struct{}) error {
-	indexNeedsDrop := make([]bool, len(m.enabledIndexes))
-	err := m.db.View(func(dbTx database.Tx) error {
-		// None of the indexes needs to be dropped if the index tips
-		// bucket hasn't been created yet.
-		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
-		if indexesBucket == nil {
-			return nil
-		}
-
-		// Mark the indexer as requiring a drop if one is already in
-		// progress.
-		for i, indexer := range m.enabledIndexes {
-			dropKey := indexDropKey(indexer.Key())
-			if indexesBucket.Get(dropKey) != nil {
-				indexNeedsDrop[i] = true
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	if interruptRequested(interrupt) {
-		return errInterruptRequested
-	}
-
-	// Finish dropping any of the enabled indexes that are already in the
-	// middle of being dropped.
-	for i, indexer := range m.enabledIndexes {
-		if !indexNeedsDrop[i] {
-			continue
-		}
-
-		log.Infof("Resuming %s drop", indexer.Name())
-		err := dropIndex(m.db, indexer.Key(), indexer.Name(), interrupt)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// maybeCreateIndexes determines if each of the enabled indexes have already
-// been created and creates them if not.
-func (m *Manager) maybeCreateIndexes(dbTx database.Tx) error {
-	indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
-	for _, indexer := range m.enabledIndexes {
-		// Nothing to do if the index tip already exists.
-		idxKey := indexer.Key()
-		if indexesBucket.Get(idxKey) != nil {
-			continue
-		}
-
-		// The tip for the index does not exist, so create it and
-		// invoke the create callback for the index so it can perform
-		// any one-time initialization it requires.
-		if err := indexer.Create(dbTx); err != nil {
-			return err
-		}
-
-		// TODO (Mike): this is temporary solution to prevent node from not starting
-		// because it thinks indexers are not initialized.
-		// Indexers, however, do not work properly, and a general solution to their work operation is required
-		indexesBucket.Put(idxKey, []byte{0})
-	}
-
-	return nil
-}
-
-// Init initializes the enabled indexes. This is called during DAG
-// initialization and primarily consists of catching up all indexes to the
-// current tips. This is necessary since each index can be disabled
-// and re-enabled at any time and attempting to catch-up indexes at the same
-// time new blocks are being downloaded would lead to an overall longer time to
-// catch up due to the I/O contention.
-//
-// This is part of the blockdag.IndexManager interface.
-func (m *Manager) Init(db database.DB, blockDAG *blockdag.BlockDAG, interrupt <-chan struct{}) error {
-	// Nothing to do when no indexes are enabled.
-	if len(m.enabledIndexes) == 0 {
-		return nil
-	}
-
-	if interruptRequested(interrupt) {
-		return errInterruptRequested
-	}
-
-	m.db = db
-
-	// Finish and drops that were previously interrupted.
-	if err := m.maybeFinishDrops(interrupt); err != nil {
-		return err
-	}
-
-	// Create the initial state for the indexes as needed.
-	err := m.db.Update(func(dbTx database.Tx) error {
-		// Create the bucket for the current tips as needed.
-		meta := dbTx.Metadata()
-		_, err := meta.CreateBucketIfNotExists(indexTipsBucketName)
-		if err != nil {
-			return err
-		}
-		if _, err := meta.CreateBucketIfNotExists(indexCurrentBlockIDBucketName); err != nil {
-			return err
-		}
-
-		return m.maybeCreateIndexes(dbTx)
-	})
-	if err != nil {
-		return err
-	}
-
-	// Initialize each of the enabled indexes.
-	for _, indexer := range m.enabledIndexes {
-		if err := indexer.Init(db, blockDAG); err != nil {
-			return err
-		}
-	}
-
-	return m.recoverIfNeeded()
-}
-
-// recoverIfNeeded checks if the node worked for some time
-// without one of the current enabled indexes, and if it's
-// the case, recovers the missing blocks from the index.
-func (m *Manager) recoverIfNeeded() error {
-	return m.db.Update(func(dbTx database.Tx) error {
-		lastKnownBlockID := blockdag.DBFetchCurrentBlockID(dbTx)
-		for _, indexer := range m.enabledIndexes {
-			serializedCurrentIdxBlockID := dbTx.Metadata().Bucket(indexCurrentBlockIDBucketName).Get(indexer.Key())
-			currentIdxBlockID := uint64(0)
-			if serializedCurrentIdxBlockID != nil {
-				currentIdxBlockID = blockdag.DeserializeBlockID(serializedCurrentIdxBlockID)
-			}
-			if lastKnownBlockID > currentIdxBlockID {
-				err := indexer.Recover(dbTx, currentIdxBlockID, lastKnownBlockID)
-				if err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	})
-}
-
-// ConnectBlock must be invoked when a block is added to the DAG. It
-// keeps track of the state of each index it is managing, performs some sanity
-// checks, and invokes each indexer.
-//
-// This is part of the blockdag.IndexManager interface.
-func (m *Manager) ConnectBlock(dbTx database.Tx, block *util.Block, blockID uint64, dag *blockdag.BlockDAG,
-	txsAcceptanceData blockdag.MultiBlockTxsAcceptanceData, virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-
-	// Call each of the currently active optional indexes with the block
-	// being connected so they can update accordingly.
-	for _, index := range m.enabledIndexes {
-		// Notify the indexer with the connected block so it can index it.
-		if err := index.ConnectBlock(dbTx, block, blockID, dag, txsAcceptanceData, virtualTxsAcceptanceData); err != nil {
-			return err
-		}
-	}
-
-	// Add the new block ID index entry for the block being connected and
-	// update the current internal block ID accordingly.
-	err := m.updateIndexersWithCurrentBlockID(dbTx, block.Hash(), blockID)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *Manager) updateIndexersWithCurrentBlockID(dbTx database.Tx, blockHash *daghash.Hash, blockID uint64) error {
-	serializedBlockID := blockdag.SerializeBlockID(blockID)
-	for _, index := range m.enabledIndexes {
-		err := dbTx.Metadata().Bucket(indexCurrentBlockIDBucketName).Put(index.Key(), serializedBlockID)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// NewManager returns a new index manager with the provided indexes enabled.
-//
-// The manager returned satisfies the blockdag.IndexManager interface and thus
-// cleanly plugs into the normal blockdag processing path.
-func NewManager(enabledIndexes []Indexer) *Manager {
-	return &Manager{
-		enabledIndexes: enabledIndexes,
-	}
-}
-
-// dropIndex drops the passed index from the database. Since indexes can be
-// massive, it deletes the index in multiple database transactions in order to
-// keep memory usage to reasonable levels. It also marks the drop in progress
-// so the drop can be resumed if it is stopped before it is done before the
-// index can be used again.
-func dropIndex(db database.DB, idxKey []byte, idxName string, interrupt <-chan struct{}) error {
-	// Nothing to do if the index doesn't already exist.
-	var needsDelete bool
-	err := db.View(func(dbTx database.Tx) error {
-		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
-		if indexesBucket != nil && indexesBucket.Get(idxKey) != nil {
-			needsDelete = true
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-	if !needsDelete {
-		log.Infof("Not dropping %s because it does not exist", idxName)
-		return nil
-	}
-
-	// Mark that the index is in the process of being dropped so that it
-	// can be resumed on the next start if interrupted before the process is
-	// complete.
-	log.Infof("Dropping all %s entries. This might take a while...",
-		idxName)
-	err = db.Update(func(dbTx database.Tx) error {
-		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
-		return indexesBucket.Put(indexDropKey(idxKey), idxKey)
-	})
-	if err != nil {
-		return err
-	}
-
-	// Since the indexes can be so large, attempting to simply delete
-	// the bucket in a single database transaction would result in massive
-	// memory usage and likely crash many systems due to ulimits. In order
-	// to avoid this, use a cursor to delete a maximum number of entries out
-	// of the bucket at a time. Recurse buckets depth-first to delete any
-	// sub-buckets.
-	const maxDeletions = 2000000
-	var totalDeleted uint64
-
-	// Recurse through all buckets in the index, cataloging each for
-	// later deletion.
-	var subBuckets [][][]byte
-	var subBucketClosure func(database.Tx, []byte, [][]byte) error
-	subBucketClosure = func(dbTx database.Tx,
-		subBucket []byte, tlBucket [][]byte) error {
-		// Get full bucket name and append to subBuckets for later
-		// deletion.
-		var bucketName [][]byte
-		if (tlBucket == nil) || (len(tlBucket) == 0) {
-			bucketName = append(bucketName, subBucket)
-		} else {
-			bucketName = append(tlBucket, subBucket)
-		}
-		subBuckets = append(subBuckets, bucketName)
-		// Recurse sub-buckets to append to subBuckets slice.
-		bucket := dbTx.Metadata()
-		for _, subBucketName := range bucketName {
-			bucket = bucket.Bucket(subBucketName)
-		}
-		return bucket.ForEachBucket(func(k []byte) error {
-			return subBucketClosure(dbTx, k, bucketName)
-		})
-	}
-
-	// Call subBucketClosure with top-level bucket.
-	err = db.View(func(dbTx database.Tx) error {
-		return subBucketClosure(dbTx, idxKey, nil)
-	})
-	if err != nil {
-		return nil
-	}
-
-	// Iterate through each sub-bucket in reverse, deepest-first, deleting
-	// all keys inside them and then dropping the buckets themselves.
-	for i := range subBuckets {
-		bucketName := subBuckets[len(subBuckets)-1-i]
-		// Delete maxDeletions key/value pairs at a time.
-		for numDeleted := maxDeletions; numDeleted == maxDeletions; {
-			numDeleted = 0
-			err := db.Update(func(dbTx database.Tx) error {
-				subBucket := dbTx.Metadata()
-				for _, subBucketName := range bucketName {
-					subBucket = subBucket.Bucket(subBucketName)
-				}
-				cursor := subBucket.Cursor()
-				for ok := cursor.First(); ok; ok = cursor.Next() &&
-					numDeleted < maxDeletions {
-
-					if err := cursor.Delete(); err != nil {
-						return err
-					}
-					numDeleted++
-				}
-				return nil
-			})
-			if err != nil {
-				return err
-			}
-
-			if numDeleted > 0 {
-				totalDeleted += uint64(numDeleted)
-				log.Infof("Deleted %d keys (%d total) from %s",
-					numDeleted, totalDeleted, idxName)
-			}
-		}
-
-		if interruptRequested(interrupt) {
-			return errInterruptRequested
-		}
-
-		// Drop the bucket itself.
-		err = db.Update(func(dbTx database.Tx) error {
-			bucket := dbTx.Metadata()
-			for j := 0; j < len(bucketName)-1; j++ {
-				bucket = bucket.Bucket(bucketName[j])
-			}
-			return bucket.DeleteBucket(bucketName[len(bucketName)-1])
-		})
-	}
-
-	// Remove the index tip, index bucket, and in-progress drop flag now
-	// that all index entries have been removed.
-	err = db.Update(func(dbTx database.Tx) error {
-		meta := dbTx.Metadata()
-		indexesBucket := meta.Bucket(indexTipsBucketName)
-		if err := indexesBucket.Delete(idxKey); err != nil {
-			return err
-		}
-
-		if err := meta.Bucket(indexCurrentBlockIDBucketName).Delete(idxKey); err != nil {
-			return err
-		}
-
-		return indexesBucket.Delete(indexDropKey(idxKey))
-	})
-	if err != nil {
-		return err
-	}
-
-	log.Infof("Dropped %s", idxName)
-	return nil
-}

blockdag/indexers/txindex.go

@@ -1,438 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-const (
-	// txIndexName is the human-readable name for the index.
-	txIndexName = "transaction index"
-
-	includingBlocksIndexKeyEntrySize = 8 // 4 bytes for offset + 4 bytes for transaction length
-)
-
-var (
-	includingBlocksIndexKey = []byte("includingblocksidx")
-
-	acceptingBlocksIndexKey = []byte("acceptingblocksidx")
-)
-
-// txsAcceptedByVirtual is the in-memory index of txIDs that were accepted
-// by the current virtual
-var txsAcceptedByVirtual map[daghash.TxID]bool
-
-// -----------------------------------------------------------------------------
-// The transaction index consists of an entry for every transaction in the DAG.
-//
-// There are two buckets used in total. The first bucket maps the hash of
-// each transaction to its location in each block it's included in. The second bucket
-// contains all of the blocks that from their viewpoint the transaction has been
-// accepted (i.e. the transaction is found in their blue set without double spends),
-// and their blue block (or themselves) that included the transaction.
-//
-// NOTE: Although it is technically possible for multiple transactions to have
-// the same hash as long as the previous transaction with the same hash is fully
-// spent, this code only stores the most recent one because doing otherwise
-// would add a non-trivial amount of space and overhead for something that will
-// realistically never happen per the probability and even if it did, the old
-// one must be fully spent and so the most likely transaction a caller would
-// want for a given hash is the most recent one anyways.
-//
-// The including blocks index contains a sub bucket for each transaction hash (32 byte each), that its serialized format is:
-//
-//   <block id> = <start offset><tx length>
-//
-//   Field           Type              Size
-//   block id        uint64          8 bytes
-//   start offset    uint32          4 bytes
-//   tx length       uint32          4 bytes
-//   -----
-//   Total: 16 bytes
-//
-// The accepting blocks index contains a sub bucket for each transaction hash (32 byte each), that its serialized format is:
-//
-//   <accepting block id> = <including block id>
-//
-//   Field           Type              Size
-//   accepting block id        uint64          8 bytes
-//   including block id        uint64          8 bytes
-//   -----
-//   Total: 16 bytes
-//
-// -----------------------------------------------------------------------------
-
-func putIncludingBlocksEntry(target []byte, txLoc wire.TxLoc) {
-	byteOrder.PutUint32(target, uint32(txLoc.TxStart))
-	byteOrder.PutUint32(target[4:], uint32(txLoc.TxLen))
-}
-
-func dbPutIncludingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint64, serializedData []byte) error {
-	bucket, err := dbTx.Metadata().Bucket(includingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
-	if err != nil {
-		return err
-	}
-	return bucket.Put(blockdag.SerializeBlockID(blockID), serializedData)
-}
-
-func dbPutAcceptingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint64, serializedData []byte) error {
-	bucket, err := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
-	if err != nil {
-		return err
-	}
-	return bucket.Put(blockdag.SerializeBlockID(blockID), serializedData)
-}
-
-// dbFetchFirstTxRegion uses an existing database transaction to fetch the block
-// region for the provided transaction hash from the transaction index. When
-// there is no entry for the provided hash, nil will be returned for the both
-// the region and the error.
-//
-// 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.
-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.
-	txBucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txID[:])
-	if txBucket == nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No block region "+
-				"was found for %s", txID),
-		}
-	}
-	cursor := txBucket.Cursor()
-	if ok := cursor.First(); !ok {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No block region "+
-				"was found for %s", txID),
-		}
-	}
-	serializedBlockID := cursor.Key()
-	serializedData := cursor.Value()
-	if len(serializedData) == 0 {
-		return nil, nil
-	}
-
-	// Ensure the serialized data has enough bytes to properly deserialize.
-	if len(serializedData) < includingBlocksIndexKeyEntrySize {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("corrupt transaction index "+
-				"entry for %s", txID),
-		}
-	}
-
-	// Load the block hash associated with the block ID.
-	hash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, serializedBlockID)
-	if err != nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("corrupt transaction index "+
-				"entry for %s: %s", txID, err),
-		}
-	}
-
-	// Deserialize the final entry.
-	region := database.BlockRegion{Hash: &daghash.Hash{}}
-	copy(region.Hash[:], hash[:])
-	region.Offset = byteOrder.Uint32(serializedData[:4])
-	region.Len = byteOrder.Uint32(serializedData[4:])
-
-	return &region, nil
-}
-
-// dbAddTxIndexEntries uses an existing database transaction to add a
-// transaction index entry for every transaction in the passed block.
-func dbAddTxIndexEntries(dbTx database.Tx, block *util.Block, blockID uint64, multiBlockTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	// The offset and length of the transactions within the serialized
-	// block.
-	txLocs, err := block.TxLoc()
-	if err != nil {
-		return err
-	}
-
-	// As an optimization, allocate a single slice big enough to hold all
-	// of the serialized transaction index entries for the block and
-	// serialize them directly into the slice. Then, pass the appropriate
-	// subslice to the database to be written. This approach significantly
-	// cuts down on the number of required allocations.
-	includingBlocksOffset := 0
-	serializedIncludingBlocksValues := make([]byte, len(block.Transactions())*includingBlocksIndexKeyEntrySize)
-	for i, tx := range block.Transactions() {
-		putIncludingBlocksEntry(serializedIncludingBlocksValues[includingBlocksOffset:], txLocs[i])
-		endOffset := includingBlocksOffset + includingBlocksIndexKeyEntrySize
-		err := dbPutIncludingBlocksEntry(dbTx, tx.ID(), blockID,
-			serializedIncludingBlocksValues[includingBlocksOffset:endOffset:endOffset])
-		if err != nil {
-			return err
-		}
-		includingBlocksOffset += includingBlocksIndexKeyEntrySize
-	}
-
-	for _, blockTxsAcceptanceData := range multiBlockTxsAcceptanceData {
-		var includingBlockID uint64
-		if blockTxsAcceptanceData.BlockHash.IsEqual(block.Hash()) {
-			includingBlockID = blockID
-		} else {
-			includingBlockID, err = blockdag.DBFetchBlockIDByHash(dbTx, &blockTxsAcceptanceData.BlockHash)
-			if err != nil {
-				return err
-			}
-		}
-
-		serializedIncludingBlockID := blockdag.SerializeBlockID(includingBlockID)
-
-		for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
-			if !txAcceptanceData.IsAccepted {
-				continue
-			}
-			err = dbPutAcceptingBlocksEntry(dbTx, txAcceptanceData.Tx.ID(), blockID, serializedIncludingBlockID)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func updateTxsAcceptedByVirtual(virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	// Initialize a new txsAcceptedByVirtual
-	entries := 0
-	for _, blockTxsAcceptanceData := range virtualTxsAcceptanceData {
-		entries += len(blockTxsAcceptanceData.TxAcceptanceData)
-	}
-	txsAcceptedByVirtual = make(map[daghash.TxID]bool, entries)
-
-	// Copy virtualTxsAcceptanceData to txsAcceptedByVirtual
-	for _, blockTxsAcceptanceData := range virtualTxsAcceptanceData {
-		for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
-			txsAcceptedByVirtual[*txAcceptanceData.Tx.ID()] = true
-		}
-	}
-
-	return nil
-}
-
-// TxIndex implements a transaction by hash index. That is to say, it supports
-// querying all transactions by their hash.
-type TxIndex struct {
-	db database.DB
-}
-
-// Ensure the TxIndex type implements the Indexer interface.
-var _ Indexer = (*TxIndex)(nil)
-
-// Init initializes the hash-based transaction index. In particular, it finds
-// the highest used block ID and stores it for later use when connecting or
-// disconnecting blocks.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Init(db database.DB, dag *blockdag.BlockDAG) error {
-	idx.db = db
-
-	// Initialize the txsAcceptedByVirtual index
-	virtualTxsAcceptanceData, err := dag.TxsAcceptedByVirtual()
-	if err != nil {
-		return err
-	}
-	err = updateTxsAcceptedByVirtual(virtualTxsAcceptanceData)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// Key returns the database key to use for the index as a byte slice.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Key() []byte {
-	return includingBlocksIndexKey
-}
-
-// Name returns the human-readable name of the index.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Name() string {
-	return txIndexName
-}
-
-// Create is invoked when the indexer manager determines the index needs
-// to be created for the first time. It creates the buckets for the hash-based
-// transaction index and the internal block ID indexes.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Create(dbTx database.Tx) error {
-	meta := dbTx.Metadata()
-	if _, err := meta.CreateBucket(includingBlocksIndexKey); err != nil {
-		return err
-	}
-	_, err := meta.CreateBucket(acceptingBlocksIndexKey)
-	return err
-
-}
-
-// ConnectBlock is invoked by the index manager when a new block has been
-// connected to the DAG. This indexer adds a hash-to-transaction mapping
-// for every transaction in the passed block.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) ConnectBlock(dbTx database.Tx, block *util.Block, blockID uint64, dag *blockdag.BlockDAG,
-	acceptedTxsData blockdag.MultiBlockTxsAcceptanceData, virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	if err := dbAddTxIndexEntries(dbTx, block, blockID, acceptedTxsData); err != nil {
-		return err
-	}
-
-	err := updateTxsAcceptedByVirtual(virtualTxsAcceptanceData)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// TxFirstBlockRegion returns the first block region for the provided transaction hash
-// from the transaction index. The block region can in turn be used to load the
-// raw transaction bytes. When there is no entry for the provided hash, nil
-// will be returned for the both the entry and the error.
-//
-// This function is safe for concurrent access.
-func (idx *TxIndex) TxFirstBlockRegion(txID *daghash.TxID) (*database.BlockRegion, error) {
-	var region *database.BlockRegion
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		region, err = dbFetchFirstTxRegion(dbTx, txID)
-		return err
-	})
-	return region, err
-}
-
-// TxBlocks returns the hashes of the blocks where the transaction exists
-func (idx *TxIndex) TxBlocks(txHash *daghash.Hash) ([]*daghash.Hash, error) {
-	blockHashes := make([]*daghash.Hash, 0)
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		blockHashes, err = dbFetchTxBlocks(dbTx, txHash)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	return blockHashes, err
-}
-
-func dbFetchTxBlocks(dbTx database.Tx, txHash *daghash.Hash) ([]*daghash.Hash, error) {
-	blockHashes := make([]*daghash.Hash, 0)
-	bucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txHash[:])
-	if bucket == nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No including blocks "+
-				"were found for %s", txHash),
-		}
-	}
-	err := bucket.ForEach(func(serializedBlockID, _ []byte) error {
-		blockHash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, serializedBlockID)
-		if err != nil {
-			return err
-		}
-		blockHashes = append(blockHashes, blockHash)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return blockHashes, nil
-}
-
-// 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, txID *daghash.TxID) (*daghash.Hash, error) {
-	var acceptingBlock *daghash.Hash
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		acceptingBlock, err = dbFetchTxAcceptingBlock(dbTx, txID, dag)
-		return err
-	})
-	return acceptingBlock, err
-}
-
-func dbFetchTxAcceptingBlock(dbTx database.Tx, txID *daghash.TxID, dag *blockdag.BlockDAG) (*daghash.Hash, error) {
-	// If the transaction was accepted by the current virtual,
-	// return the zeroHash immediately
-	if _, ok := txsAcceptedByVirtual[*txID]; ok {
-		return &daghash.ZeroHash, nil
-	}
-
-	bucket := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).Bucket(txID[:])
-	if bucket == nil {
-		return nil, nil
-	}
-	cursor := bucket.Cursor()
-	if !cursor.First() {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("Accepting blocks bucket is "+
-				"empty for %s", txID),
-		}
-	}
-	for ; cursor.Key() != nil; cursor.Next() {
-		blockHash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, cursor.Key())
-		if err != nil {
-			return nil, err
-		}
-		isBlockInSelectedParentChain, err := dag.IsInSelectedParentChain(blockHash)
-		if err != nil {
-			return nil, err
-		}
-		if isBlockInSelectedParentChain {
-			return blockHash, nil
-		}
-	}
-	return nil, nil
-}
-
-// NewTxIndex returns a new instance of an indexer that is used to create a
-// mapping of the hashes of all transactions in the blockDAG to the respective
-// block, location within the block, and size of the transaction.
-//
-// It implements the Indexer interface which plugs into the IndexManager that in
-// turn is used by the blockdag package. This allows the index to be
-// seamlessly maintained along with the DAG.
-func NewTxIndex() *TxIndex {
-	return &TxIndex{}
-}
-
-// DropTxIndex drops the transaction index from the provided database if it
-// exists. Since the address index relies on it, the address index will also be
-// dropped when it exists.
-func DropTxIndex(db database.DB, interrupt <-chan struct{}) error {
-	err := dropIndex(db, addrIndexKey, addrIndexName, interrupt)
-	if err != nil {
-		return err
-	}
-
-	err = dropIndex(db, includingBlocksIndexKey, addrIndexName, interrupt)
-	if err != nil {
-		return err
-	}
-
-	return dropIndex(db, acceptingBlocksIndexKey, txIndexName, interrupt)
-}
-
-// Recover is invoked when the indexer wasn't turned on for several blocks
-// and the indexer needs to close the gaps.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Recover(dbTx database.Tx, currentBlockID, lastKnownBlockID uint64) error {
-	return errors.Errorf("txindex was turned off for %d blocks and can't be recovered."+
-		" To resume working drop the txindex with --droptxindex", lastKnownBlockID-currentBlockID)
-}

blockdag/indexers/txindex_test.go

@@ -1,144 +0,0 @@
-package indexers
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/mining"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func createTransaction(t *testing.T, value uint64, originTx *wire.MsgTx, outputIndex uint32) *wire.MsgTx {
-	signatureScript, err := txscript.PayToScriptHashSignatureScript(blockdag.OpTrueScript, nil)
-	if err != nil {
-		t.Fatalf("Error creating signature script: %s", err)
-	}
-	txIn := &wire.TxIn{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  *originTx.TxID(),
-			Index: outputIndex,
-		},
-		Sequence:        wire.MaxTxInSequenceNum,
-		SignatureScript: signatureScript,
-	}
-	txOut := wire.NewTxOut(value, blockdag.OpTrueScript)
-	tx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
-
-	return tx
-}
-
-func TestTxIndexConnectBlock(t *testing.T) {
-	blocks := make(map[daghash.Hash]*util.Block)
-
-	txIndex := NewTxIndex()
-	indexManager := NewManager([]Indexer{txIndex})
-
-	params := dagconfig.SimnetParams
-	params.BlockCoinbaseMaturity = 0
-	params.K = 1
-
-	config := blockdag.Config{
-		IndexManager: indexManager,
-		DAGParams:    &params,
-	}
-
-	dag, teardown, err := blockdag.DAGSetup("TestTxIndexConnectBlock", config)
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: Failed to setup DAG instance: %v", err)
-	}
-	if teardown != nil {
-		defer teardown()
-	}
-
-	prepareAndProcessBlock := func(parentHashes []*daghash.Hash, transactions []*wire.MsgTx, blockName string) *wire.MsgBlock {
-		block, err := mining.PrepareBlockForTest(dag, &params, parentHashes, transactions, false)
-		if err != nil {
-			t.Fatalf("TestTxIndexConnectBlock: block %v got unexpected error from PrepareBlockForTest: %v", blockName, err)
-		}
-		utilBlock := util.NewBlock(block)
-		blocks[*block.BlockHash()] = utilBlock
-		isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, blockdag.BFNoPoWCheck)
-		if err != nil {
-			t.Fatalf("TestTxIndexConnectBlock: dag.ProcessBlock got unexpected error for block %v: %v", blockName, err)
-		}
-		if isDelayed {
-			t.Fatalf("TestTxIndexConnectBlock: block %s "+
-				"is too far in the future", blockName)
-		}
-		if isOrphan {
-			t.Fatalf("TestTxIndexConnectBlock: block %v was unexpectedly orphan", blockName)
-		}
-		return block
-	}
-
-	block1 := prepareAndProcessBlock([]*daghash.Hash{params.GenesisHash}, nil, "1")
-	block2Tx := createTransaction(t, block1.Transactions[0].TxOut[0].Value, block1.Transactions[0], 0)
-	block2 := prepareAndProcessBlock([]*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{block2Tx}, "2")
-	block3Tx := createTransaction(t, block2.Transactions[0].TxOut[0].Value, block2.Transactions[0], 0)
-	block3 := prepareAndProcessBlock([]*daghash.Hash{block2.BlockHash()}, []*wire.MsgTx{block3Tx}, "3")
-
-	block2TxID := block2Tx.TxID()
-	block2TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block2TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-	block3Hash := block3.BlockHash()
-	if !block2TxNewAcceptedBlock.IsEqual(block3Hash) {
-		t.Errorf("TestTxIndexConnectBlock: block2Tx should've "+
-			"been accepted in block %v but instead got accepted in block %v", block3Hash, block2TxNewAcceptedBlock)
-	}
-
-	block3TxID := block3Tx.TxID()
-	block3TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block3TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-	if !block3TxNewAcceptedBlock.IsEqual(&daghash.ZeroHash) {
-		t.Errorf("TestTxIndexConnectBlock: block3Tx should've "+
-			"been accepted by the virtual block but instead got accepted in block %v", block3TxNewAcceptedBlock)
-	}
-
-	block3A := prepareAndProcessBlock([]*daghash.Hash{block2.BlockHash()}, []*wire.MsgTx{block3Tx}, "3A")
-	block4 := prepareAndProcessBlock([]*daghash.Hash{block3.BlockHash()}, nil, "4")
-	prepareAndProcessBlock([]*daghash.Hash{block3A.BlockHash(), block4.BlockHash()}, nil, "5")
-
-	block2TxAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block2TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-
-	if !block2TxAcceptedBlock.IsEqual(block3Hash) {
-		t.Errorf("TestTxIndexConnectBlock: block2Tx should've "+
-			"been accepted in block %v but instead got accepted in block %v", block3Hash, block2TxAcceptedBlock)
-	}
-
-	region, err := txIndex.TxFirstBlockRegion(block3TxID)
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: no block region was found for block3Tx")
-	}
-	regionBlock, ok := blocks[*region.Hash]
-	if !ok {
-		t.Fatalf("TestTxIndexConnectBlock: couldn't find block with hash %v", region.Hash)
-	}
-
-	regionBlockBytes, err := regionBlock.Bytes()
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: Couldn't serialize block to bytes")
-	}
-	block3TxInBlock := regionBlockBytes[region.Offset : region.Offset+region.Len]
-
-	block3TxBuf := bytes.NewBuffer(make([]byte, 0, block3Tx.SerializeSize()))
-	block3Tx.KaspaEncode(block3TxBuf, 0)
-	blockTxBytes := block3TxBuf.Bytes()
-
-	if !reflect.DeepEqual(blockTxBytes, block3TxInBlock) {
-		t.Errorf("TestTxIndexConnectBlock: the block region that was in the bucket doesn't match block3Tx")
-	}
-
-}

blockdag/mediantime.go

@@ -1,206 +0,0 @@
-// Copyright (c) 2013-2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"math"
-	"sort"
-	"sync"
-	"time"
-)
-
-const (
-	// maxAllowedOffsetSeconds is the maximum number of seconds in either
-	// direction that local clock will be adjusted. When the median time
-	// of the network is outside of this range, no offset will be applied.
-	maxAllowedOffsetSecs = 70 * 60 // 1 hour 10 minutes
-
-	// similarTimeSecs is the number of seconds in either direction from the
-	// local clock that is used to determine that it is likley wrong and
-	// hence to show a warning.
-	similarTimeSecs = 5 * 60 // 5 minutes
-)
-
-var (
-	// maxMedianTimeEntries is the maximum number of entries allowed in the
-	// median time data. This is a variable as opposed to a constant so the
-	// test code can modify it.
-	maxMedianTimeEntries = 200
-)
-
-// MedianTimeSource provides a mechanism to add several time samples which are
-// used to determine a median time which is then used as an offset to the local
-// clock.
-type MedianTimeSource interface {
-	// AdjustedTime returns the current time adjusted by the median time
-	// offset as calculated from the time samples added by AddTimeSample.
-	AdjustedTime() time.Time
-
-	// AddTimeSample adds a time sample that is used when determining the
-	// median time of the added samples.
-	AddTimeSample(id string, timeVal time.Time)
-
-	// Offset returns the number of seconds to adjust the local clock based
-	// upon the median of the time samples added by AddTimeData.
-	Offset() time.Duration
-}
-
-// int64Sorter implements sort.Interface to allow a slice of 64-bit integers to
-// be sorted.
-type int64Sorter []int64
-
-// Len returns the number of 64-bit integers in the slice. It is part of the
-// sort.Interface implementation.
-func (s int64Sorter) Len() int {
-	return len(s)
-}
-
-// Swap swaps the 64-bit integers at the passed indices. It is part of the
-// sort.Interface implementation.
-func (s int64Sorter) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-
-// Less returns whether the 64-bit integer with index i should sort before the
-// 64-bit integer with index j. It is part of the sort.Interface
-// implementation.
-func (s int64Sorter) Less(i, j int) bool {
-	return s[i] < s[j]
-}
-
-// medianTime provides an implementation of the MedianTimeSource interface.
-type medianTime struct {
-	mtx                sync.Mutex
-	knownIDs           map[string]struct{}
-	offsets            []int64
-	offsetSecs         int64
-	invalidTimeChecked bool
-}
-
-// Ensure the medianTime type implements the MedianTimeSource interface.
-var _ MedianTimeSource = (*medianTime)(nil)
-
-// AdjustedTime returns the current time adjusted by the median time offset as
-// calculated from the time samples added by AddTimeSample.
-//
-// This function is safe for concurrent access and is part of the
-// MedianTimeSource interface implementation.
-func (m *medianTime) AdjustedTime() time.Time {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
-
-	// Limit the adjusted time to 1 second precision.
-	now := time.Unix(time.Now().Unix(), 0)
-	return now.Add(time.Duration(m.offsetSecs) * time.Second)
-}
-
-// AddTimeSample adds a time sample that is used when determining the median
-// time of the added samples.
-//
-// This function is safe for concurrent access and is part of the
-// MedianTimeSource interface implementation.
-func (m *medianTime) AddTimeSample(sourceID string, timeVal time.Time) {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
-
-	// Don't add time data from the same source.
-	if _, exists := m.knownIDs[sourceID]; exists {
-		return
-	}
-	m.knownIDs[sourceID] = struct{}{}
-
-	// Truncate the provided offset to seconds and append it to the slice
-	// of offsets while respecting the maximum number of allowed entries by
-	// replacing the oldest entry with the new entry once the maximum number
-	// of entries is reached.
-	now := time.Unix(time.Now().Unix(), 0)
-	offsetSecs := int64(timeVal.Sub(now).Seconds())
-	numOffsets := len(m.offsets)
-	if numOffsets == maxMedianTimeEntries && maxMedianTimeEntries > 0 {
-		m.offsets = m.offsets[1:]
-		numOffsets--
-	}
-	m.offsets = append(m.offsets, offsetSecs)
-	numOffsets++
-
-	// Sort the offsets so the median can be obtained as needed later.
-	sortedOffsets := make([]int64, numOffsets)
-	copy(sortedOffsets, m.offsets)
-	sort.Sort(int64Sorter(sortedOffsets))
-
-	offsetDuration := time.Duration(offsetSecs) * time.Second
-	log.Debugf("Added time sample of %s (total: %d)", offsetDuration,
-		numOffsets)
-
-	// The median offset is only updated when there are enough offsets and
-	// the number of offsets is odd so the middle value is the true median.
-	// Thus, there is nothing to do when those conditions are not met.
-	if numOffsets < 5 || numOffsets&0x01 != 1 {
-		return
-	}
-
-	// At this point the number of offsets in the list is odd, so the
-	// middle value of the sorted offsets is the median.
-	median := sortedOffsets[numOffsets/2]
-
-	// Set the new offset when the median offset is within the allowed
-	// offset range.
-	if math.Abs(float64(median)) < maxAllowedOffsetSecs {
-		m.offsetSecs = median
-	} else {
-		// The median offset of all added time data is larger than the
-		// maximum allowed offset, so don't use an offset. This
-		// effectively limits how far the local clock can be skewed.
-		m.offsetSecs = 0
-
-		if !m.invalidTimeChecked {
-			m.invalidTimeChecked = true
-
-			// Find if any time samples have a time that is close
-			// to the local time.
-			var remoteHasCloseTime bool
-			for _, offset := range sortedOffsets {
-				if math.Abs(float64(offset)) < similarTimeSecs {
-					remoteHasCloseTime = true
-					break
-				}
-			}
-
-			// Warn if none of the time samples are close.
-			if !remoteHasCloseTime {
-				log.Warnf("Please check your date and time " +
-					"are correct!  kaspad will not work " +
-					"properly with an invalid time")
-			}
-		}
-	}
-
-	medianDuration := time.Duration(m.offsetSecs) * time.Second
-	log.Debugf("New time offset: %d", medianDuration)
-}
-
-// Offset returns the number of seconds to adjust the local clock based upon the
-// median of the time samples added by AddTimeData.
-//
-// This function is safe for concurrent access and is part of the
-// MedianTimeSource interface implementation.
-func (m *medianTime) Offset() time.Duration {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
-
-	return time.Duration(m.offsetSecs) * time.Second
-}
-
-// NewMedianTime returns a new instance of concurrency-safe implementation of
-// the MedianTimeSource interface. The returned implementation contains the
-// rules necessary for proper time handling in the DAG consensus rules and
-// expects the time samples to be added from the timestamp field of the version
-// message received from remote peers that successfully connect and negotiate.
-func NewMedianTime() MedianTimeSource {
-	return &medianTime{
-		knownIDs: make(map[string]struct{}),
-		offsets:  make([]int64, 0, maxMedianTimeEntries),
-	}
-}

blockdag/mediantime_test.go

@@ -1,102 +0,0 @@
-// Copyright (c) 2013-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"strconv"
-	"testing"
-	"time"
-)
-
-// TestMedianTime tests the medianTime implementation.
-func TestMedianTime(t *testing.T) {
-	tests := []struct {
-		in         []int64
-		wantOffset int64
-		useDupID   bool
-	}{
-		// Not enough samples must result in an offset of 0.
-		{in: []int64{1}, wantOffset: 0},
-		{in: []int64{1, 2}, wantOffset: 0},
-		{in: []int64{1, 2, 3}, wantOffset: 0},
-		{in: []int64{1, 2, 3, 4}, wantOffset: 0},
-
-		// Various number of entries. The expected offset is only
-		// updated on odd number of elements.
-		{in: []int64{-13, 57, -4, -23, -12}, wantOffset: -12},
-		{in: []int64{55, -13, 61, -52, 39, 55}, wantOffset: 39},
-		{in: []int64{-62, -58, -30, -62, 51, -30, 15}, wantOffset: -30},
-		{in: []int64{29, -47, 39, 54, 42, 41, 8, -33}, wantOffset: 39},
-		{in: []int64{37, 54, 9, -21, -56, -36, 5, -11, -39}, wantOffset: -11},
-		{in: []int64{57, -28, 25, -39, 9, 63, -16, 19, -60, 25}, wantOffset: 9},
-		{in: []int64{-5, -4, -3, -2, -1}, wantOffset: -3, useDupID: true},
-
-		// The offset stops being updated once the max number of entries
-		// has been reached.
-		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52}, wantOffset: 17},
-		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45}, wantOffset: 17},
-		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45, 4}, wantOffset: 17},
-
-		// Offsets that are too far away from the local time should
-		// be ignored.
-		{in: []int64{-4201, 4202, -4203, 4204, -4205}, wantOffset: 0},
-
-		// Exercise the condition where the median offset is greater
-		// than the max allowed adjustment, but there is at least one
-		// sample that is close enough to the current time to avoid
-		// triggering a warning about an invalid local clock.
-		{in: []int64{4201, 4202, 4203, 4204, -299}, wantOffset: 0},
-	}
-
-	// Modify the max number of allowed median time entries for these tests.
-	maxMedianTimeEntries = 10
-	defer func() { maxMedianTimeEntries = 200 }()
-
-	for i, test := range tests {
-		filter := NewMedianTime()
-		for j, offset := range test.in {
-			id := strconv.Itoa(j)
-			now := time.Unix(time.Now().Unix(), 0)
-			tOffset := now.Add(time.Duration(offset) * time.Second)
-			filter.AddTimeSample(id, tOffset)
-
-			// Ensure the duplicate IDs are ignored.
-			if test.useDupID {
-				// Modify the offsets to ensure the final median
-				// would be different if the duplicate is added.
-				tOffset = tOffset.Add(time.Duration(offset) *
-					time.Second)
-				filter.AddTimeSample(id, tOffset)
-			}
-		}
-
-		// Since it is possible that the time.Now call in AddTimeSample
-		// and the time.Now calls here in the tests will be off by one
-		// second, allow a fudge factor to compensate.
-		gotOffset := filter.Offset()
-		wantOffset := time.Duration(test.wantOffset) * time.Second
-		wantOffset2 := time.Duration(test.wantOffset-1) * time.Second
-		if gotOffset != wantOffset && gotOffset != wantOffset2 {
-			t.Errorf("Offset #%d: unexpected offset -- got %v, "+
-				"want %v or %v", i, gotOffset, wantOffset,
-				wantOffset2)
-			continue
-		}
-
-		// Since it is possible that the time.Now call in AdjustedTime
-		// and the time.Now call here in the tests will be off by one
-		// second, allow a fudge factor to compensate.
-		adjustedTime := filter.AdjustedTime()
-		now := time.Unix(time.Now().Unix(), 0)
-		wantTime := now.Add(filter.Offset())
-		wantTime2 := now.Add(filter.Offset() - time.Second)
-		if !adjustedTime.Equal(wantTime) && !adjustedTime.Equal(wantTime2) {
-			t.Errorf("AdjustedTime #%d: unexpected result -- got %v, "+
-				"want %v or %v", i, adjustedTime, wantTime,
-				wantTime2)
-			continue
-		}
-	}
-}

blockdag/process.go

@@ -1,263 +0,0 @@
-// Copyright (c) 2013-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"time"
-
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// BehaviorFlags is a bitmask defining tweaks to the normal behavior when
-// performing DAG processing and consensus rules checks.
-type BehaviorFlags uint32
-
-const (
-	// BFFastAdd may be set to indicate that several checks can be avoided
-	// for the block since it is already known to fit into the DAG due to
-	// already proving it correct links into the DAG.
-	BFFastAdd BehaviorFlags = 1 << iota
-
-	// BFNoPoWCheck may be set to indicate the proof of work check which
-	// ensures a block hashes to a value less than the required target will
-	// not be performed.
-	BFNoPoWCheck
-
-	// BFWasUnorphaned may be set to indicate that a block was just now
-	// unorphaned
-	BFWasUnorphaned
-
-	// BFAfterDelay may be set to indicate that a block had timestamp too far
-	// in the future, just finished the delay
-	BFAfterDelay
-
-	// BFIsSync may be set to indicate that the block was sent as part of the
-	// netsync process
-	BFIsSync
-
-	// BFWasStored is set to indicate that the block was previously stored
-	// in the block index but was never fully processed
-	BFWasStored
-
-	// BFNone is a convenience value to specifically indicate no flags.
-	BFNone BehaviorFlags = 0
-)
-
-// BlockExists determines whether a block with the given hash exists in
-// the DAG.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) BlockExists(hash *daghash.Hash) bool {
-	return dag.index.HaveBlock(hash)
-}
-
-// processOrphans determines if there are any orphans which depend on the passed
-// block hash (they are no longer orphans if true) and potentially accepts them.
-// It repeats the process for the newly accepted blocks (to detect further
-// orphans which may no longer be orphans) until there are no more.
-//
-// The flags do not modify the behavior of this function directly, however they
-// are needed to pass along to maybeAcceptBlock.
-//
-// This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) processOrphans(hash *daghash.Hash, flags BehaviorFlags) error {
-	// Start with processing at least the passed hash. Leave a little room
-	// for additional orphan blocks that need to be processed without
-	// needing to grow the array in the common case.
-	processHashes := make([]*daghash.Hash, 0, 10)
-	processHashes = append(processHashes, hash)
-	for len(processHashes) > 0 {
-		// Pop the first hash to process from the slice.
-		processHash := processHashes[0]
-		processHashes[0] = nil // Prevent GC leak.
-		processHashes = processHashes[1:]
-
-		// Look up all orphans that are parented by the block we just
-		// accepted.  An indexing for loop is
-		// intentionally used over a range here as range does not
-		// reevaluate the slice on each iteration nor does it adjust the
-		// index for the modified slice.
-		for i := 0; i < len(dag.prevOrphans[*processHash]); i++ {
-			orphan := dag.prevOrphans[*processHash][i]
-			if orphan == nil {
-				log.Warnf("Found a nil entry at index %d in the "+
-					"orphan dependency list for block %s", i,
-					processHash)
-				continue
-			}
-
-			// Skip this orphan if one or more of its parents are
-			// still missing.
-			_, err := lookupParentNodes(orphan.block, dag)
-			if err != nil {
-				if ruleErr, ok := err.(RuleError); ok && ruleErr.ErrorCode == ErrParentBlockUnknown {
-					continue
-				}
-				return err
-			}
-
-			// Remove the orphan from the orphan pool.
-			orphanHash := orphan.block.Hash()
-			dag.removeOrphanBlock(orphan)
-			i--
-
-			// Potentially accept the block into the block DAG.
-			err = dag.maybeAcceptBlock(orphan.block, flags|BFWasUnorphaned)
-			if err != nil {
-				// Since we don't want to reject the original block because of
-				// a bad unorphaned child, only return an error if it's not a RuleError.
-				if _, ok := err.(RuleError); !ok {
-					return err
-				}
-				log.Warnf("Verification failed for orphan block %s: %s", orphanHash, err)
-			}
-
-			// Add this block to the list of blocks to process so
-			// any orphan blocks that depend on this block are
-			// handled too.
-			processHashes = append(processHashes, orphanHash)
-		}
-	}
-	return nil
-}
-
-// ProcessBlock is the main workhorse for handling insertion of new blocks into
-// the block DAG. It includes functionality such as rejecting duplicate
-// blocks, ensuring blocks follow all rules, orphan handling, and insertion into
-// the block DAG.
-//
-// When no errors occurred during processing, the first return value indicates
-// whether or not the block is an orphan.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) ProcessBlock(block *util.Block, flags BehaviorFlags) (isOrphan bool, isDelayed bool, err error) {
-	dag.dagLock.Lock()
-	defer dag.dagLock.Unlock()
-	return dag.processBlockNoLock(block, flags)
-}
-
-func (dag *BlockDAG) processBlockNoLock(block *util.Block, flags BehaviorFlags) (isOrphan bool, isDelayed bool, err error) {
-	isAfterDelay := flags&BFAfterDelay == BFAfterDelay
-	wasBlockStored := flags&BFWasStored == BFWasStored
-
-	blockHash := block.Hash()
-	log.Tracef("Processing block %s", blockHash)
-
-	// The block must not already exist in the DAG.
-	if dag.BlockExists(blockHash) && !wasBlockStored {
-		str := fmt.Sprintf("already have block %s", blockHash)
-		return false, false, ruleError(ErrDuplicateBlock, str)
-	}
-
-	// The block must not already exist as an orphan.
-	if _, exists := dag.orphans[*blockHash]; exists {
-		str := fmt.Sprintf("already have block (orphan) %s", blockHash)
-		return false, false, ruleError(ErrDuplicateBlock, str)
-	}
-
-	if dag.isKnownDelayedBlock(blockHash) {
-		str := fmt.Sprintf("already have block (delayed) %s", blockHash)
-		return false, false, ruleError(ErrDuplicateBlock, str)
-	}
-
-	if !isAfterDelay {
-		// Perform preliminary sanity checks on the block and its transactions.
-		delay, err := dag.checkBlockSanity(block, flags)
-		if err != nil {
-			return false, false, err
-		}
-
-		if delay != 0 {
-			err = dag.addDelayedBlock(block, delay)
-			if err != nil {
-				return false, false, err
-			}
-			return false, true, nil
-		}
-	}
-
-	var missingParents []*daghash.Hash
-	for _, parentHash := range block.MsgBlock().Header.ParentHashes {
-		if !dag.BlockExists(parentHash) {
-			missingParents = append(missingParents, parentHash)
-		}
-	}
-
-	// Handle the case of a block with a valid timestamp(non-delayed) which points to a delayed block.
-	delay, isParentDelayed := dag.maxDelayOfParents(missingParents)
-	if isParentDelayed {
-		// Add Nanosecond to ensure that parent process time will be after its child.
-		delay += time.Nanosecond
-		err := dag.addDelayedBlock(block, delay)
-		if err != nil {
-			return false, false, err
-		}
-		return false, true, err
-	}
-
-	// Handle orphan blocks.
-	if len(missingParents) > 0 {
-		// Some orphans during netsync are a normal part of the process, since the anticone
-		// of the chain-split is never explicitly requested.
-		// Therefore, if we are during netsync - don't report orphans to default logs.
-		//
-		// The number K*2 was chosen since in peace times anticone is limited to K blocks,
-		// while some red block can make it a bit bigger, but much more than that indicates
-		// there might be some problem with the netsync process.
-		if flags&BFIsSync == BFIsSync && dagconfig.KType(len(dag.orphans)) < dag.dagParams.K*2 {
-			log.Debugf("Adding orphan block %s. This is normal part of netsync process", blockHash)
-		} else {
-			log.Infof("Adding orphan block %s", blockHash)
-		}
-		dag.addOrphanBlock(block)
-
-		return true, false, nil
-	}
-
-	// The block has passed all context independent checks and appears sane
-	// enough to potentially accept it into the block DAG.
-	err = dag.maybeAcceptBlock(block, flags)
-	if err != nil {
-		return false, false, err
-	}
-
-	// Accept any orphan blocks that depend on this block (they are
-	// no longer orphans) and repeat for those accepted blocks until
-	// there are no more.
-	err = dag.processOrphans(blockHash, flags)
-	if err != nil {
-		return false, false, err
-	}
-
-	if !isAfterDelay {
-		err = dag.processDelayedBlocks()
-		if err != nil {
-			return false, false, err
-		}
-	}
-
-	log.Debugf("Accepted block %s", blockHash)
-
-	return false, false, nil
-}
-
-// maxDelayOfParents returns the maximum delay of the given block hashes.
-// Note that delay could be 0, but isDelayed will return true. This is the case where the parent process time is due.
-func (dag *BlockDAG) maxDelayOfParents(parentHashes []*daghash.Hash) (delay time.Duration, isDelayed bool) {
-	for _, parentHash := range parentHashes {
-		if delayedParent, exists := dag.delayedBlocks[*parentHash]; exists {
-			isDelayed = true
-			parentDelay := delayedParent.processTime.Sub(dag.AdjustedTime())
-			if parentDelay > delay {
-				delay = parentDelay
-			}
-		}
-	}
-
-	return delay, isDelayed
-}

blockdag/process_test.go

@@ -1,71 +0,0 @@
-package blockdag
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-func TestProcessOrphans(t *testing.T) {
-	dag, teardownFunc, err := DAGSetup("TestProcessOrphans", Config{
-		DAGParams: &dagconfig.SimnetParams,
-	})
-	if err != nil {
-		t.Errorf("Failed to setup dag instance: %v", err)
-		return
-	}
-	defer teardownFunc()
-
-	dag.TestSetCoinbaseMaturity(0)
-
-	blocksFile := "blk_0_to_4.dat"
-	blocks, err := LoadBlocks(filepath.Join("testdata/", blocksFile))
-	if err != nil {
-		t.Fatalf("TestProcessOrphans: "+
-			"Error loading file '%s': %s\n", blocksFile, err)
-	}
-
-	// Get a reference to a parent block
-	parentBlock := blocks[1]
-
-	// Get a reference to a child block and mess with it so that:
-	// a. It gets added to the orphan pool
-	// b. It gets rejected once it's unorphaned
-	childBlock := blocks[2]
-	childBlock.MsgBlock().Header.UTXOCommitment = &daghash.ZeroHash
-
-	// Process the child block so that it gets added to the orphan pool
-	isOrphan, isDelayed, err := dag.ProcessBlock(childBlock, BFNoPoWCheck)
-	if err != nil {
-		t.Fatalf("TestProcessOrphans: child block unexpectedly returned an error: %s", err)
-	}
-	if isDelayed {
-		t.Fatalf("TestProcessOrphans: child block is too far in the future")
-	}
-	if !isOrphan {
-		t.Fatalf("TestProcessOrphans: incorrectly returned that child block is not an orphan")
-	}
-
-	// Process the parent block. Note that this will attempt to unorphan the child block
-	isOrphan, isDelayed, err = dag.ProcessBlock(parentBlock, BFNone)
-	if err != nil {
-		t.Fatalf("TestProcessOrphans: parent block unexpectedly returned an error: %s", err)
-	}
-	if isDelayed {
-		t.Fatalf("TestProcessOrphans: parent block is too far in the future")
-	}
-	if isOrphan {
-		t.Fatalf("TestProcessOrphans: incorrectly returned that parent block is an orphan")
-	}
-
-	// Make sure that the child block had been rejected
-	node := dag.index.LookupNode(childBlock.Hash())
-	if node == nil {
-		t.Fatalf("TestProcessOrphans: child block missing from block index")
-	}
-	if !dag.index.NodeStatus(node).KnownInvalid() {
-		t.Fatalf("TestProcessOrphans: child block erroneously not marked as invalid")
-	}
-}

blockdag/reachability.go

@@ -1,589 +0,0 @@
-package blockdag
-
-import (
-	"fmt"
-	"github.com/pkg/errors"
-	"math"
-	"strings"
-)
-
-// reachabilityInterval represents an interval to be used within the
-// tree reachability algorithm. See reachabilityTreeNode for further
-// details.
-type reachabilityInterval struct {
-	start uint64
-	end   uint64
-}
-
-func newReachabilityInterval(start uint64, end uint64) *reachabilityInterval {
-	return &reachabilityInterval{start: start, end: end}
-}
-
-// size returns the size of this interval. Note that intervals are
-// inclusive from both sides.
-func (ri *reachabilityInterval) size() uint64 {
-	return ri.end - ri.start + 1
-}
-
-// splitInHalf splits this interval by a fraction of 0.5.
-// See splitFraction for further details.
-func (ri *reachabilityInterval) splitInHalf() (
-	left *reachabilityInterval, right *reachabilityInterval, err error) {
-
-	return ri.splitFraction(0.5)
-}
-
-// splitFraction splits this interval to two parts such that their
-// union is equal to the original interval and the first (left) part
-// contains the given fraction of the original interval's size.
-// Note: if the split results in fractional parts, this method rounds
-// the first part up and the last part down.
-func (ri *reachabilityInterval) splitFraction(fraction float64) (
-	left *reachabilityInterval, right *reachabilityInterval, err error) {
-
-	if fraction < 0 || fraction > 1 {
-		return nil, nil, errors.Errorf("fraction must be between 0 and 1")
-	}
-	if ri.size() == 0 {
-		return nil, nil, errors.Errorf("cannot split an empty interval")
-	}
-
-	allocationSize := uint64(math.Ceil(float64(ri.size()) * fraction))
-	left = newReachabilityInterval(ri.start, ri.start+allocationSize-1)
-	right = newReachabilityInterval(ri.start+allocationSize, ri.end)
-	return left, right, nil
-}
-
-// splitExact splits this interval to exactly |sizes| parts where
-// |part_i| = sizes[i]. This method expects sum(sizes) to be exactly
-// equal to the interval's size.
-func (ri *reachabilityInterval) splitExact(sizes []uint64) ([]*reachabilityInterval, error) {
-	sizesSum := uint64(0)
-	for _, size := range sizes {
-		sizesSum += size
-	}
-	if sizesSum != ri.size() {
-		return nil, errors.Errorf("sum of sizes must be equal to the interval's size")
-	}
-
-	intervals := make([]*reachabilityInterval, len(sizes))
-	start := ri.start
-	for i, size := range sizes {
-		intervals[i] = newReachabilityInterval(start, start+size-1)
-		start += size
-	}
-	return intervals, nil
-}
-
-// splitWithExponentialBias splits this interval to |sizes| parts
-// by the allocation rule described below. This method expects sum(sizes)
-// to be smaller or equal to the interval's size. Every part_i is
-// allocated at least sizes[i] capacity. The remaining budget is
-// split by an exponentially biased rule described below.
-//
-// This rule follows the GHOSTDAG protocol behavior where the child
-// with the largest subtree is expected to dominate the competition
-// for new blocks and thus grow the most. However, we may need to
-// add slack for non-largest subtrees in order to make CPU reindexing
-// attacks unworthy.
-func (ri *reachabilityInterval) splitWithExponentialBias(sizes []uint64) ([]*reachabilityInterval, error) {
-	intervalSize := ri.size()
-	sizesSum := uint64(0)
-	for _, size := range sizes {
-		sizesSum += size
-	}
-	if sizesSum > intervalSize {
-		return nil, errors.Errorf("sum of sizes must be less than or equal to the interval's size")
-	}
-	if sizesSum == intervalSize {
-		return ri.splitExact(sizes)
-	}
-
-	// Add a fractional bias to every size in the given sizes
-	totalBias := intervalSize - sizesSum
-	remainingBias := totalBias
-	biasedSizes := make([]uint64, len(sizes))
-	fractions := exponentialFractions(sizes)
-	for i, fraction := range fractions {
-		var bias uint64
-		if i == len(fractions)-1 {
-			bias = remainingBias
-		} else {
-			bias = uint64(math.Round(float64(totalBias) * fraction))
-			if bias > remainingBias {
-				bias = remainingBias
-			}
-		}
-		biasedSizes[i] = sizes[i] + bias
-		remainingBias -= bias
-	}
-	return ri.splitExact(biasedSizes)
-}
-
-// exponentialFractions returns a fraction of each size in sizes
-// as follows:
-//   fraction[i] = 2^size[i] / sum_j(2^size[j])
-// In the code below the above equation is divided by 2^max(size)
-// to avoid exploding numbers. Note that in 1 / 2^(max(size)-size[i])
-// we divide 1 by potentially a very large number, which will
-// result in loss of float precision. This is not a problem - all
-// numbers close to 0 bear effectively the same weight.
-func exponentialFractions(sizes []uint64) []float64 {
-	maxSize := uint64(0)
-	for _, size := range sizes {
-		if size > maxSize {
-			maxSize = size
-		}
-	}
-	fractions := make([]float64, len(sizes))
-	for i, size := range sizes {
-		fractions[i] = 1 / math.Pow(2, float64(maxSize-size))
-	}
-	fractionsSum := float64(0)
-	for _, fraction := range fractions {
-		fractionsSum += fraction
-	}
-	for i, fraction := range fractions {
-		fractions[i] = fraction / fractionsSum
-	}
-	return fractions
-}
-
-// isAncestorOf checks if this interval's node is a reachability tree
-// ancestor of the other interval's node. The condition below is relying on the
-// property of reachability intervals that intervals are either completely disjoint,
-// or one strictly contains the other.
-func (ri *reachabilityInterval) isAncestorOf(other *reachabilityInterval) bool {
-	return ri.start <= other.end && other.end <= ri.end
-}
-
-// String returns a string representation of the interval.
-func (ri *reachabilityInterval) String() string {
-	return fmt.Sprintf("[%d,%d]", ri.start, ri.end)
-}
-
-// reachabilityTreeNode represents a node in the reachability tree
-// of some DAG block. It mainly provides the ability to query *tree*
-// reachability with O(1) query time. It does so by managing an
-// index interval for each node and making sure all nodes in its
-// subtree are indexed within the interval, so the query
-// B ∈ subtree(A) simply becomes B.interval ⊂ A.interval.
-//
-// The main challenge of maintaining such intervals is that our tree
-// is an ever-growing tree and as such pre-allocated intervals may
-// not suffice as per future events. This is where the reindexing
-// algorithm below comes into place.
-// We use the reasonable assumption that the initial root interval
-// (e.g., [0, 2^64-1]) should always suffice for any practical use-
-// case, and so reindexing should always succeed unless more than
-// 2^64 blocks are added to the DAG/tree.
-type reachabilityTreeNode struct {
-	blockNode *blockNode
-
-	children []*reachabilityTreeNode
-	parent   *reachabilityTreeNode
-
-	// interval is the index interval containing all intervals of
-	// blocks in this node's subtree
-	interval *reachabilityInterval
-
-	// remainingInterval is the not-yet allocated interval (within
-	// this node's interval) awaiting new children
-	remainingInterval *reachabilityInterval
-
-	// subtreeSize is a helper field used only during reindexing
-	// (expected to be 0 any other time).
-	// See countSubtrees for further details.
-	subtreeSize uint64
-}
-
-func newReachabilityTreeNode(blockNode *blockNode) *reachabilityTreeNode {
-	// Please see the comment above reachabilityTreeNode to understand why
-	// we use these initial values.
-	interval := newReachabilityInterval(1, math.MaxUint64-1)
-	// We subtract 1 from the end of the remaining interval to prevent the node from allocating
-	// the entire interval to its child, so its interval would *strictly* contain the interval of its child.
-	remainingInterval := newReachabilityInterval(interval.start, interval.end-1)
-	return &reachabilityTreeNode{blockNode: blockNode, interval: interval, remainingInterval: remainingInterval}
-}
-
-// addChild adds child to this tree node. If this node has no
-// remaining interval to allocate, a reindexing is triggered.
-// This method returns a list of reachabilityTreeNodes modified
-// by it.
-func (rtn *reachabilityTreeNode) addChild(child *reachabilityTreeNode) ([]*reachabilityTreeNode, error) {
-	// Set the parent-child relationship
-	rtn.children = append(rtn.children, child)
-	child.parent = rtn
-
-	// No allocation space left -- reindex
-	if rtn.remainingInterval.size() == 0 {
-		return rtn.reindexIntervals()
-	}
-
-	// Allocate from the remaining space
-	allocated, remaining, err := rtn.remainingInterval.splitInHalf()
-	if err != nil {
-		return nil, err
-	}
-	child.setInterval(allocated)
-	rtn.remainingInterval = remaining
-	return []*reachabilityTreeNode{rtn, child}, nil
-}
-
-// setInterval sets the reachability interval for this node.
-func (rtn *reachabilityTreeNode) setInterval(interval *reachabilityInterval) {
-	rtn.interval = interval
-
-	// Reserve a single interval index for the current node. This
-	// is necessary to ensure that ancestor intervals are strictly
-	// supersets of any descendant intervals and not equal
-	rtn.remainingInterval = newReachabilityInterval(interval.start, interval.end-1)
-}
-
-// reindexIntervals traverses the reachability subtree that's
-// defined by this node and reallocates reachability interval space
-// such that another reindexing is unlikely to occur shortly
-// thereafter. It does this by traversing down the reachability
-// tree until it finds a node with a subreeSize that's greater than
-// its interval size. See propagateInterval for further details.
-// This method returns a list of reachabilityTreeNodes modified by it.
-func (rtn *reachabilityTreeNode) reindexIntervals() ([]*reachabilityTreeNode, error) {
-	current := rtn
-
-	// Initial interval and subtree sizes
-	intervalSize := current.interval.size()
-	subtreeSize := current.countSubtrees()
-
-	// Find the first ancestor that has sufficient interval space
-	for intervalSize < subtreeSize {
-		if current.parent == nil {
-			// If we ended up here it means that there are more
-			// than 2^64 blocks, which shouldn't ever happen.
-			return nil, errors.Errorf("missing tree " +
-				"parent during reindexing. Theoretically, this " +
-				"should only ever happen if there are more " +
-				"than 2^64 blocks in the DAG.")
-		}
-		current = current.parent
-		intervalSize = current.interval.size()
-		subtreeSize = current.countSubtrees()
-	}
-
-	// Propagate the interval to the subtree
-	return current.propagateInterval()
-}
-
-// countSubtrees counts the size of each subtree under this node.
-// It is equivalent to the following recursive implementation:
-//
-// func (rtn *reachabilityTreeNode) countSubtrees() uint64 {
-//     subtreeSize := uint64(0)
-//     for _, child := range rtn.children {
-//         subtreeSize += child.countSubtrees()
-//     }
-//     return subtreeSize + 1
-// }
-//
-// However, we are expecting (linearly) deep trees, and so a
-// recursive stack-based approach is inefficient and will hit
-// recursion limits. Instead, the same logic was implemented
-// using a (queue-based) BFS method. At a high level, the
-// algorithm uses BFS for reaching all leaves and pushes
-// intermediate updates from leaves via parent chains until all
-// size information is gathered at the root of the operation
-// (i.e. at rtn).
-//
-// Note the role of the subtreeSize field in the algorithm.
-// For each node rtn this field is initialized to 0. The field
-// has two possible states:
-// * rtn.subtreeSize > |rtn.children|:
-//   indicates that rtn's subtree size is already known and
-//   calculated.
-// * rtn.subtreeSize <= |rtn.children|:
-//   indicates that we are still in the counting stage of
-//   tracking which of rtn's children has already calculated
-//   its subtree size.
-//   This way, once rtn.subtree_size = |rtn.children| we know we
-//   can pull subtree sizes from children and continue pushing
-//   the readiness signal further up.
-func (rtn *reachabilityTreeNode) countSubtrees() uint64 {
-	queue := []*reachabilityTreeNode{rtn}
-	for len(queue) > 0 {
-		var current *reachabilityTreeNode
-		current, queue = queue[0], queue[1:]
-		if len(current.children) == 0 {
-			// We reached a leaf
-			current.subtreeSize = 1
-		}
-		if current.subtreeSize <= uint64(len(current.children)) {
-			// We haven't yet calculated the subtree size of
-			// the current node. Add all its children to the
-			// queue
-			for _, child := range current.children {
-				queue = append(queue, child)
-			}
-			continue
-		}
-
-		// We reached a leaf or a pre-calculated subtree.
-		// Push information up
-		for current != rtn {
-			current = current.parent
-			current.subtreeSize++
-			if current.subtreeSize != uint64(len(current.children)) {
-				// Not all subtrees of the current node are ready
-				break
-			}
-			// All subtrees of current have reported readiness.
-			// Count actual subtree size and continue pushing up.
-			childSubtreeSizeSum := uint64(0)
-			for _, child := range current.children {
-				childSubtreeSizeSum += child.subtreeSize
-			}
-			current.subtreeSize = childSubtreeSizeSum + 1
-		}
-	}
-	return rtn.subtreeSize
-}
-
-// propagateInterval propagates the new interval using a BFS traversal.
-// Subtree intervals are recursively allocated according to subtree sizes and
-// the allocation rule in splitWithExponentialBias. This method returns
-// a list of reachabilityTreeNodes modified by it.
-func (rtn *reachabilityTreeNode) propagateInterval() ([]*reachabilityTreeNode, error) {
-	// We set the interval to reset its remainingInterval, so we could reallocate it while reindexing.
-	rtn.setInterval(rtn.interval)
-	modifiedNodes := []*reachabilityTreeNode{rtn}
-	queue := []*reachabilityTreeNode{rtn}
-	for len(queue) > 0 {
-		var current *reachabilityTreeNode
-		current, queue = queue[0], queue[1:]
-		if len(current.children) > 0 {
-			sizes := make([]uint64, len(current.children))
-			for i, child := range current.children {
-				sizes[i] = child.subtreeSize
-			}
-			intervals, err := current.remainingInterval.splitWithExponentialBias(sizes)
-			if err != nil {
-				return nil, err
-			}
-			for i, child := range current.children {
-				childInterval := intervals[i]
-				child.setInterval(childInterval)
-				queue = append(queue, child)
-			}
-
-			// Empty up remaining interval
-			current.remainingInterval.start = current.remainingInterval.end + 1
-		}
-
-		modifiedNodes = append(modifiedNodes, current)
-
-		// Cleanup temp info for future reindexing
-		current.subtreeSize = 0
-	}
-	return modifiedNodes, nil
-}
-
-// isAncestorOf checks if this node is a reachability tree ancestor
-// of the other node.
-func (rtn *reachabilityTreeNode) isAncestorOf(other *reachabilityTreeNode) bool {
-	return rtn.interval.isAncestorOf(other.interval)
-}
-
-// String returns a string representation of a reachability tree node
-// and its children.
-func (rtn *reachabilityTreeNode) String() string {
-	queue := []*reachabilityTreeNode{rtn}
-	lines := []string{rtn.interval.String()}
-	for len(queue) > 0 {
-		var current *reachabilityTreeNode
-		current, queue = queue[0], queue[1:]
-		if len(current.children) == 0 {
-			break
-		}
-
-		line := ""
-		for _, child := range current.children {
-			line += child.interval.String()
-			queue = append(queue, child)
-		}
-		lines = append([]string{line}, lines...)
-	}
-	return strings.Join(lines, "\n")
-}
-
-// futureCoveringBlockSet represents a collection of blocks in the future of
-// a certain block. Once a block B is added to the DAG, every block A_i in
-// B's selected parent anticone must register B in its futureCoveringBlockSet. This allows
-// to relatively quickly (O(log(|futureCoveringBlockSet|))) query whether B
-// is a descendent (is in the "future") of any block that previously
-// registered it.
-//
-// Note that futureCoveringBlockSet is meant to be queried only if B is not
-// a reachability tree descendant of the block in question, as reachability
-// tree queries are always O(1).
-//
-// See insertBlock, isInFuture, and dag.isAncestorOf for further details.
-type futureCoveringBlockSet []*futureCoveringBlock
-
-// futureCoveringBlock represents a block in the future of some other block.
-type futureCoveringBlock struct {
-	blockNode *blockNode
-	treeNode  *reachabilityTreeNode
-}
-
-// insertBlock inserts the given block into this futureCoveringBlockSet
-// while keeping futureCoveringBlockSet ordered by interval.
-// If a block B ∈ futureCoveringBlockSet exists such that its interval
-// contains block's interval, block need not be added. If block's
-// interval contains B's interval, it replaces it.
-//
-// Notes:
-// * Intervals never intersect unless one contains the other
-//   (this follows from the tree structure and the indexing rule).
-// * Since futureCoveringBlockSet is kept ordered, a binary search can be
-//   used for insertion/queries.
-// * Although reindexing may change a block's interval, the
-//   is-superset relation will by definition
-//   be always preserved.
-func (fb *futureCoveringBlockSet) insertBlock(block *futureCoveringBlock) {
-	blockInterval := block.treeNode.interval
-	i := fb.findIndex(block)
-	if i > 0 {
-		candidate := (*fb)[i-1]
-		candidateInterval := candidate.treeNode.interval
-		if candidateInterval.isAncestorOf(blockInterval) {
-			// candidate is an ancestor of block, no need to insert
-			return
-		}
-		if blockInterval.isAncestorOf(candidateInterval) {
-			// block is an ancestor of candidate, and can thus replace it
-			(*fb)[i-1] = block
-			return
-		}
-	}
-
-	// Insert block in the correct index to maintain futureCoveringBlockSet as
-	// a sorted-by-interval list.
-	// Note that i might be equal to len(futureCoveringBlockSet)
-	left := (*fb)[:i]
-	right := append([]*futureCoveringBlock{block}, (*fb)[i:]...)
-	*fb = append(left, right...)
-}
-
-// isInFuture resolves whether the given block is in the subtree of
-// any block in this futureCoveringBlockSet.
-// See insertBlock method for the complementary insertion behavior.
-//
-// Like the insert method, this method also relies on the fact that
-// futureCoveringBlockSet is kept ordered by interval to efficiently perform a
-// binary search over futureCoveringBlockSet and answer the query in
-// O(log(|futureCoveringBlockSet|)).
-func (fb futureCoveringBlockSet) isInFuture(block *futureCoveringBlock) bool {
-	i := fb.findIndex(block)
-	if i == 0 {
-		// No candidate to contain block
-		return false
-	}
-
-	candidate := fb[i-1]
-	return candidate.treeNode.isAncestorOf(block.treeNode)
-}
-
-// findIndex finds the index of the block with the maximum start that is below
-// the given block.
-func (fb futureCoveringBlockSet) findIndex(block *futureCoveringBlock) int {
-	blockInterval := block.treeNode.interval
-	end := blockInterval.end
-
-	low := 0
-	high := len(fb)
-	for low < high {
-		middle := (low + high) / 2
-		middleInterval := fb[middle].treeNode.interval
-		if end < middleInterval.start {
-			high = middle
-		} else {
-			low = middle + 1
-		}
-	}
-	return low
-}
-
-// String returns a string representation of the intervals in this futureCoveringBlockSet.
-func (fb futureCoveringBlockSet) String() string {
-	intervalsString := ""
-	for _, block := range fb {
-		intervalsString += block.treeNode.interval.String()
-	}
-	return intervalsString
-}
-
-func (dag *BlockDAG) updateReachability(node *blockNode, selectedParentAnticone []*blockNode) error {
-	// Allocate a new reachability tree node
-	newTreeNode := newReachabilityTreeNode(node)
-
-	// If this is the genesis node, simply initialize it and return
-	if node.isGenesis() {
-		return dag.reachabilityStore.setTreeNode(newTreeNode)
-	}
-
-	// Insert the node into the selected parent's reachability tree
-	selectedParentTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(node.selectedParent)
-	if err != nil {
-		return err
-	}
-	modifiedTreeNodes, err := selectedParentTreeNode.addChild(newTreeNode)
-	if err != nil {
-		return err
-	}
-	for _, modifiedTreeNode := range modifiedTreeNodes {
-		err = dag.reachabilityStore.setTreeNode(modifiedTreeNode)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Add the block to the futureCoveringSets of all the blocks
-	// in the selected parent's anticone
-	for _, current := range selectedParentAnticone {
-		currentFutureCoveringSet, err := dag.reachabilityStore.futureCoveringSetByBlockNode(current)
-		if err != nil {
-			return err
-		}
-		currentFutureCoveringSet.insertBlock(&futureCoveringBlock{blockNode: node, treeNode: newTreeNode})
-		err = dag.reachabilityStore.setFutureCoveringSet(current, currentFutureCoveringSet)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// isAncestorOf returns true if this node is in the past of the other node
-// in the DAG. The complexity of this method is O(log(|this.futureCoveringBlockSet|))
-func (dag *BlockDAG) isAncestorOf(this *blockNode, other *blockNode) (bool, error) {
-	// First, check if this node is a reachability tree ancestor of the
-	// other node
-	thisTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(this)
-	if err != nil {
-		return false, err
-	}
-	otherTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(other)
-	if err != nil {
-		return false, err
-	}
-	if thisTreeNode.isAncestorOf(otherTreeNode) {
-		return true, nil
-	}
-
-	// Otherwise, use previously registered future blocks to complete the
-	// reachability test
-	thisFutureCoveringSet, err := dag.reachabilityStore.futureCoveringSetByBlockNode(this)
-	if err != nil {
-		return false, err
-	}
-	return thisFutureCoveringSet.isInFuture(&futureCoveringBlock{blockNode: other, treeNode: otherTreeNode}), nil
-}

blockdag/reachability_test.go

@@ -1,475 +0,0 @@
-package blockdag
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestAddChild(t *testing.T) {
-	// Scenario 1: test addChild in a chain
-	//             root -> a -> b -> c...
-	// Create the root node of a new reachability tree
-	root := newReachabilityTreeNode(&blockNode{})
-	root.setInterval(newReachabilityInterval(1, 100))
-
-	// Add a chain of child nodes just before a reindex occurs (2^6=64 < 100)
-	currentTip := root
-	for i := 0; i < 6; i++ {
-		node := newReachabilityTreeNode(&blockNode{})
-		modifiedNodes, err := currentTip.addChild(node)
-		if err != nil {
-			t.Fatalf("TestAddChild: addChild failed: %s", err)
-		}
-
-		// Expect only the node and its parent to be affected
-		expectedModifiedNodes := []*reachabilityTreeNode{currentTip, node}
-		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
-			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
-				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
-		}
-
-		currentTip = node
-	}
-
-	// Add another node to the tip of the chain to trigger a reindex (100 < 2^7=128)
-	lastChild := newReachabilityTreeNode(&blockNode{})
-	modifiedNodes, err := currentTip.addChild(lastChild)
-	if err != nil {
-		t.Fatalf("TestAddChild: addChild failed: %s", err)
-	}
-
-	// Expect more than just the node and its parent to be modified but not
-	// all the nodes
-	if len(modifiedNodes) <= 2 && len(modifiedNodes) >= 7 {
-		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
-	}
-
-	// Expect the tip to have an interval of 1 and remaining interval of 0
-	tipInterval := lastChild.interval.size()
-	if tipInterval != 1 {
-		t.Fatalf("TestAddChild: unexpected tip interval size: want: 1, got: %d", tipInterval)
-	}
-	tipRemainingInterval := lastChild.remainingInterval.size()
-	if tipRemainingInterval != 0 {
-		t.Fatalf("TestAddChild: unexpected tip interval size: want: 0, got: %d", tipRemainingInterval)
-	}
-
-	// Expect all nodes to be descendant nodes of root
-	currentNode := currentTip
-	for currentNode != nil {
-		if !root.isAncestorOf(currentNode) {
-			t.Fatalf("TestAddChild: currentNode is not a descendant of root")
-		}
-		currentNode = currentNode.parent
-	}
-
-	// Scenario 2: test addChild where all nodes are direct descendants of root
-	//             root -> a, b, c...
-	// Create the root node of a new reachability tree
-	root = newReachabilityTreeNode(&blockNode{})
-	root.setInterval(newReachabilityInterval(1, 100))
-
-	// Add child nodes to root just before a reindex occurs (2^6=64 < 100)
-	childNodes := make([]*reachabilityTreeNode, 6)
-	for i := 0; i < len(childNodes); i++ {
-		childNodes[i] = newReachabilityTreeNode(&blockNode{})
-		modifiedNodes, err := root.addChild(childNodes[i])
-		if err != nil {
-			t.Fatalf("TestAddChild: addChild failed: %s", err)
-		}
-
-		// Expect only the node and the root to be affected
-		expectedModifiedNodes := []*reachabilityTreeNode{root, childNodes[i]}
-		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
-			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
-				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
-		}
-	}
-
-	// Add another node to the root to trigger a reindex (100 < 2^7=128)
-	lastChild = newReachabilityTreeNode(&blockNode{})
-	modifiedNodes, err = root.addChild(lastChild)
-	if err != nil {
-		t.Fatalf("TestAddChild: addChild failed: %s", err)
-	}
-
-	// Expect more than just the node and the root to be modified but not
-	// all the nodes
-	if len(modifiedNodes) <= 2 && len(modifiedNodes) >= 7 {
-		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
-	}
-
-	// Expect the last-added child to have an interval of 1 and remaining interval of 0
-	lastChildInterval := lastChild.interval.size()
-	if lastChildInterval != 1 {
-		t.Fatalf("TestAddChild: unexpected lastChild interval size: want: 1, got: %d", lastChildInterval)
-	}
-	lastChildRemainingInterval := lastChild.remainingInterval.size()
-	if lastChildRemainingInterval != 0 {
-		t.Fatalf("TestAddChild: unexpected lastChild interval size: want: 0, got: %d", lastChildRemainingInterval)
-	}
-
-	// Expect all nodes to be descendant nodes of root
-	for _, childNode := range childNodes {
-		if !root.isAncestorOf(childNode) {
-			t.Fatalf("TestAddChild: childNode is not a descendant of root")
-		}
-	}
-}
-
-func TestSplitFraction(t *testing.T) {
-	tests := []struct {
-		interval      *reachabilityInterval
-		fraction      float64
-		expectedLeft  *reachabilityInterval
-		expectedRight *reachabilityInterval
-	}{
-		{
-			interval:      newReachabilityInterval(1, 100),
-			fraction:      0.5,
-			expectedLeft:  newReachabilityInterval(1, 50),
-			expectedRight: newReachabilityInterval(51, 100),
-		},
-		{
-			interval:      newReachabilityInterval(2, 100),
-			fraction:      0.5,
-			expectedLeft:  newReachabilityInterval(2, 51),
-			expectedRight: newReachabilityInterval(52, 100),
-		},
-		{
-			interval:      newReachabilityInterval(1, 99),
-			fraction:      0.5,
-			expectedLeft:  newReachabilityInterval(1, 50),
-			expectedRight: newReachabilityInterval(51, 99),
-		},
-		{
-			interval:      newReachabilityInterval(1, 100),
-			fraction:      0.2,
-			expectedLeft:  newReachabilityInterval(1, 20),
-			expectedRight: newReachabilityInterval(21, 100),
-		},
-		{
-			interval:      newReachabilityInterval(1, 100),
-			fraction:      0,
-			expectedLeft:  newReachabilityInterval(1, 0),
-			expectedRight: newReachabilityInterval(1, 100),
-		},
-		{
-			interval:      newReachabilityInterval(1, 100),
-			fraction:      1,
-			expectedLeft:  newReachabilityInterval(1, 100),
-			expectedRight: newReachabilityInterval(101, 100),
-		},
-	}
-
-	for i, test := range tests {
-		left, right, err := test.interval.splitFraction(test.fraction)
-		if err != nil {
-			t.Fatalf("TestSplitFraction: splitFraction unexpectedly failed in test #%d: %s", i, err)
-		}
-		if !reflect.DeepEqual(left, test.expectedLeft) {
-			t.Errorf("TestSplitFraction: unexpected left in test #%d. "+
-				"want: %s, got: %s", i, test.expectedLeft, left)
-		}
-		if !reflect.DeepEqual(right, test.expectedRight) {
-			t.Errorf("TestSplitFraction: unexpected right in test #%d. "+
-				"want: %s, got: %s", i, test.expectedRight, right)
-		}
-	}
-}
-
-func TestSplitExact(t *testing.T) {
-	tests := []struct {
-		interval          *reachabilityInterval
-		sizes             []uint64
-		expectedIntervals []*reachabilityInterval
-	}{
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{100},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{50, 50},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 50),
-				newReachabilityInterval(51, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{10, 20, 30, 40},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 10),
-				newReachabilityInterval(11, 30),
-				newReachabilityInterval(31, 60),
-				newReachabilityInterval(61, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{0, 100},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 0),
-				newReachabilityInterval(1, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{100, 0},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 100),
-				newReachabilityInterval(101, 100),
-			},
-		},
-	}
-
-	for i, test := range tests {
-		intervals, err := test.interval.splitExact(test.sizes)
-		if err != nil {
-			t.Fatalf("TestSplitExact: splitExact unexpectedly failed in test #%d: %s", i, err)
-		}
-		if !reflect.DeepEqual(intervals, test.expectedIntervals) {
-			t.Errorf("TestSplitExact: unexpected intervals in test #%d. "+
-				"want: %s, got: %s", i, test.expectedIntervals, intervals)
-		}
-	}
-}
-
-func TestSplitWithExponentialBias(t *testing.T) {
-	tests := []struct {
-		interval          *reachabilityInterval
-		sizes             []uint64
-		expectedIntervals []*reachabilityInterval
-	}{
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{100},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{50, 50},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 50),
-				newReachabilityInterval(51, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{10, 20, 30, 40},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 10),
-				newReachabilityInterval(11, 30),
-				newReachabilityInterval(31, 60),
-				newReachabilityInterval(61, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{25, 25},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 50),
-				newReachabilityInterval(51, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{1, 1},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 50),
-				newReachabilityInterval(51, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{33, 33, 33},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 33),
-				newReachabilityInterval(34, 66),
-				newReachabilityInterval(67, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{10, 15, 25},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 10),
-				newReachabilityInterval(11, 25),
-				newReachabilityInterval(26, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 100),
-			sizes:    []uint64{25, 15, 10},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 75),
-				newReachabilityInterval(76, 90),
-				newReachabilityInterval(91, 100),
-			},
-		},
-		{
-			interval: newReachabilityInterval(1, 10_000),
-			sizes:    []uint64{10, 10, 20},
-			expectedIntervals: []*reachabilityInterval{
-				newReachabilityInterval(1, 20),
-				newReachabilityInterval(21, 40),
-				newReachabilityInterval(41, 10_000),
-			},
-		},
-	}
-
-	for i, test := range tests {
-		intervals, err := test.interval.splitWithExponentialBias(test.sizes)
-		if err != nil {
-			t.Fatalf("TestSplitWithExponentialBias: splitWithExponentialBias unexpectedly failed in test #%d: %s", i, err)
-		}
-		if !reflect.DeepEqual(intervals, test.expectedIntervals) {
-			t.Errorf("TestSplitWithExponentialBias: unexpected intervals in test #%d. "+
-				"want: %s, got: %s", i, test.expectedIntervals, intervals)
-		}
-	}
-}
-
-func TestIsInFuture(t *testing.T) {
-	blocks := futureCoveringBlockSet{
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(2, 3)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-	}
-
-	tests := []struct {
-		block          *futureCoveringBlock
-		expectedResult bool
-	}{
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 1)}},
-			expectedResult: false,
-		},
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
-			expectedResult: true,
-		},
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 76)}},
-			expectedResult: true,
-		},
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(78, 100)}},
-			expectedResult: false,
-		},
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1980, 2000)}},
-			expectedResult: false,
-		},
-		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1920)}},
-			expectedResult: true,
-		},
-	}
-
-	for i, test := range tests {
-		result := blocks.isInFuture(test.block)
-		if result != test.expectedResult {
-			t.Errorf("TestIsInFuture: unexpected result in test #%d. Want: %t, got: %t",
-				i, test.expectedResult, result)
-		}
-	}
-}
-
-func TestInsertBlock(t *testing.T) {
-	blocks := futureCoveringBlockSet{
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-	}
-
-	tests := []struct {
-		toInsert       []*futureCoveringBlock
-		expectedResult futureCoveringBlockSet
-	}{
-		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
-			},
-			expectedResult: futureCoveringBlockSet{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-			},
-		},
-		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(65, 78)}},
-			},
-			expectedResult: futureCoveringBlockSet{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(65, 78)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-			},
-		},
-		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
-			},
-			expectedResult: futureCoveringBlockSet{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-			},
-		},
-		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(3000, 3010)}},
-			},
-			expectedResult: futureCoveringBlockSet{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(3000, 3010)}},
-			},
-		},
-	}
-
-	for i, test := range tests {
-		// Create a clone of blocks so that we have a clean start for every test
-		blocksClone := make(futureCoveringBlockSet, len(blocks))
-		for i, block := range blocks {
-			blocksClone[i] = block
-		}
-
-		for _, block := range test.toInsert {
-			blocksClone.insertBlock(block)
-		}
-		if !reflect.DeepEqual(blocksClone, test.expectedResult) {
-			t.Errorf("TestInsertBlock: unexpected result in test #%d. Want: %s, got: %s",
-				i, test.expectedResult, blocksClone)
-		}
-	}
-}

blockdag/test_utils_test.go

@@ -1,14 +0,0 @@
-package blockdag
-
-import (
-	"testing"
-)
-
-func TestIsSupportedDbType(t *testing.T) {
-	if !isSupportedDbType("ffldb") {
-		t.Errorf("ffldb should be a supported DB driver")
-	}
-	if isSupportedDbType("madeUpDb") {
-		t.Errorf("madeUpDb should not be a supported DB driver")
-	}
-}

blockdag/thresholdstate.go

@@ -1,358 +0,0 @@
-// Copyright (c) 2016-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"fmt"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// ThresholdState define the various threshold states used when voting on
-// consensus changes.
-type ThresholdState byte
-
-// These constants are used to identify specific threshold states.
-const (
-	// ThresholdDefined is the first state for each deployment and is the
-	// state for the genesis block has by definition for all deployments.
-	ThresholdDefined ThresholdState = iota
-
-	// ThresholdStarted is the state for a deployment once its start time
-	// has been reached.
-	ThresholdStarted
-
-	// ThresholdLockedIn is the state for a deployment during the retarget
-	// period which is after the ThresholdStarted state period and the
-	// number of blocks that have voted for the deployment equal or exceed
-	// the required number of votes for the deployment.
-	ThresholdLockedIn
-
-	// ThresholdActive is the state for a deployment for all blocks after a
-	// retarget period in which the deployment was in the ThresholdLockedIn
-	// state.
-	ThresholdActive
-
-	// ThresholdFailed is the state for a deployment once its expiration
-	// time has been reached and it did not reach the ThresholdLockedIn
-	// state.
-	ThresholdFailed
-
-	// numThresholdsStates is the maximum number of threshold states used in
-	// tests.
-	numThresholdsStates
-)
-
-// thresholdStateStrings is a map of ThresholdState values back to their
-// constant names for pretty printing.
-var thresholdStateStrings = map[ThresholdState]string{
-	ThresholdDefined:  "ThresholdDefined",
-	ThresholdStarted:  "ThresholdStarted",
-	ThresholdLockedIn: "ThresholdLockedIn",
-	ThresholdActive:   "ThresholdActive",
-	ThresholdFailed:   "ThresholdFailed",
-}
-
-// String returns the ThresholdState as a human-readable name.
-func (t ThresholdState) String() string {
-	if s := thresholdStateStrings[t]; s != "" {
-		return s
-	}
-	return fmt.Sprintf("Unknown ThresholdState (%d)", int(t))
-}
-
-// thresholdConditionChecker provides a generic interface that is invoked to
-// determine when a consensus rule change threshold should be changed.
-type thresholdConditionChecker interface {
-	// BeginTime returns the unix timestamp for the median block time after
-	// which voting on a rule change starts (at the next window).
-	BeginTime() uint64
-
-	// EndTime returns the unix timestamp for the median block time after
-	// which an attempted rule change fails if it has not already been
-	// locked in or activated.
-	EndTime() uint64
-
-	// RuleChangeActivationThreshold is the number of blocks for which the
-	// condition must be true in order to lock in a rule change.
-	RuleChangeActivationThreshold() uint64
-
-	// MinerConfirmationWindow is the number of blocks in each threshold
-	// state retarget window.
-	MinerConfirmationWindow() uint64
-
-	// Condition returns whether or not the rule change activation condition
-	// has been met. This typically involves checking whether or not the
-	// bit associated with the condition is set, but can be more complex as
-	// needed.
-	Condition(*blockNode) (bool, error)
-}
-
-// thresholdStateCache provides a type to cache the threshold states of each
-// threshold window for a set of IDs.
-type thresholdStateCache struct {
-	entries map[daghash.Hash]ThresholdState
-}
-
-// Lookup returns the threshold state associated with the given hash along with
-// a boolean that indicates whether or not it is valid.
-func (c *thresholdStateCache) Lookup(hash *daghash.Hash) (ThresholdState, bool) {
-	state, ok := c.entries[*hash]
-	return state, ok
-}
-
-// Update updates the cache to contain the provided hash to threshold state
-// mapping.
-func (c *thresholdStateCache) Update(hash *daghash.Hash, state ThresholdState) {
-	c.entries[*hash] = state
-}
-
-// newThresholdCaches returns a new array of caches to be used when calculating
-// threshold states.
-func newThresholdCaches(numCaches uint32) []thresholdStateCache {
-	caches := make([]thresholdStateCache, numCaches)
-	for i := 0; i < len(caches); i++ {
-		caches[i] = thresholdStateCache{
-			entries: make(map[daghash.Hash]ThresholdState),
-		}
-	}
-	return caches
-}
-
-// thresholdState returns the current rule change threshold state for the block
-// AFTER the given node and deployment ID. The cache is used to ensure the
-// threshold states for previous windows are only calculated once.
-//
-// This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdConditionChecker, cache *thresholdStateCache) (ThresholdState, error) {
-	// The threshold state for the window that contains the genesis block is
-	// defined by definition.
-	confirmationWindow := checker.MinerConfirmationWindow()
-	if prevNode == nil || (prevNode.blueScore+1) < confirmationWindow {
-		return ThresholdDefined, nil
-	}
-
-	// Get the ancestor that is the last block of the previous confirmation
-	// window in order to get its threshold state. This can be done because
-	// the state is the same for all blocks within a given window.
-	prevNode = prevNode.SelectedAncestor(prevNode.blueScore -
-		(prevNode.blueScore+1)%confirmationWindow)
-
-	// Iterate backwards through each of the previous confirmation windows
-	// to find the most recently cached threshold state.
-	var neededStates []*blockNode
-	for prevNode != nil {
-		// Nothing more to do if the state of the block is already
-		// cached.
-		if _, ok := cache.Lookup(prevNode.hash); ok {
-			break
-		}
-
-		// The start and expiration times are based on the median block
-		// time, so calculate it now.
-		medianTime := prevNode.PastMedianTime(dag)
-
-		// The state is simply defined if the start time hasn't been
-		// been reached yet.
-		if uint64(medianTime.Unix()) < checker.BeginTime() {
-			cache.Update(prevNode.hash, ThresholdDefined)
-			break
-		}
-
-		// Add this node to the list of nodes that need the state
-		// calculated and cached.
-		neededStates = append(neededStates, prevNode)
-
-		// Get the ancestor that is the last block of the previous
-		// confirmation window.
-		prevNode = prevNode.RelativeAncestor(confirmationWindow)
-	}
-
-	// Start with the threshold state for the most recent confirmation
-	// window that has a cached state.
-	state := ThresholdDefined
-	if prevNode != nil {
-		var ok bool
-		state, ok = cache.Lookup(prevNode.hash)
-		if !ok {
-			return ThresholdFailed, AssertError(fmt.Sprintf(
-				"thresholdState: cache lookup failed for %s",
-				prevNode.hash))
-		}
-	}
-
-	// Since each threshold state depends on the state of the previous
-	// window, iterate starting from the oldest unknown window.
-	for neededNum := len(neededStates) - 1; neededNum >= 0; neededNum-- {
-		prevNode := neededStates[neededNum]
-
-		switch state {
-		case ThresholdDefined:
-			// The deployment of the rule change fails if it expires
-			// before it is accepted and locked in.
-			medianTime := prevNode.PastMedianTime(dag)
-			medianTimeUnix := uint64(medianTime.Unix())
-			if medianTimeUnix >= checker.EndTime() {
-				state = ThresholdFailed
-				break
-			}
-
-			// The state for the rule moves to the started state
-			// once its start time has been reached (and it hasn't
-			// already expired per the above).
-			if medianTimeUnix >= checker.BeginTime() {
-				state = ThresholdStarted
-			}
-
-		case ThresholdStarted:
-			// The deployment of the rule change fails if it expires
-			// before it is accepted and locked in.
-			medianTime := prevNode.PastMedianTime(dag)
-			if uint64(medianTime.Unix()) >= checker.EndTime() {
-				state = ThresholdFailed
-				break
-			}
-
-			// At this point, the rule change is still being voted
-			// on by the miners, so iterate backwards through the
-			// confirmation window to count all of the votes in it.
-			var count uint64
-			windowNodes := make([]*blockNode, 0, confirmationWindow)
-			windowNodes = append(windowNodes, prevNode)
-			windowNodes = append(windowNodes, blueBlockWindow(prevNode, confirmationWindow-1)...)
-			for _, current := range windowNodes {
-				condition, err := checker.Condition(current)
-				if err != nil {
-					return ThresholdFailed, err
-				}
-				if condition {
-					count++
-				}
-
-				// Get the previous block node.
-				current = current.selectedParent
-			}
-
-			// The state is locked in if the number of blocks in the
-			// period that voted for the rule change meets the
-			// activation threshold.
-			if count >= checker.RuleChangeActivationThreshold() {
-				state = ThresholdLockedIn
-			}
-
-		case ThresholdLockedIn:
-			// The new rule becomes active when its previous state
-			// was locked in.
-			state = ThresholdActive
-
-			// Nothing to do if the previous state is active or failed since
-			// they are both terminal states.
-		case ThresholdActive:
-		case ThresholdFailed:
-		}
-
-		// Update the cache to avoid recalculating the state in the
-		// future.
-		cache.Update(prevNode.hash, state)
-	}
-
-	return state, nil
-}
-
-// ThresholdState returns the current rule change threshold state of the given
-// deployment ID for the block AFTER the blueScore of the current DAG.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) ThresholdState(deploymentID uint32) (ThresholdState, error) {
-	dag.dagLock.Lock()
-	defer dag.dagLock.Unlock()
-	state, err := dag.deploymentState(dag.selectedTip(), deploymentID)
-
-	return state, err
-}
-
-// IsDeploymentActive returns true if the target deploymentID is active, and
-// false otherwise.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) IsDeploymentActive(deploymentID uint32) (bool, error) {
-	dag.dagLock.Lock()
-	defer dag.dagLock.Unlock()
-	state, err := dag.deploymentState(dag.selectedTip(), deploymentID)
-	if err != nil {
-		return false, err
-	}
-
-	return state == ThresholdActive, nil
-}
-
-// deploymentState returns the current rule change threshold for a given
-// deploymentID. The threshold is evaluated from the point of view of the block
-// node passed in as the first argument to this method.
-//
-// It is important to note that, as the variable name indicates, this function
-// expects the block node prior to the block for which the deployment state is
-// desired. In other words, the returned deployment state is for the block
-// AFTER the passed node.
-//
-// This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) deploymentState(prevNode *blockNode, deploymentID uint32) (ThresholdState, error) {
-	if deploymentID > uint32(len(dag.dagParams.Deployments)) {
-		return ThresholdFailed, DeploymentError(deploymentID)
-	}
-
-	deployment := &dag.dagParams.Deployments[deploymentID]
-	checker := deploymentChecker{deployment: deployment, dag: dag}
-	cache := &dag.deploymentCaches[deploymentID]
-
-	return dag.thresholdState(prevNode, checker, cache)
-}
-
-// initThresholdCaches initializes the threshold state caches for each warning
-// bit and defined deployment and provides warnings if the DAG is current per
-// the warnUnknownVersions and warnUnknownRuleActivations functions.
-func (dag *BlockDAG) initThresholdCaches() error {
-	// Initialize the warning and deployment caches by calculating the
-	// threshold state for each of them. This will ensure the caches are
-	// populated and any states that needed to be recalculated due to
-	// definition changes is done now.
-	prevNode := dag.selectedTip().selectedParent
-	for bit := uint32(0); bit < vbNumBits; bit++ {
-		checker := bitConditionChecker{bit: bit, dag: dag}
-		cache := &dag.warningCaches[bit]
-		_, err := dag.thresholdState(prevNode, checker, cache)
-		if err != nil {
-			return err
-		}
-	}
-	for id := 0; id < len(dag.dagParams.Deployments); id++ {
-		deployment := &dag.dagParams.Deployments[id]
-		cache := &dag.deploymentCaches[id]
-		checker := deploymentChecker{deployment: deployment, dag: dag}
-		_, err := dag.thresholdState(prevNode, checker, cache)
-		if err != nil {
-			return err
-		}
-	}
-
-	// No warnings about unknown rules or versions until the DAG is
-	// current.
-	if dag.isCurrent() {
-		// Warn if a high enough percentage of the last blocks have
-		// unexpected versions.
-		bestNode := dag.selectedTip()
-		if err := dag.warnUnknownVersions(bestNode); err != nil {
-			return err
-		}
-
-		// Warn if any unknown new rules are either about to activate or
-		// have already been activated.
-		if err := dag.warnUnknownRuleActivations(bestNode); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

blockdag/thresholdstate_test.go

@@ -1,134 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"testing"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// TestThresholdStateStringer tests the stringized output for the
-// ThresholdState type.
-func TestThresholdStateStringer(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		in   ThresholdState
-		want string
-	}{
-		{ThresholdDefined, "ThresholdDefined"},
-		{ThresholdStarted, "ThresholdStarted"},
-		{ThresholdLockedIn, "ThresholdLockedIn"},
-		{ThresholdActive, "ThresholdActive"},
-		{ThresholdFailed, "ThresholdFailed"},
-		{0xff, "Unknown ThresholdState (255)"},
-	}
-
-	// Detect additional threshold states that don't have the stringer added.
-	if len(tests)-1 != int(numThresholdsStates) {
-		t.Errorf("It appears a threshold statewas added without " +
-			"adding an associated stringer test")
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		result := test.in.String()
-		if result != test.want {
-			t.Errorf("String #%d\n got: %s want: %s", i, result,
-				test.want)
-			continue
-		}
-	}
-}
-
-// TestThresholdStateCache ensure the threshold state cache works as intended
-// including adding entries, updating existing entries, and flushing.
-func TestThresholdStateCache(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name       string
-		numEntries int
-		state      ThresholdState
-	}{
-		{name: "2 entries defined", numEntries: 2, state: ThresholdDefined},
-		{name: "7 entries started", numEntries: 7, state: ThresholdStarted},
-		{name: "10 entries active", numEntries: 10, state: ThresholdActive},
-		{name: "5 entries locked in", numEntries: 5, state: ThresholdLockedIn},
-		{name: "3 entries failed", numEntries: 3, state: ThresholdFailed},
-	}
-
-nextTest:
-	for _, test := range tests {
-		cache := &newThresholdCaches(1)[0]
-		for i := 0; i < test.numEntries; i++ {
-			var hash daghash.Hash
-			hash[0] = uint8(i + 1)
-
-			// Ensure the hash isn't available in the cache already.
-			_, ok := cache.Lookup(&hash)
-			if ok {
-				t.Errorf("Lookup (%s): has entry for hash %v",
-					test.name, hash)
-				continue nextTest
-			}
-
-			// Ensure hash that was added to the cache reports it's
-			// available and the state is the expected value.
-			cache.Update(&hash, test.state)
-			state, ok := cache.Lookup(&hash)
-			if !ok {
-				t.Errorf("Lookup (%s): missing entry for hash "+
-					"%v", test.name, hash)
-				continue nextTest
-			}
-			if state != test.state {
-				t.Errorf("Lookup (%s): state mismatch - got "+
-					"%v, want %v", test.name, state,
-					test.state)
-				continue nextTest
-			}
-
-			// Ensure adding an existing hash with the same state
-			// doesn't break the existing entry.
-			cache.Update(&hash, test.state)
-			state, ok = cache.Lookup(&hash)
-			if !ok {
-				t.Errorf("Lookup (%s): missing entry after "+
-					"second add for hash %v", test.name,
-					hash)
-				continue nextTest
-			}
-			if state != test.state {
-				t.Errorf("Lookup (%s): state mismatch after "+
-					"second add - got %v, want %v",
-					test.name, state, test.state)
-				continue nextTest
-			}
-
-			// Ensure adding an existing hash with a different state
-			// updates the existing entry.
-			newState := ThresholdFailed
-			if newState == test.state {
-				newState = ThresholdStarted
-			}
-			cache.Update(&hash, newState)
-			state, ok = cache.Lookup(&hash)
-			if !ok {
-				t.Errorf("Lookup (%s): missing entry after "+
-					"state change for hash %v", test.name,
-					hash)
-				continue nextTest
-			}
-			if state != newState {
-				t.Errorf("Lookup (%s): state mismatch after "+
-					"state change - got %v, want %v",
-					test.name, state, newState)
-				continue nextTest
-			}
-		}
-	}
-}

blockdag/utxo_ecmh.go

@@ -1,32 +0,0 @@
-package blockdag
-
-import (
-	"bytes"
-	"github.com/golang/groupcache/lru"
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const ecmhCacheSize = 4_000_000
-
-var (
-	utxoToECMHCache = lru.New(ecmhCacheSize)
-)
-
-func utxoMultiset(entry *UTXOEntry, outpoint *wire.Outpoint) (*ecc.Multiset, error) {
-	w := &bytes.Buffer{}
-	err := serializeUTXO(w, entry, outpoint)
-	if err != nil {
-		return nil, err
-	}
-	serializedUTXO := w.Bytes()
-	utxoHash := daghash.DoubleHashH(serializedUTXO)
-
-	if cachedMSPoint, ok := utxoToECMHCache.Get(utxoHash); ok {
-		return cachedMSPoint.(*ecc.Multiset), nil
-	}
-	msPoint := ecc.NewMultiset(ecc.S256()).Add(serializedUTXO)
-	utxoToECMHCache.Add(utxoHash, msPoint)
-	return msPoint, nil
-}

blockdag/utxodiffstore.go

@@ -1,207 +0,0 @@
-package blockdag
-
-import (
-	"bytes"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/locks"
-	"github.com/pkg/errors"
-)
-
-var multisetPointSize = 32
-
-type blockUTXODiffData struct {
-	diff      *UTXODiff
-	diffChild *blockNode
-}
-
-type utxoDiffStore struct {
-	dag    *BlockDAG
-	dirty  map[daghash.Hash]struct{}
-	loaded map[daghash.Hash]*blockUTXODiffData
-	mtx    *locks.PriorityMutex
-}
-
-func newUTXODiffStore(dag *BlockDAG) *utxoDiffStore {
-	return &utxoDiffStore{
-		dag:    dag,
-		dirty:  make(map[daghash.Hash]struct{}),
-		loaded: make(map[daghash.Hash]*blockUTXODiffData),
-		mtx:    locks.NewPriorityMutex(),
-	}
-}
-
-func (diffStore *utxoDiffStore) setBlockDiff(node *blockNode, diff *UTXODiff) error {
-	diffStore.mtx.HighPriorityWriteLock()
-	defer diffStore.mtx.HighPriorityWriteUnlock()
-	// load the diff data from DB to diffStore.loaded
-	_, exists, err := diffStore.diffDataByHash(node.hash)
-	if err != nil {
-		return err
-	}
-	if !exists {
-		diffStore.loaded[*node.hash] = &blockUTXODiffData{}
-	}
-
-	diffStore.loaded[*node.hash].diff = diff
-	diffStore.setBlockAsDirty(node.hash)
-	return nil
-}
-
-func (diffStore *utxoDiffStore) setBlockDiffChild(node *blockNode, diffChild *blockNode) error {
-	diffStore.mtx.HighPriorityWriteLock()
-	defer diffStore.mtx.HighPriorityWriteUnlock()
-	// load the diff data from DB to diffStore.loaded
-	_, exists, err := diffStore.diffDataByHash(node.hash)
-	if err != nil {
-		return err
-	}
-	if !exists {
-		return diffNotFoundError(node)
-	}
-
-	diffStore.loaded[*node.hash].diffChild = diffChild
-	diffStore.setBlockAsDirty(node.hash)
-	return nil
-}
-
-func (diffStore *utxoDiffStore) removeBlocksDiffData(dbTx database.Tx, blockHashes []*daghash.Hash) error {
-	for _, hash := range blockHashes {
-		err := diffStore.removeBlockDiffData(dbTx, hash)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (diffStore *utxoDiffStore) removeBlockDiffData(dbTx database.Tx, blockHash *daghash.Hash) error {
-	diffStore.mtx.LowPriorityWriteLock()
-	defer diffStore.mtx.LowPriorityWriteUnlock()
-	delete(diffStore.loaded, *blockHash)
-	err := dbRemoveDiffData(dbTx, blockHash)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (diffStore *utxoDiffStore) setBlockAsDirty(blockHash *daghash.Hash) {
-	diffStore.dirty[*blockHash] = struct{}{}
-}
-
-func (diffStore *utxoDiffStore) diffDataByHash(hash *daghash.Hash) (*blockUTXODiffData, bool, error) {
-	if diffData, ok := diffStore.loaded[*hash]; ok {
-		return diffData, true, nil
-	}
-	diffData, err := diffStore.diffDataFromDB(hash)
-	if err != nil {
-		return nil, false, err
-	}
-	exists := diffData != nil
-	if exists {
-		diffStore.loaded[*hash] = diffData
-	}
-	return diffData, exists, nil
-}
-
-func diffNotFoundError(node *blockNode) error {
-	return errors.Errorf("Couldn't find diff data for block %s", node.hash)
-}
-
-func (diffStore *utxoDiffStore) diffByNode(node *blockNode) (*UTXODiff, error) {
-	diffStore.mtx.HighPriorityReadLock()
-	defer diffStore.mtx.HighPriorityReadUnlock()
-	diffData, exists, err := diffStore.diffDataByHash(node.hash)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, diffNotFoundError(node)
-	}
-	return diffData.diff, nil
-}
-
-func (diffStore *utxoDiffStore) diffChildByNode(node *blockNode) (*blockNode, error) {
-	diffStore.mtx.HighPriorityReadLock()
-	defer diffStore.mtx.HighPriorityReadUnlock()
-	diffData, exists, err := diffStore.diffDataByHash(node.hash)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, diffNotFoundError(node)
-	}
-	return diffData.diffChild, nil
-}
-
-func (diffStore *utxoDiffStore) diffDataFromDB(hash *daghash.Hash) (*blockUTXODiffData, error) {
-	var diffData *blockUTXODiffData
-	err := diffStore.dag.db.View(func(dbTx database.Tx) error {
-		bucket := dbTx.Metadata().Bucket(utxoDiffsBucketName)
-		serializedBlockDiffData := bucket.Get(hash[:])
-		if serializedBlockDiffData != nil {
-			var err error
-			diffData, err = diffStore.deserializeBlockUTXODiffData(serializedBlockDiffData)
-			return err
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return diffData, nil
-}
-
-// flushToDB writes all dirty diff data to the database. If all writes
-// succeed, this clears the dirty set.
-func (diffStore *utxoDiffStore) flushToDB(dbTx database.Tx) error {
-	diffStore.mtx.HighPriorityWriteLock()
-	defer diffStore.mtx.HighPriorityWriteUnlock()
-	if len(diffStore.dirty) == 0 {
-		return nil
-	}
-
-	// Allocate a buffer here to avoid needless allocations/grows
-	// while writing each entry.
-	buffer := &bytes.Buffer{}
-	for hash := range diffStore.dirty {
-		buffer.Reset()
-		diffData := diffStore.loaded[hash]
-		err := dbStoreDiffData(dbTx, buffer, &hash, diffData)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (diffStore *utxoDiffStore) clearDirtyEntries() {
-	diffStore.dirty = make(map[daghash.Hash]struct{})
-}
-
-// dbStoreDiffData stores the UTXO diff data to the database.
-// This overwrites the current entry if there exists one.
-func dbStoreDiffData(dbTx database.Tx, writeBuffer *bytes.Buffer, hash *daghash.Hash, diffData *blockUTXODiffData) error {
-	// To avoid a ton of allocs, use the given writeBuffer
-	// instead of allocating one. We expect the buffer to
-	// already be initalized and, in most cases, to already
-	// be large enough to accommodate the serialized data
-	// without growing.
-	err := serializeBlockUTXODiffData(writeBuffer, diffData)
-	if err != nil {
-		return err
-	}
-
-	// Bucket.Put doesn't copy on its own, so we manually
-	// copy here. We do so because we expect the buffer
-	// to be reused once we're done with it.
-	serializedDiffData := make([]byte, writeBuffer.Len())
-	copy(serializedDiffData, writeBuffer.Bytes())
-
-	return dbTx.Metadata().Bucket(utxoDiffsBucketName).Put(hash[:], serializedDiffData)
-}
-
-func dbRemoveDiffData(dbTx database.Tx, hash *daghash.Hash) error {
-	return dbTx.Metadata().Bucket(utxoDiffsBucketName).Delete(hash[:])
-}

blockdag/utxodiffstore_test.go

@@ -1,86 +0,0 @@
-package blockdag
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-	"reflect"
-	"testing"
-)
-
-func TestUTXODiffStore(t *testing.T) {
-	// Create a new database and DAG instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("TestUTXODiffStore", Config{
-		DAGParams: &dagconfig.SimnetParams,
-	})
-	if err != nil {
-		t.Fatalf("TestUTXODiffStore: Failed to setup DAG instance: %v", err)
-	}
-	defer teardownFunc()
-
-	nodeCounter := byte(0)
-	createNode := func() *blockNode {
-		nodeCounter++
-		node := &blockNode{hash: &daghash.Hash{nodeCounter}}
-		dag.index.AddNode(node)
-		return node
-	}
-
-	// Check that an error is returned when asking for non existing node
-	nonExistingNode := createNode()
-	_, err = dag.utxoDiffStore.diffByNode(nonExistingNode)
-	expectedErrString := fmt.Sprintf("Couldn't find diff data for block %s", nonExistingNode.hash)
-	if err == nil || err.Error() != expectedErrString {
-		t.Errorf("diffByNode: expected error %s but got %s", expectedErrString, err)
-	}
-
-	// Add node's diff data to the utxoDiffStore and check if it's checked correctly.
-	node := createNode()
-	diff := NewUTXODiff()
-	diff.toAdd.add(wire.Outpoint{TxID: daghash.TxID{0x01}, Index: 0}, &UTXOEntry{amount: 1, scriptPubKey: []byte{0x01}})
-	diff.toRemove.add(wire.Outpoint{TxID: daghash.TxID{0x02}, Index: 0}, &UTXOEntry{amount: 2, scriptPubKey: []byte{0x02}})
-	if err := dag.utxoDiffStore.setBlockDiff(node, diff); err != nil {
-		t.Fatalf("setBlockDiff: unexpected error: %s", err)
-	}
-	diffChild := createNode()
-	if err := dag.utxoDiffStore.setBlockDiffChild(node, diffChild); err != nil {
-		t.Fatalf("setBlockDiffChild: unexpected error: %s", err)
-	}
-
-	if storeDiff, err := dag.utxoDiffStore.diffByNode(node); err != nil {
-		t.Fatalf("diffByNode: unexpected error: %s", err)
-	} else if !reflect.DeepEqual(storeDiff, diff) {
-		t.Errorf("Expected diff and storeDiff to be equal")
-	}
-
-	if storeDiffChild, err := dag.utxoDiffStore.diffChildByNode(node); err != nil {
-		t.Fatalf("diffByNode: unexpected error: %s", err)
-	} else if !reflect.DeepEqual(storeDiffChild, diffChild) {
-		t.Errorf("Expected diff and storeDiff to be equal")
-	}
-
-	// Flush changes to db, delete them from the dag.utxoDiffStore.loaded
-	// map, and check if the diff data is re-fetched from the database.
-	err = dag.db.Update(func(dbTx database.Tx) error {
-		return dag.utxoDiffStore.flushToDB(dbTx)
-	})
-	if err != nil {
-		t.Fatalf("Error flushing utxoDiffStore data to DB: %s", err)
-	}
-	delete(dag.utxoDiffStore.loaded, *node.hash)
-
-	if storeDiff, err := dag.utxoDiffStore.diffByNode(node); err != nil {
-		t.Fatalf("diffByNode: unexpected error: %s", err)
-	} else if !reflect.DeepEqual(storeDiff, diff) {
-		t.Errorf("Expected diff and storeDiff to be equal")
-	}
-
-	// Check if getBlockDiff caches the result in dag.utxoDiffStore.loaded
-	if loadedDiffData, ok := dag.utxoDiffStore.loaded[*node.hash]; !ok {
-		t.Errorf("the diff data wasn't added to loaded map after requesting it")
-	} else if !reflect.DeepEqual(loadedDiffData.diff, diff) {
-		t.Errorf("Expected diff and loadedDiff to be equal")
-	}
-}

blockdag/utxoio.go

@@ -1,313 +0,0 @@
-package blockdag
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"github.com/pkg/errors"
-	"io"
-	"math/big"
-
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// serializeBlockUTXODiffData serializes diff data in the following format:
-// 	Name         | Data type | Description
-//  ------------ | --------- | -----------
-// 	hasDiffChild | Boolean   | Indicates if a diff child exist
-//  diffChild    | Hash      | The diffChild's hash. Empty if hasDiffChild is true.
-//  diff		 | UTXODiff  | The diff data's diff
-func serializeBlockUTXODiffData(w io.Writer, diffData *blockUTXODiffData) error {
-	hasDiffChild := diffData.diffChild != nil
-	err := wire.WriteElement(w, hasDiffChild)
-	if err != nil {
-		return err
-	}
-	if hasDiffChild {
-		err := wire.WriteElement(w, diffData.diffChild.hash)
-		if err != nil {
-			return err
-		}
-	}
-
-	err = serializeUTXODiff(w, diffData.diff)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// utxoEntryHeaderCode returns the calculated header code to be used when
-// serializing the provided utxo entry.
-func utxoEntryHeaderCode(entry *UTXOEntry) uint64 {
-	// As described in the serialization format comments, the header code
-	// encodes the blue score shifted over one bit and the block reward flag
-	// in the lowest bit.
-	headerCode := uint64(entry.BlockBlueScore()) << 1
-	if entry.IsCoinbase() {
-		headerCode |= 0x01
-	}
-
-	return headerCode
-}
-
-func (diffStore *utxoDiffStore) deserializeBlockUTXODiffData(serializedDiffDataBytes []byte) (*blockUTXODiffData, error) {
-	diffData := &blockUTXODiffData{}
-	serializedDiffData := bytes.NewBuffer(serializedDiffDataBytes)
-
-	var hasDiffChild bool
-	err := wire.ReadElement(serializedDiffData, &hasDiffChild)
-	if err != nil {
-		return nil, err
-	}
-
-	if hasDiffChild {
-		hash := &daghash.Hash{}
-		err := wire.ReadElement(serializedDiffData, hash)
-		if err != nil {
-			return nil, err
-		}
-		diffData.diffChild = diffStore.dag.index.LookupNode(hash)
-	}
-
-	diffData.diff = &UTXODiff{
-		useMultiset: true,
-	}
-
-	diffData.diff.toAdd, err = deserializeDiffEntries(serializedDiffData)
-	if err != nil {
-		return nil, err
-	}
-
-	diffData.diff.toRemove, err = deserializeDiffEntries(serializedDiffData)
-	if err != nil {
-		return nil, err
-	}
-
-	diffData.diff.diffMultiset, err = deserializeMultiset(serializedDiffData)
-	if err != nil {
-		return nil, err
-	}
-
-	return diffData, nil
-}
-
-func deserializeDiffEntries(r io.Reader) (utxoCollection, error) {
-	count, err := wire.ReadVarInt(r)
-	if err != nil {
-		return nil, err
-	}
-	collection := utxoCollection{}
-	for i := uint64(0); i < count; i++ {
-		outpointSize, err := wire.ReadVarInt(r)
-		if err != nil {
-			return nil, err
-		}
-
-		serializedOutpoint := make([]byte, outpointSize)
-		err = binary.Read(r, byteOrder, serializedOutpoint)
-		if err != nil {
-			return nil, err
-		}
-		outpoint, err := deserializeOutpoint(serializedOutpoint)
-		if err != nil {
-			return nil, err
-		}
-
-		utxoEntrySize, err := wire.ReadVarInt(r)
-		if err != nil {
-			return nil, err
-		}
-		serializedEntry := make([]byte, utxoEntrySize)
-		err = binary.Read(r, byteOrder, serializedEntry)
-		if err != nil {
-			return nil, err
-		}
-		utxoEntry, err := deserializeUTXOEntry(serializedEntry)
-		if err != nil {
-			return nil, err
-		}
-		collection.add(*outpoint, utxoEntry)
-	}
-	return collection, nil
-}
-
-// deserializeMultiset deserializes an EMCH multiset.
-// See serializeMultiset for more details.
-func deserializeMultiset(r io.Reader) (*ecc.Multiset, error) {
-	xBytes := make([]byte, multisetPointSize)
-	yBytes := make([]byte, multisetPointSize)
-	err := binary.Read(r, byteOrder, xBytes)
-	if err != nil {
-		return nil, err
-	}
-	err = binary.Read(r, byteOrder, yBytes)
-	if err != nil {
-		return nil, err
-	}
-	var x, y big.Int
-	x.SetBytes(xBytes)
-	y.SetBytes(yBytes)
-	return ecc.NewMultisetFromPoint(ecc.S256(), &x, &y), nil
-}
-
-// serializeUTXODiff serializes UTXODiff by serializing
-// UTXODiff.toAdd, UTXODiff.toRemove and UTXODiff.Multiset one after the other.
-func serializeUTXODiff(w io.Writer, diff *UTXODiff) error {
-	if !diff.useMultiset {
-		return errors.New("Cannot serialize a UTXO diff without a multiset")
-	}
-	err := serializeUTXOCollection(w, diff.toAdd)
-	if err != nil {
-		return err
-	}
-
-	err = serializeUTXOCollection(w, diff.toRemove)
-	if err != nil {
-		return err
-	}
-	err = serializeMultiset(w, diff.diffMultiset)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// serializeUTXOCollection serializes utxoCollection by iterating over
-// the utxo entries and serializing them and their corresponding outpoint
-// prefixed by a varint that indicates their size.
-func serializeUTXOCollection(w io.Writer, collection utxoCollection) error {
-	err := wire.WriteVarInt(w, uint64(len(collection)))
-	if err != nil {
-		return err
-	}
-	for outpoint, utxoEntry := range collection {
-		err := serializeUTXO(w, utxoEntry, &outpoint)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// serializeMultiset serializes an ECMH multiset. The serialization
-// is done by taking the (x,y) coordinnates of the multiset point and
-// padding each one of them with 32 byte (it'll be 32 byte in most
-// cases anyway except one of the coordinates is zero) and writing
-// them one after the other.
-func serializeMultiset(w io.Writer, ms *ecc.Multiset) error {
-	x, y := ms.Point()
-	xBytes := make([]byte, multisetPointSize)
-	copy(xBytes, x.Bytes())
-	yBytes := make([]byte, multisetPointSize)
-	copy(yBytes, y.Bytes())
-
-	err := binary.Write(w, byteOrder, xBytes)
-	if err != nil {
-		return err
-	}
-	err = binary.Write(w, byteOrder, yBytes)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// serializeUTXO serializes a utxo entry-outpoint pair
-func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *wire.Outpoint) error {
-	serializedOutpoint := *outpointKey(*outpoint)
-	err := wire.WriteVarInt(w, uint64(len(serializedOutpoint)))
-	if err != nil {
-		return err
-	}
-
-	err = binary.Write(w, byteOrder, serializedOutpoint)
-	if err != nil {
-		return err
-	}
-
-	serializedUTXOEntry := serializeUTXOEntry(entry)
-	err = wire.WriteVarInt(w, uint64(len(serializedUTXOEntry)))
-	if err != nil {
-		return err
-	}
-	err = binary.Write(w, byteOrder, serializedUTXOEntry)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// serializeUTXOEntry returns the entry serialized to a format that is suitable
-// for long-term storage. The format is described in detail above.
-func serializeUTXOEntry(entry *UTXOEntry) []byte {
-	// Encode the header code.
-	headerCode := utxoEntryHeaderCode(entry)
-
-	// Calculate the size needed to serialize the entry.
-	size := serializeSizeVLQ(headerCode) +
-		compressedTxOutSize(uint64(entry.Amount()), entry.ScriptPubKey())
-
-	// Serialize the header code followed by the compressed unspent
-	// transaction output.
-	serialized := make([]byte, size)
-	offset := putVLQ(serialized, headerCode)
-	offset += putCompressedTxOut(serialized[offset:], uint64(entry.Amount()),
-		entry.ScriptPubKey())
-
-	return serialized
-}
-
-// deserializeOutpoint decodes an outpoint from the passed serialized byte
-// slice into a new wire.Outpoint using a format that is suitable for long-
-// term storage. this format is described in detail above.
-func deserializeOutpoint(serialized []byte) (*wire.Outpoint, error) {
-	if len(serialized) <= daghash.HashSize {
-		return nil, errDeserialize("unexpected end of data")
-	}
-
-	txID := daghash.TxID{}
-	txID.SetBytes(serialized[:daghash.HashSize])
-	index, _ := deserializeVLQ(serialized[daghash.HashSize:])
-	return wire.NewOutpoint(&txID, uint32(index)), nil
-}
-
-// deserializeUTXOEntry decodes a UTXO entry from the passed serialized byte
-// slice into a new UTXOEntry using a format that is suitable for long-term
-// storage. The format is described in detail above.
-func deserializeUTXOEntry(serialized []byte) (*UTXOEntry, error) {
-	// Deserialize the header code.
-	code, offset := deserializeVLQ(serialized)
-	if offset >= len(serialized) {
-		return nil, errDeserialize("unexpected end of data after header")
-	}
-
-	// Decode the header code.
-	//
-	// Bit 0 indicates whether the containing transaction is a coinbase.
-	// Bits 1-x encode blue score of the containing transaction.
-	isCoinbase := code&0x01 != 0
-	blockBlueScore := code >> 1
-
-	// Decode the compressed unspent transaction output.
-	amount, scriptPubKey, _, err := decodeCompressedTxOut(serialized[offset:])
-	if err != nil {
-		return nil, errDeserialize(fmt.Sprintf("unable to decode "+
-			"UTXO: %s", err))
-	}
-
-	entry := &UTXOEntry{
-		amount:         amount,
-		scriptPubKey:   scriptPubKey,
-		blockBlueScore: blockBlueScore,
-		packedFlags:    0,
-	}
-	if isCoinbase {
-		entry.packedFlags |= tfCoinbase
-	}
-
-	return entry, nil
-}

blockdag/versionbits.go

@@ -1,294 +0,0 @@
-// Copyright (c) 2016-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag
-
-import (
-	"math"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-)
-
-const (
-	// vbTopBits defines the bits to set in the version to signal that the
-	// version bits scheme is being used.
-	vbTopBits = 0x10000000
-
-	// vbTopMask is the bitmask to use to determine whether or not the
-	// version bits scheme is in use.
-	vbTopMask = 0xe0000000
-
-	// vbNumBits is the total number of bits available for use with the
-	// version bits scheme.
-	vbNumBits = 29
-
-	// unknownVerNumToCheck is the number of previous blocks to consider
-	// when checking for a threshold of unknown block versions for the
-	// purposes of warning the user.
-	unknownVerNumToCheck = 100
-
-	// unknownVerWarnNum is the threshold of previous blocks that have an
-	// unknown version to use for the purposes of warning the user.
-	unknownVerWarnNum = unknownVerNumToCheck / 2
-)
-
-// bitConditionChecker provides a thresholdConditionChecker which can be used to
-// test whether or not a specific bit is set when it's not supposed to be
-// according to the expected version based on the known deployments and the
-// current state of the DAG. This is useful for detecting and warning about
-// unknown rule activations.
-type bitConditionChecker struct {
-	bit uint32
-	dag *BlockDAG
-}
-
-// Ensure the bitConditionChecker type implements the thresholdConditionChecker
-// interface.
-var _ thresholdConditionChecker = bitConditionChecker{}
-
-// BeginTime returns the unix timestamp for the median block time after which
-// voting on a rule change starts (at the next window).
-//
-// Since this implementation checks for unknown rules, it returns 0 so the rule
-// is always treated as active.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c bitConditionChecker) BeginTime() uint64 {
-	return 0
-}
-
-// EndTime returns the unix timestamp for the median block time after which an
-// attempted rule change fails if it has not already been locked in or
-// activated.
-//
-// Since this implementation checks for unknown rules, it returns the maximum
-// possible timestamp so the rule is always treated as active.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c bitConditionChecker) EndTime() uint64 {
-	return math.MaxUint64
-}
-
-// RuleChangeActivationThreshold is the number of blocks for which the condition
-// must be true in order to lock in a rule change.
-//
-// This implementation returns the value defined by the DAG params the checker
-// is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c bitConditionChecker) RuleChangeActivationThreshold() uint64 {
-	return c.dag.dagParams.RuleChangeActivationThreshold
-}
-
-// MinerConfirmationWindow is the number of blocks in each threshold state
-// retarget window.
-//
-// This implementation returns the value defined by the DAG params the checker
-// is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c bitConditionChecker) MinerConfirmationWindow() uint64 {
-	return c.dag.dagParams.MinerConfirmationWindow
-}
-
-// Condition returns true when the specific bit associated with the checker is
-// set and it's not supposed to be according to the expected version based on
-// the known deployments and the current state of the DAG.
-//
-// This function MUST be called with the DAG state lock held (for writes).
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c bitConditionChecker) Condition(node *blockNode) (bool, error) {
-	conditionMask := uint32(1) << c.bit
-	version := uint32(node.version)
-	if version&vbTopMask != vbTopBits {
-		return false, nil
-	}
-	if version&conditionMask == 0 {
-		return false, nil
-	}
-
-	expectedVersion, err := c.dag.calcNextBlockVersion(node.selectedParent)
-	if err != nil {
-		return false, err
-	}
-	return uint32(expectedVersion)&conditionMask == 0, nil
-}
-
-// deploymentChecker provides a thresholdConditionChecker which can be used to
-// test a specific deployment rule. This is required for properly detecting
-// and activating consensus rule changes.
-type deploymentChecker struct {
-	deployment *dagconfig.ConsensusDeployment
-	dag        *BlockDAG
-}
-
-// Ensure the deploymentChecker type implements the thresholdConditionChecker
-// interface.
-var _ thresholdConditionChecker = deploymentChecker{}
-
-// BeginTime returns the unix timestamp for the median block time after which
-// voting on a rule change starts (at the next window).
-//
-// This implementation returns the value defined by the specific deployment the
-// checker is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c deploymentChecker) BeginTime() uint64 {
-	return c.deployment.StartTime
-}
-
-// EndTime returns the unix timestamp for the median block time after which an
-// attempted rule change fails if it has not already been locked in or
-// activated.
-//
-// This implementation returns the value defined by the specific deployment the
-// checker is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c deploymentChecker) EndTime() uint64 {
-	return c.deployment.ExpireTime
-}
-
-// RuleChangeActivationThreshold is the number of blocks for which the condition
-// must be true in order to lock in a rule change.
-//
-// This implementation returns the value defined by the DAG params the checker
-// is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c deploymentChecker) RuleChangeActivationThreshold() uint64 {
-	return c.dag.dagParams.RuleChangeActivationThreshold
-}
-
-// MinerConfirmationWindow is the number of blocks in each threshold state
-// retarget window.
-//
-// This implementation returns the value defined by the DAG params the checker
-// is associated with.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c deploymentChecker) MinerConfirmationWindow() uint64 {
-	return c.dag.dagParams.MinerConfirmationWindow
-}
-
-// Condition returns true when the specific bit defined by the deployment
-// associated with the checker is set.
-//
-// This is part of the thresholdConditionChecker interface implementation.
-func (c deploymentChecker) Condition(node *blockNode) (bool, error) {
-	conditionMask := uint32(1) << c.deployment.BitNumber
-	version := uint32(node.version)
-	return (version&vbTopMask == vbTopBits) && (version&conditionMask != 0),
-		nil
-}
-
-// calcNextBlockVersion calculates the expected version of the block after the
-// passed previous block node based on the state of started and locked in
-// rule change deployments.
-//
-// This function differs from the exported CalcNextBlockVersion in that the
-// exported version uses the selected tip as the previous block node
-// while this function accepts any block node.
-//
-// This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) calcNextBlockVersion(prevNode *blockNode) (int32, error) {
-	// Set the appropriate bits for each actively defined rule deployment
-	// that is either in the process of being voted on, or locked in for the
-	// activation at the next threshold window change.
-	expectedVersion := uint32(vbTopBits)
-	for id := 0; id < len(dag.dagParams.Deployments); id++ {
-		deployment := &dag.dagParams.Deployments[id]
-		cache := &dag.deploymentCaches[id]
-		checker := deploymentChecker{deployment: deployment, dag: dag}
-		state, err := dag.thresholdState(prevNode, checker, cache)
-		if err != nil {
-			return 0, err
-		}
-		if state == ThresholdStarted || state == ThresholdLockedIn {
-			expectedVersion |= uint32(1) << deployment.BitNumber
-		}
-	}
-	return int32(expectedVersion), nil
-}
-
-// CalcNextBlockVersion calculates the expected version of the block after the
-// end of the current selected tip based on the state of started and locked in
-// rule change deployments.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) CalcNextBlockVersion() (int32, error) {
-	version, err := dag.calcNextBlockVersion(dag.selectedTip())
-	return version, err
-}
-
-// warnUnknownRuleActivations displays a warning when any unknown new rules are
-// either about to activate or have been activated. This will only happen once
-// when new rules have been activated and every block for those about to be
-// activated.
-//
-// This function MUST be called with the DAG state lock held (for writes)
-func (dag *BlockDAG) warnUnknownRuleActivations(node *blockNode) error {
-	// Warn if any unknown new rules are either about to activate or have
-	// already been activated.
-	for bit := uint32(0); bit < vbNumBits; bit++ {
-		checker := bitConditionChecker{bit: bit, dag: dag}
-		cache := &dag.warningCaches[bit]
-		state, err := dag.thresholdState(node.selectedParent, checker, cache)
-		if err != nil {
-			return err
-		}
-
-		switch state {
-		case ThresholdActive:
-			if !dag.unknownRulesWarned {
-				log.Warnf("Unknown new rules activated (bit %d)",
-					bit)
-				dag.unknownRulesWarned = true
-			}
-
-		case ThresholdLockedIn:
-			window := checker.MinerConfirmationWindow()
-			activationBlueScore := window - (node.blueScore % window)
-			log.Warnf("Unknown new rules are about to activate in "+
-				"%d blueScore (bit %d)", activationBlueScore, bit)
-		}
-	}
-
-	return nil
-}
-
-// warnUnknownVersions logs a warning if a high enough percentage of the last
-// blocks have unexpected versions.
-//
-// This function MUST be called with the DAG state lock held (for writes)
-func (dag *BlockDAG) warnUnknownVersions(node *blockNode) error {
-	// Nothing to do if already warned.
-	if dag.unknownVersionsWarned {
-		return nil
-	}
-
-	// Warn if enough previous blocks have unexpected versions.
-	numUpgraded := uint32(0)
-	for i := uint32(0); i < unknownVerNumToCheck && node != nil; i++ {
-		expectedVersion, err := dag.calcNextBlockVersion(node.selectedParent)
-		if err != nil {
-			return err
-		}
-		if (node.version & ^expectedVersion) != 0 {
-
-			numUpgraded++
-		}
-
-		node = node.selectedParent
-	}
-	if numUpgraded > unknownVerWarnNum {
-		log.Warn("Unknown block versions are being mined, so new " +
-			"rules might be in effect. Are you running the " +
-			"latest version of the software?")
-		dag.unknownVersionsWarned = true
-	}
-
-	return nil
-}

cmd/addblock/addblock.go

@@ -6,58 +6,24 @@ package main
 
 import (
 	"os"
-	"path/filepath"
 	"runtime"
 
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/limits"
-	"github.com/kaspanet/kaspad/logs"
+	"github.com/kaspanet/kaspad/infrastructure/limits"
+	"github.com/kaspanet/kaspad/infrastructure/logs"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
 const (
-	// blockDbNamePrefix is the prefix for the kaspad block database.
-	blockDbNamePrefix = "blocks"
+	// blockDBNamePrefix is the prefix for the kaspad block database.
+	blockDBNamePrefix = "blocks"
 )
 
 var (
 	cfg   *ConfigFlags
-	log   logs.Logger
-	spawn func(func())
+	log   *logs.Logger
+	spawn func(string, func())
 )
 
-// loadBlockDB opens the block database and returns a handle to it.
-func loadBlockDB() (database.DB, error) {
-	// The database name is based on the database type.
-	dbName := blockDbNamePrefix + "_" + cfg.DbType
-	dbPath := filepath.Join(cfg.DataDir, dbName)
-
-	log.Infof("Loading block database from '%s'", dbPath)
-	db, err := database.Open(cfg.DbType, dbPath, ActiveConfig().NetParams().Net)
-	if err != nil {
-		// Return the error if it's not because the database doesn't
-		// exist.
-		if dbErr, ok := err.(database.Error); !ok || dbErr.ErrorCode !=
-			database.ErrDbDoesNotExist {
-
-			return nil, err
-		}
-
-		// Create the db if it does not exist.
-		err = os.MkdirAll(cfg.DataDir, 0700)
-		if err != nil {
-			return nil, err
-		}
-		db, err = database.Create(cfg.DbType, dbPath, ActiveConfig().NetParams().Net)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	log.Info("Block database loaded")
-	return db, nil
-}
-
 // realMain is the real main function for the utility. It is necessary to work
 // around the fact that deferred functions do not run when os.Exit() is called.
 func realMain() error {
@@ -74,14 +40,6 @@ func realMain() error {
 	log = backendLogger.Logger("MAIN")
 	spawn = panics.GoroutineWrapperFunc(log)
 
-	// Load the block database.
-	db, err := loadBlockDB()
-	if err != nil {
-		log.Errorf("Failed to load database: %s", err)
-		return err
-	}
-	defer db.Close()
-
 	fi, err := os.Open(cfg.InFile)
 	if err != nil {
 		log.Errorf("Failed to open file %s: %s", cfg.InFile, err)
@@ -92,7 +50,7 @@ func realMain() error {
 	// Create a block importer for the database and input file and start it.
 	// The done channel returned from start will contain an error if
 	// anything went wrong.
-	importer, err := newBlockImporter(db, fi)
+	importer, err := newBlockImporter(fi)
 	if err != nil {
 		log.Errorf("Failed create block importer: %s", err)
 		return err

cmd/addblock/config.go

@@ -6,20 +6,15 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/config"
+	flags "github.com/jessevdk/go-flags"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 	"os"
 	"path/filepath"
-	"strings"
-
-	flags "github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/database"
-	_ "github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/kaspanet/kaspad/util"
 )
 
 const (
-	defaultDbType   = "ffldb"
 	defaultDataFile = "bootstrap.dat"
 	defaultProgress = 10
 )
@@ -27,7 +22,6 @@ const (
 var (
 	kaspadHomeDir  = util.AppDataDir("kaspad", false)
 	defaultDataDir = filepath.Join(kaspadHomeDir, "data")
-	knownDbTypes   = database.SupportedDrivers()
 	activeConfig   *ConfigFlags
 )
 
@@ -40,12 +34,10 @@ func ActiveConfig() *ConfigFlags {
 //
 // See loadConfig for details on the configuration load process.
 type ConfigFlags struct {
-	DataDir   string `short:"b" long:"datadir" description:"Location of the kaspad data directory"`
-	DbType    string `long:"dbtype" description:"Database backend to use for the Block DAG"`
-	InFile    string `short:"i" long:"infile" description:"File containing the block(s)"`
-	TxIndex   bool   `long:"txindex" description:"Build a full hash-based transaction index which makes all transactions available via the getrawtransaction RPC"`
-	AddrIndex bool   `long:"addrindex" description:"Build a full address-based transaction index which makes the searchrawtransactions RPC available"`
-	Progress  int    `short:"p" long:"progress" description:"Show a progress message each time this number of seconds have passed -- Use 0 to disable progress announcements"`
+	DataDir         string `short:"b" long:"datadir" description:"Location of the kaspad data directory"`
+	InFile          string `short:"i" long:"infile" description:"File containing the block(s)"`
+	Progress        int    `short:"p" long:"progress" description:"Show a progress message each time this number of seconds have passed -- Use 0 to disable progress announcements"`
+	AcceptanceIndex bool   `long:"acceptanceindex" description:"Maintain a full hash-based acceptance index which makes the getChainFromBlock RPC available"`
 	config.NetworkFlags
 }
 
@@ -59,23 +51,11 @@ func fileExists(name string) bool {
 	return true
 }
 
-// validDbType returns whether or not dbType is a supported database type.
-func validDbType(dbType string) bool {
-	for _, knownType := range knownDbTypes {
-		if dbType == knownType {
-			return true
-		}
-	}
-
-	return false
-}
-
 // loadConfig initializes and parses the config using command line options.
 func loadConfig() (*ConfigFlags, []string, error) {
 	// Default config.
 	activeConfig = &ConfigFlags{
 		DataDir:  defaultDataDir,
-		DbType:   defaultDbType,
 		InFile:   defaultDataFile,
 		Progress: defaultProgress,
 	}
@@ -84,7 +64,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	parser := flags.NewParser(&activeConfig, flags.Default)
 	remainingArgs, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			parser.WriteHelp(os.Stderr)
 		}
 		return nil, nil, err
@@ -95,16 +76,6 @@ func loadConfig() (*ConfigFlags, []string, error) {
 		return nil, nil, err
 	}
 
-	// Validate database type.
-	if !validDbType(activeConfig.DbType) {
-		str := "%s: The specified database type [%s] is invalid -- " +
-			"supported types %s"
-		err := errors.Errorf(str, "loadConfig", activeConfig.DbType, strings.Join(knownDbTypes, ", "))
-		fmt.Fprintln(os.Stderr, err)
-		parser.WriteHelp(os.Stderr)
-		return nil, nil, err
-	}
-
 	// Append the network type to the data directory so it is "namespaced"
 	// per network. In addition to the block database, there are other
 	// pieces of data that are saved to disk such as address manager state.

cmd/addblock/import.go

@@ -6,16 +6,16 @@ package main
 
 import (
 	"encoding/binary"
+	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/pkg/errors"
 	"io"
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/blockdag/indexers"
-	"github.com/kaspanet/kaspad/database"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/network/domainmessage"
 	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
 )
 
 // importResults houses the stats and result as an import operation.
@@ -28,7 +28,6 @@ type importResults struct {
 // blockImporter houses information about an ongoing import from a block data
 // file to the block database.
 type blockImporter struct {
-	db                database.DB
 	dag               *blockdag.BlockDAG
 	r                 io.ReadSeeker
 	processQueue      chan []byte
@@ -41,8 +40,8 @@ type blockImporter struct {
 	receivedLogBlocks int64
 	receivedLogTx     int64
 	lastHeight        int64
-	lastBlockTime     time.Time
-	lastLogTime       time.Time
+	lastBlockTime     mstime.Time
+	lastLogTime       mstime.Time
 }
 
 // readBlock reads the next block from the input file.
@@ -69,10 +68,10 @@ func (bi *blockImporter) readBlock() ([]byte, error) {
 	if err := binary.Read(bi.r, binary.LittleEndian, &blockLen); err != nil {
 		return nil, err
 	}
-	if blockLen > wire.MaxMessagePayload {
+	if blockLen > domainmessage.MaxMessagePayload {
 		return nil, errors.Errorf("block payload of %d bytes is larger "+
 			"than the max allowed %d bytes", blockLen,
-			wire.MaxMessagePayload)
+			domainmessage.MaxMessagePayload)
 	}
 
 	serializedBlock := make([]byte, blockLen)
@@ -101,14 +100,14 @@ func (bi *blockImporter) processBlock(serializedBlock []byte) (bool, error) {
 
 	// Skip blocks that already exist.
 	blockHash := block.Hash()
-	if bi.dag.HaveBlock(blockHash) {
+	if bi.dag.IsKnownBlock(blockHash) {
 		return false, nil
 	}
 
 	// Don't bother trying to process orphans.
 	parentHashes := block.MsgBlock().Header.ParentHashes
 	if len(parentHashes) > 0 {
-		if !bi.dag.HaveBlocks(parentHashes) {
+		if !bi.dag.AreKnownBlocks(parentHashes) {
 			return false, errors.Errorf("import file contains block "+
 				"%v which does not link to the available "+
 				"block DAG", parentHashes)
@@ -172,7 +171,7 @@ out:
 func (bi *blockImporter) logProgress() {
 	bi.receivedLogBlocks++
 
-	now := time.Now()
+	now := mstime.Now()
 	duration := now.Sub(bi.lastLogTime)
 	if duration < time.Second*time.Duration(cfg.Progress) {
 		return
@@ -266,12 +265,12 @@ func (bi *blockImporter) Import() chan *importResults {
 	// Start up the read and process handling goroutines. This setup allows
 	// blocks to be read from disk in parallel while being processed.
 	bi.wg.Add(2)
-	spawn(bi.readHandler)
-	spawn(bi.processHandler)
+	spawn("blockImporter.readHandler", bi.readHandler)
+	spawn("blockImporter.processHandler", bi.processHandler)
 
 	// Wait for the import to finish in a separate goroutine and signal
 	// the status handler when done.
-	spawn(func() {
+	spawn("blockImporter.sendToDoneChan", func() {
 		bi.wg.Wait()
 		bi.doneChan <- true
 	})
@@ -279,7 +278,7 @@ func (bi *blockImporter) Import() chan *importResults {
 	// Start the status handler and return the result channel that it will
 	// send the results on when the import is done.
 	resultChan := make(chan *importResults)
-	spawn(func() {
+	spawn("blockImporter.statusHandler", func() {
 		bi.statusHandler(resultChan)
 	})
 	return resultChan
@@ -287,29 +286,12 @@ func (bi *blockImporter) Import() chan *importResults {
 
 // newBlockImporter returns a new importer for the provided file reader seeker
 // and database.
-func newBlockImporter(db database.DB, r io.ReadSeeker) (*blockImporter, error) {
-	// Create the transaction and address indexes if needed.
-	//
-	// CAUTION: the txindex needs to be first in the indexes array because
-	// the addrindex uses data from the txindex during catchup. If the
-	// addrindex is run first, it may not have the transactions from the
-	// current block indexed.
+func newBlockImporter(r io.ReadSeeker) (*blockImporter, error) {
+	// Create the acceptance index if needed.
 	var indexes []indexers.Indexer
-	if cfg.TxIndex || cfg.AddrIndex {
-		// Enable transaction index if address index is enabled since it
-		// requires it.
-		if !cfg.TxIndex {
-			log.Infof("Transaction index enabled because it is " +
-				"required by the address index")
-			cfg.TxIndex = true
-		} else {
-			log.Info("Transaction index is enabled")
-		}
-		indexes = append(indexes, indexers.NewTxIndex())
-	}
-	if cfg.AddrIndex {
-		log.Info("Address index is enabled")
-		indexes = append(indexes, indexers.NewAddrIndex(ActiveConfig().NetParams()))
+	if cfg.AcceptanceIndex {
+		log.Info("Acceptance index is enabled")
+		indexes = append(indexes, indexers.NewAcceptanceIndex())
 	}
 
 	// Create an index manager if any of the optional indexes are enabled.
@@ -319,9 +301,8 @@ func newBlockImporter(db database.DB, r io.ReadSeeker) (*blockImporter, error) {
 	}
 
 	dag, err := blockdag.New(&blockdag.Config{
-		DB:           db,
 		DAGParams:    ActiveConfig().NetParams(),
-		TimeSource:   blockdag.NewMedianTime(),
+		TimeSource:   blockdag.NewTimeSource(),
 		IndexManager: indexManager,
 	})
 	if err != nil {
@@ -329,13 +310,12 @@ func newBlockImporter(db database.DB, r io.ReadSeeker) (*blockImporter, error) {
 	}
 
 	return &blockImporter{
-		db:           db,
 		r:            r,
 		processQueue: make(chan []byte, 2),
 		doneChan:     make(chan bool),
 		errChan:      make(chan error),
 		quit:         make(chan struct{}),
 		dag:          dag,
-		lastLogTime:  time.Now(),
+		lastLogTime:  mstime.Now(),
 	}, nil
 }

cmd/addsubnetwork/addsubnetwork.go

@@ -1,87 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/kaspanet/kaspad/rpcmodel"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-	"github.com/pkg/errors"
-	"time"
-)
-
-const (
-	getSubnetworkRetryDelay = 5 * time.Second
-	maxGetSubnetworkRetries = 12
-)
-
-func main() {
-	cfg, err := parseConfig()
-	if err != nil {
-		panic(errors.Errorf("error parsing command-line arguments: %s", err))
-	}
-
-	privateKey, addrPubKeyHash, err := decodeKeys(cfg)
-	if err != nil {
-		panic(errors.Errorf("error decoding public key: %s", err))
-	}
-
-	client, err := connect(cfg)
-	if err != nil {
-		panic(errors.Errorf("could not connect to RPC server: %s", err))
-	}
-	log.Infof("Connected to server %s", cfg.RPCServer)
-
-	fundingOutpoint, fundingTx, err := findUnspentTXO(cfg, client, addrPubKeyHash)
-	if err != nil {
-		panic(errors.Errorf("error finding unspent transactions: %s", err))
-	}
-	if fundingOutpoint == nil || fundingTx == nil {
-		panic(errors.Errorf("could not find any unspent transactions this for key"))
-	}
-	log.Infof("Found transaction to spend: %s:%d", fundingOutpoint.TxID, fundingOutpoint.Index)
-
-	registryTx, err := buildSubnetworkRegistryTx(cfg, fundingOutpoint, fundingTx, privateKey)
-	if err != nil {
-		panic(errors.Errorf("error building subnetwork registry tx: %s", err))
-	}
-
-	_, err = client.SendRawTransaction(registryTx, true)
-	if err != nil {
-		panic(errors.Errorf("failed sending subnetwork registry tx: %s", err))
-	}
-	log.Infof("Successfully sent subnetwork registry transaction")
-
-	subnetworkID, err := blockdag.TxToSubnetworkID(registryTx)
-	if err != nil {
-		panic(errors.Errorf("could not build subnetwork ID: %s", err))
-	}
-
-	err = waitForSubnetworkToBecomeAccepted(client, subnetworkID)
-	if err != nil {
-		panic(errors.Errorf("error waiting for subnetwork to become accepted: %s", err))
-	}
-	log.Infof("Subnetwork '%s' was successfully registered.", subnetworkID)
-}
-
-func waitForSubnetworkToBecomeAccepted(client *rpcclient.Client, subnetworkID *subnetworkid.SubnetworkID) error {
-	retries := 0
-	for {
-		_, err := client.GetSubnetwork(subnetworkID.String())
-		if err != nil {
-			if rpcError, ok := err.(*rpcmodel.RPCError); ok && rpcError.Code == rpcmodel.ErrRPCSubnetworkNotFound {
-				log.Infof("Subnetwork not found")
-
-				retries++
-				if retries == maxGetSubnetworkRetries {
-					return errors.Errorf("failed to get subnetwork %d times: %s", maxGetSubnetworkRetries, err)
-				}
-
-				log.Infof("Waiting %d seconds...", int(getSubnetworkRetryDelay.Seconds()))
-				<-time.After(getSubnetworkRetryDelay)
-				continue
-			}
-			return errors.Errorf("failed getting subnetwork: %s", err)
-		}
-		return nil
-	}
-}

cmd/addsubnetwork/config.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/pkg/errors"
-)
-
-var activeConfig *ConfigFlags
-
-// ActiveConfig returns the active configuration struct
-func ActiveConfig() *ConfigFlags {
-	return activeConfig
-}
-
-// ConfigFlags holds the configurations set by the command line argument
-type ConfigFlags struct {
-	PrivateKey    string `short:"k" long:"private-key" description:"Private key" required:"true"`
-	RPCUser       string `short:"u" long:"rpcuser" description:"RPC username" required:"true"`
-	RPCPassword   string `short:"P" long:"rpcpass" default-mask:"-" description:"RPC password" required:"true"`
-	RPCServer     string `short:"s" long:"rpcserver" description:"RPC server to connect to" required:"true"`
-	RPCCert       string `short:"c" long:"rpccert" description:"RPC server certificate chain for validation"`
-	DisableTLS    bool   `long:"notls" description:"Disable TLS"`
-	GasLimit      uint64 `long:"gaslimit" description:"The gas limit of the new subnetwork"`
-	RegistryTxFee uint64 `long:"regtxfee" description:"The fee for the subnetwork registry transaction"`
-	config.NetworkFlags
-}
-
-const (
-	defaultSubnetworkGasLimit = 1000
-	defaultRegistryTxFee      = 3000
-)
-
-func parseConfig() (*ConfigFlags, error) {
-	activeConfig = &ConfigFlags{}
-	parser := flags.NewParser(activeConfig, flags.PrintErrors|flags.HelpFlag)
-	_, err := parser.Parse()
-
-	if err != nil {
-		return nil, err
-	}
-
-	if activeConfig.RPCCert == "" && !activeConfig.DisableTLS {
-		return nil, errors.New("--notls has to be disabled if --cert is used")
-	}
-
-	if activeConfig.RPCCert != "" && activeConfig.DisableTLS {
-		return nil, errors.New("--cert should be omitted if --notls is used")
-	}
-
-	err = activeConfig.ResolveNetwork(parser)
-	if err != nil {
-		return nil, err
-	}
-
-	if activeConfig.GasLimit < 0 {
-		return nil, errors.Errorf("gaslimit may not be smaller than 0")
-	}
-	if activeConfig.GasLimit == 0 {
-		activeConfig.GasLimit = defaultSubnetworkGasLimit
-	}
-
-	if activeConfig.RegistryTxFee < 0 {
-		return nil, errors.Errorf("regtxfee may not be smaller than 0")
-	}
-	if activeConfig.RegistryTxFee == 0 {
-		activeConfig.RegistryTxFee = defaultRegistryTxFee
-	}
-
-	return activeConfig, nil
-}

cmd/addsubnetwork/connect.go

@@ -1,37 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/pkg/errors"
-	"io/ioutil"
-)
-
-func connect(cfg *ConfigFlags) (*rpcclient.Client, error) {
-	var cert []byte
-	if !cfg.DisableTLS {
-		var err error
-		cert, err = ioutil.ReadFile(cfg.RPCCert)
-		if err != nil {
-			return nil, errors.Errorf("error reading certificates file: %s", err)
-		}
-	}
-
-	connCfg := &rpcclient.ConnConfig{
-		Host:       cfg.RPCServer,
-		Endpoint:   "ws",
-		User:       cfg.RPCUser,
-		Pass:       cfg.RPCPassword,
-		DisableTLS: cfg.DisableTLS,
-	}
-
-	if !cfg.DisableTLS {
-		connCfg.Certificates = cert
-	}
-
-	client, err := rpcclient.New(connCfg, nil)
-	if err != nil {
-		return nil, errors.Errorf("error connecting to address %s: %s", cfg.RPCServer, err)
-	}
-
-	return client, nil
-}

cmd/addsubnetwork/keys.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/base58"
-)
-
-func decodeKeys(cfg *ConfigFlags) (*ecc.PrivateKey, *util.AddressPubKeyHash, error) {
-	privateKeyBytes := base58.Decode(cfg.PrivateKey)
-	privateKey, _ := ecc.PrivKeyFromBytes(ecc.S256(), privateKeyBytes)
-	serializedPrivateKey := privateKey.PubKey().SerializeCompressed()
-
-	addr, err := util.NewAddressPubKeyHashFromPublicKey(serializedPrivateKey, ActiveConfig().NetParams().Prefix)
-	if err != nil {
-		return nil, nil, err
-	}
-	return privateKey, addr, nil
-}

cmd/addsubnetwork/log.go

@@ -1,10 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/logs"
-)
-
-var (
-	backendLog = logs.NewBackend()
-	log        = backendLog.Logger("ASUB")
-)

cmd/addsubnetwork/registrytx.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-func buildSubnetworkRegistryTx(cfg *ConfigFlags, fundingOutpoint *wire.Outpoint, fundingTx *wire.MsgTx, privateKey *ecc.PrivateKey) (*wire.MsgTx, error) {
-	txIn := &wire.TxIn{
-		PreviousOutpoint: *fundingOutpoint,
-		Sequence:         wire.MaxTxInSequenceNum,
-	}
-	txOut := &wire.TxOut{
-		ScriptPubKey: fundingTx.TxOut[fundingOutpoint.Index].ScriptPubKey,
-		Value:        fundingTx.TxOut[fundingOutpoint.Index].Value - cfg.RegistryTxFee,
-	}
-	registryTx := wire.NewRegistryMsgTx(1, []*wire.TxIn{txIn}, []*wire.TxOut{txOut}, cfg.GasLimit)
-
-	SignatureScript, err := txscript.SignatureScript(registryTx, 0, fundingTx.TxOut[fundingOutpoint.Index].ScriptPubKey,
-		txscript.SigHashAll, privateKey, true)
-	if err != nil {
-		return nil, errors.Errorf("failed to build signature script: %s", err)
-	}
-	txIn.SignatureScript = SignatureScript
-
-	return registryTx, nil
-}

cmd/addsubnetwork/utxo.go

@@ -1,112 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/hex"
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/kaspanet/kaspad/rpcmodel"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-const (
-	resultsCount     = 1000
-	minConfirmations = 10
-)
-
-func findUnspentTXO(cfg *ConfigFlags, client *rpcclient.Client, addrPubKeyHash *util.AddressPubKeyHash) (*wire.Outpoint, *wire.MsgTx, error) {
-	txs, err := collectTransactions(client, addrPubKeyHash)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	utxos := buildUTXOs(txs)
-	for outpoint, tx := range utxos {
-		// Skip TXOs that can't pay for registration
-		if tx.TxOut[outpoint.Index].Value < cfg.RegistryTxFee {
-			continue
-		}
-
-		return &outpoint, tx, nil
-	}
-
-	return nil, nil, nil
-}
-
-func collectTransactions(client *rpcclient.Client, addrPubKeyHash *util.AddressPubKeyHash) ([]*wire.MsgTx, error) {
-	txs := make([]*wire.MsgTx, 0)
-	skip := 0
-	for {
-		results, err := client.SearchRawTransactionsVerbose(addrPubKeyHash, skip, resultsCount, true, false, nil)
-		if err != nil {
-			// Break when there are no further txs
-			if rpcError, ok := err.(*rpcmodel.RPCError); ok && rpcError.Code == rpcmodel.ErrRPCNoTxInfo {
-				break
-			}
-
-			return nil, err
-		}
-
-		for _, result := range results {
-			// Mempool transactions bring about unnecessary complexity, so
-			// simply don't bother processing them
-			if result.IsInMempool {
-				continue
-			}
-
-			tx, err := parseRawTransactionResult(result)
-			if err != nil {
-				return nil, errors.Errorf("failed to process SearchRawTransactionResult: %s", err)
-			}
-			if tx == nil {
-				continue
-			}
-			if !isTxMatured(tx, *result.Confirmations) {
-				continue
-			}
-
-			txs = append(txs, tx)
-		}
-
-		skip += resultsCount
-	}
-	return txs, nil
-}
-
-func parseRawTransactionResult(result *rpcmodel.SearchRawTransactionsResult) (*wire.MsgTx, error) {
-	txBytes, err := hex.DecodeString(result.Hex)
-	if err != nil {
-		return nil, errors.Errorf("failed to decode transaction bytes: %s", err)
-	}
-	var tx wire.MsgTx
-	reader := bytes.NewReader(txBytes)
-	err = tx.Deserialize(reader)
-	if err != nil {
-		return nil, errors.Errorf("failed to deserialize transaction: %s", err)
-	}
-	return &tx, nil
-}
-
-func isTxMatured(tx *wire.MsgTx, confirmations uint64) bool {
-	if !tx.IsCoinBase() {
-		return confirmations >= minConfirmations
-	}
-	return confirmations >= ActiveConfig().NetParams().BlockCoinbaseMaturity
-}
-
-func buildUTXOs(txs []*wire.MsgTx) map[wire.Outpoint]*wire.MsgTx {
-	utxos := make(map[wire.Outpoint]*wire.MsgTx)
-	for _, tx := range txs {
-		for i := range tx.TxOut {
-			outpoint := wire.NewOutpoint(tx.TxID(), uint32(i))
-			utxos[*outpoint] = tx
-		}
-	}
-	for _, tx := range txs {
-		for _, input := range tx.TxIn {
-			delete(utxos, input.PreviousOutpoint)
-		}
-	}
-	return utxos
-}

cmd/gencerts/gencerts.go

@@ -6,6 +6,7 @@ package main
 
 import (
 	"fmt"
+	"github.com/pkg/errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -32,7 +33,8 @@ func main() {
 	parser := flags.NewParser(&cfg, flags.Default)
 	_, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			parser.WriteHelp(os.Stderr)
 		}
 		return

cmd/kaspactl/config.go

@@ -6,17 +6,17 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/version"
 	"github.com/pkg/errors"
 	"io/ioutil"
-	"net"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/rpcmodel"
+	"github.com/kaspanet/kaspad/network/rpc/model"
 	"github.com/kaspanet/kaspad/util"
 )
 
@@ -24,7 +24,7 @@ const (
 	// unusableFlags are the command usage flags which this utility are not
 	// able to use. In particular it doesn't support websockets and
 	// consequently notifications.
-	unusableFlags = rpcmodel.UFWebsocketOnly | rpcmodel.UFNotification
+	unusableFlags = model.UFWebsocketOnly | model.UFNotification
 )
 
 var (
@@ -36,11 +36,6 @@ var (
 	activeConfig       *ConfigFlags
 )
 
-// ActiveConfig returns the active configuration struct
-func ActiveConfig() *ConfigFlags {
-	return activeConfig
-}
-
 // listCommands categorizes and lists all of the usable commands along with
 // their one-line usage.
 func listCommands() {
@@ -50,10 +45,10 @@ func listCommands() {
 	)
 
 	// Get a list of registered commands and categorize and filter them.
-	cmdMethods := rpcmodel.RegisteredCmdMethods()
+	cmdMethods := model.RegisteredCmdMethods()
 	categorized := make([][]string, numCategories)
 	for _, method := range cmdMethods {
-		flags, err := rpcmodel.MethodUsageFlags(method)
+		flags, err := model.MethodUsageFlags(method)
 		if err != nil {
 			// This should never happen since the method was just
 			// returned from the package, but be safe.
@@ -65,7 +60,7 @@ func listCommands() {
 			continue
 		}
 
-		usage, err := rpcmodel.MethodUsageText(method)
+		usage, err := model.MethodUsageText(method)
 		if err != nil {
 			// This should never happen since the method was just
 			// returned from the package, but be safe.
@@ -108,28 +103,6 @@ type ConfigFlags struct {
 	config.NetworkFlags
 }
 
-// normalizeAddress returns addr with the passed default port appended if
-// there is not already a port specified.
-func normalizeAddress(addr string, useTestnet, useSimnet, useDevnet bool) string {
-	_, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		var defaultPort string
-		switch {
-		case useDevnet:
-			defaultPort = "16610"
-		case useTestnet:
-			defaultPort = "16210"
-		case useSimnet:
-			defaultPort = "16510"
-		default:
-			defaultPort = "16110"
-		}
-
-		return net.JoinHostPort(addr, defaultPort)
-	}
-	return addr
-}
-
 // cleanAndExpandPath expands environement variables and leading ~ in the
 // passed path, cleans the result, and returns it.
 func cleanAndExpandPath(path string) string {
@@ -172,7 +145,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	preParser := flags.NewParser(preCfg, flags.HelpFlag)
 	_, err := preParser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); ok && flagsErr.Type == flags.ErrHelp {
 			fmt.Fprintln(os.Stderr, err)
 			fmt.Fprintln(os.Stderr, "")
 			fmt.Fprintln(os.Stderr, "The special parameter `-` "+
@@ -188,7 +162,7 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
 	usageMessage := fmt.Sprintf("Use %s -h to show options", appName)
 	if preCfg.ShowVersion {
-		fmt.Println(appName, "version", version())
+		fmt.Println(appName, "version", version.Version())
 		os.Exit(0)
 	}
 
@@ -216,7 +190,7 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	parser := flags.NewParser(activeConfig, flags.Default)
 	err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile)
 	if err != nil {
-		if _, ok := err.(*os.PathError); !ok {
+		if pErr := &(os.PathError{}); !errors.As(err, &pErr) {
 			fmt.Fprintf(os.Stderr, "Error parsing config file: %s\n",
 				err)
 			fmt.Fprintln(os.Stderr, usageMessage)
@@ -227,7 +201,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	// Parse command line options again to ensure they take precedence.
 	remainingArgs, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			fmt.Fprintln(os.Stderr, usageMessage)
 		}
 		return nil, nil, err
@@ -242,8 +217,10 @@ func loadConfig() (*ConfigFlags, []string, error) {
 
 	// Add default port to RPC server based on --testnet and --simnet flags
 	// if needed.
-	activeConfig.RPCServer = normalizeAddress(activeConfig.RPCServer, activeConfig.Testnet,
-		activeConfig.Simnet, activeConfig.Devnet)
+	activeConfig.RPCServer, err = activeConfig.NetParams().NormalizeRPCServerAddress(activeConfig.RPCServer)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	return activeConfig, remainingArgs, nil
 }

cmd/kaspactl/httpclient.go

@@ -11,7 +11,7 @@ import (
 	"net/http"
 
 	"github.com/btcsuite/go-socks/socks"
-	"github.com/kaspanet/kaspad/rpcmodel"
+	"github.com/kaspanet/kaspad/network/rpc/model"
 )
 
 // newHTTPClient returns a new HTTP client that is configured according to the
@@ -95,11 +95,12 @@ func sendPostRequest(marshalledJSON []byte, cfg *ConfigFlags) ([]byte, error) {
 	}
 
 	// Read the raw bytes and close the response.
-	respBytes, err := ioutil.ReadAll(httpResponse.Body)
-	httpResponse.Body.Close()
+	respBytes, err := func() ([]byte, error) {
+		defer httpResponse.Body.Close()
+		return ioutil.ReadAll(httpResponse.Body)
+	}()
 	if err != nil {
-		err = errors.Errorf("error reading json reply: %s", err)
-		return nil, err
+		return nil, errors.Wrap(err, "error reading json reply")
 	}
 
 	// Handle unsuccessful HTTP responses
@@ -116,7 +117,7 @@ func sendPostRequest(marshalledJSON []byte, cfg *ConfigFlags) ([]byte, error) {
 	}
 
 	// Unmarshal the response.
-	var resp rpcmodel.Response
+	var resp model.Response
 	if err := json.Unmarshal(respBytes, &resp); err != nil {
 		return nil, err
 	}

cmd/kaspactl/kaspactl.go

@@ -5,12 +5,13 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/kaspanet/kaspad/rpcmodel"
+	"github.com/kaspanet/kaspad/network/rpc/model"
 )
 
 const (
@@ -20,7 +21,7 @@ const (
 
 // commandUsage display the usage for a specific command.
 func commandUsage(method string) {
-	usage, err := rpcmodel.MethodUsageText(method)
+	usage, err := model.MethodUsageText(method)
 	if err != nil {
 		// This should never happen since the method was already checked
 		// before calling this function, but be safe.
@@ -59,7 +60,7 @@ func main() {
 	// Ensure the specified method identifies a valid registered command and
 	// is one of the usable types.
 	method := args[0]
-	usageFlags, err := rpcmodel.MethodUsageFlags(method)
+	usageFlags, err := model.MethodUsageFlags(method)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Unrecognized command '%s'\n", method)
 		fmt.Fprintln(os.Stderr, listCmdMessage)
@@ -104,20 +105,21 @@ func main() {
 
 	// Attempt to create the appropriate command using the arguments
 	// provided by the user.
-	cmd, err := rpcmodel.NewCommand(method, params...)
+	cmd, err := model.NewCommand(method, params...)
 	if err != nil {
 		// Show the error along with its error code when it's a
-		// rpcmodel.Error as it reallistcally will always be since the
+		// model.Error as it reallistcally will always be since the
 		// NewCommand function is only supposed to return errors of that
 		// type.
-		if jerr, ok := err.(rpcmodel.Error); ok {
+		var rpcModelErr model.Error
+		if ok := errors.As(err, &rpcModelErr); ok {
 			fmt.Fprintf(os.Stderr, "%s error: %s (command code: %s)\n",
-				method, err, jerr.ErrorCode)
+				method, err, rpcModelErr.ErrorCode)
 			commandUsage(method)
 			os.Exit(1)
 		}
 
-		// The error is not a rpcmodel.Error and this really should not
+		// The error is not a model.Error and this really should not
 		// happen. Nevertheless, fallback to just showing the error
 		// if it should happen due to a bug in the package.
 		fmt.Fprintf(os.Stderr, "%s error: %s\n", method, err)
@@ -127,7 +129,7 @@ func main() {
 
 	// Marshal the command into a JSON-RPC byte slice in preparation for
 	// sending it to the RPC server.
-	marshalledJSON, err := rpcmodel.MarshalCommand(1, cmd)
+	marshalledJSON, err := model.MarshalCommand(1, cmd)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)

cmd/kaspactl/version.go

@@ -1,75 +0,0 @@
-// Copyright (c) 2013 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-)
-
-// semanticAlphabet
-const semanticAlphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-"
-
-// These constants define the application version and follow the semantic
-// versioning 2.0.0 spec (http://semver.org/).
-const (
-	appMajor uint = 0
-	appMinor uint = 12
-	appPatch uint = 0
-
-	// appPreRelease MUST only contain characters from semanticAlphabet
-	// per the semantic versioning spec.
-	appPreRelease = "beta"
-)
-
-// appBuild is defined as a variable so it can be overridden during the build
-// process with '-ldflags "-X main.appBuild foo' if needed. It MUST only
-// contain characters from semanticAlphabet per the semantic versioning spec.
-var appBuild string
-
-// version returns the application version as a properly formed string per the
-// semantic versioning 2.0.0 spec (http://semver.org/).
-func version() string {
-	// Start with the major, minor, and patch versions.
-	version := fmt.Sprintf("%d.%d.%d", appMajor, appMinor, appPatch)
-
-	// Append pre-release version if there is one. The hyphen called for
-	// by the semantic versioning spec is automatically appended and should
-	// not be contained in the pre-release string. The pre-release version
-	// is not appended if it contains invalid characters.
-	preRelease := normalizeVerString(appPreRelease)
-	if preRelease != "" {
-		version = fmt.Sprintf("%s-%s", version, preRelease)
-	}
-
-	// Append build metadata if there is any. The plus called for
-	// by the semantic versioning spec is automatically appended and should
-	// not be contained in the build metadata string. The build metadata
-	// string is not appended if it contains invalid characters.
-	build := normalizeVerString(appBuild)
-	if build != "" {
-		version = fmt.Sprintf("%s+%s", version, build)
-	}
-
-	return version
-}
-
-// normalizeVerString returns the passed string stripped of all characters which
-// are not valid according to the semantic versioning guidelines for pre-release
-// version and build metadata strings. In particular they MUST only contain
-// characters in semanticAlphabet.
-func normalizeVerString(str string) string {
-	var result bytes.Buffer
-	for _, r := range str {
-		if strings.ContainsRune(semanticAlphabet, r) {
-			// Ignoring the error here since it can only fail if
-			// the the system is out of memory and there are much
-			// bigger issues at that point.
-			_, _ = result.WriteRune(r)
-		}
-	}
-	return result.String()
-}

cmd/kaspaminer/client.go

@@ -1,40 +1,39 @@
 package main
 
 import (
-	"github.com/kaspanet/kaspad/rpcclient"
+	"github.com/kaspanet/kaspad/network/domainmessage"
+	"github.com/kaspanet/kaspad/network/rpc/client"
 	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
 	"github.com/pkg/errors"
 	"io/ioutil"
-	"net"
 	"time"
 )
 
 type minerClient struct {
-	*rpcclient.Client
+	*client.Client
 	onBlockAdded chan struct{}
 }
 
-func newMinerClient(connCfg *rpcclient.ConnConfig) (*minerClient, error) {
-	client := &minerClient{
+func newMinerClient(connCfg *client.ConnConfig) (*minerClient, error) {
+	minerClient := &minerClient{
 		onBlockAdded: make(chan struct{}, 1),
 	}
-	notificationHandlers := &rpcclient.NotificationHandlers{
-		OnFilteredBlockAdded: func(_ uint64, header *wire.BlockHeader,
+	notificationHandlers := &client.NotificationHandlers{
+		OnFilteredBlockAdded: func(_ uint64, header *domainmessage.BlockHeader,
 			txs []*util.Tx) {
-			client.onBlockAdded <- struct{}{}
+			minerClient.onBlockAdded <- struct{}{}
 		},
 	}
 	var err error
-	client.Client, err = rpcclient.New(connCfg, notificationHandlers)
+	minerClient.Client, err = client.New(connCfg, notificationHandlers)
 	if err != nil {
 		return nil, errors.Errorf("Error connecting to address %s: %s", connCfg.Host, err)
 	}
 
-	if err = client.NotifyBlocks(); err != nil {
-		return nil, errors.Errorf("Error while registering client %s for block notifications: %s", client.Host(), err)
+	if err = minerClient.NotifyBlocks(); err != nil {
+		return nil, errors.Wrapf(err, "error while registering minerClient %s for block notifications", minerClient.Host())
 	}
-	return client, nil
+	return minerClient, nil
 }
 
 func connectToServer(cfg *configFlags) (*minerClient, error) {
@@ -43,8 +42,13 @@ func connectToServer(cfg *configFlags) (*minerClient, error) {
 		return nil, err
 	}
 
-	connCfg := &rpcclient.ConnConfig{
-		Host:           normalizeRPCServerAddress(cfg.RPCServer, cfg),
+	rpcAddr, err := cfg.NetParams().NormalizeRPCServerAddress(cfg.RPCServer)
+	if err != nil {
+		return nil, err
+	}
+
+	connCfg := &client.ConnConfig{
+		Host:           rpcAddr,
 		Endpoint:       "ws",
 		User:           cfg.RPCUser,
 		Pass:           cfg.RPCPassword,
@@ -63,16 +67,6 @@ func connectToServer(cfg *configFlags) (*minerClient, error) {
 	return client, nil
 }
 
-// normalizeRPCServerAddress returns addr with the current network default
-// port appended if there is not already a port specified.
-func normalizeRPCServerAddress(addr string, cfg *configFlags) string {
-	_, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		return net.JoinHostPort(addr, cfg.NetParams().RPCPort)
-	}
-	return addr
-}
-
 func readCert(cfg *configFlags) ([]byte, error) {
 	if cfg.DisableTLS {
 		return nil, nil

cmd/kaspaminer/config.go

@@ -2,16 +2,18 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/config"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 
+	"github.com/kaspanet/kaspad/infrastructure/config"
+
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/cmd/kaspaminer/version"
+	"github.com/kaspanet/kaspad/version"
 )
 
 const (
@@ -28,15 +30,18 @@ var (
 )
 
 type configFlags struct {
-	ShowVersion    bool   `short:"V" long:"version" description:"Display version information and exit"`
-	RPCUser        string `short:"u" long:"rpcuser" description:"RPC username"`
-	RPCPassword    string `short:"P" long:"rpcpass" default-mask:"-" description:"RPC password"`
-	RPCServer      string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
-	RPCCert        string `short:"c" long:"rpccert" description:"RPC server certificate chain for validation"`
-	DisableTLS     bool   `long:"notls" description:"Disable TLS"`
-	Verbose        bool   `long:"verbose" short:"v" description:"Enable logging of RPC requests"`
-	NumberOfBlocks uint64 `short:"n" long:"numblocks" description:"Number of blocks to mine. If omitted, will mine until the process is interrupted."`
-	BlockDelay     uint64 `long:"block-delay" description:"Delay for block submission (in milliseconds). This is used only for testing purposes."`
+	ShowVersion       bool   `short:"V" long:"version" description:"Display version information and exit"`
+	RPCUser           string `short:"u" long:"rpcuser" description:"RPC username"`
+	RPCPassword       string `short:"P" long:"rpcpass" default-mask:"-" description:"RPC password"`
+	RPCServer         string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
+	RPCCert           string `short:"c" long:"rpccert" description:"RPC server certificate chain for validation"`
+	DisableTLS        bool   `long:"notls" description:"Disable TLS"`
+	MiningAddr        string `long:"miningaddr" description:"Address to mine to"`
+	Verbose           bool   `long:"verbose" short:"v" description:"Enable logging of RPC requests"`
+	NumberOfBlocks    uint64 `short:"n" long:"numblocks" description:"Number of blocks to mine. If omitted, will mine until the process is interrupted."`
+	BlockDelay        uint64 `long:"block-delay" description:"Delay for block submission (in milliseconds). This is used only for testing purposes."`
+	MineWhenNotSynced bool   `long:"mine-when-not-synced" description:"Mine even if the node is not synced with the rest of the network."`
+	Profile           string `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65536"`
 	config.NetworkFlags
 }
 
@@ -72,12 +77,19 @@ func parseConfig() (*configFlags, error) {
 	}
 
 	if cfg.RPCCert == "" && !cfg.DisableTLS {
-		return nil, errors.New("--notls has to be disabled if --cert is used")
+		return nil, errors.New("either --notls or --rpccert must be specified")
 	}
 	if cfg.RPCCert != "" && cfg.DisableTLS {
 		return nil, errors.New("--rpccert should be omitted if --notls is used")
 	}
 
+	if cfg.Profile != "" {
+		profilePort, err := strconv.Atoi(cfg.Profile)
+		if err != nil || profilePort < 1024 || profilePort > 65535 {
+			return nil, errors.New("The profile port must be between 1024 and 65535")
+		}
+	}
+
 	initLog(defaultLogFile, defaultErrLogFile)
 
 	return cfg, nil

cmd/kaspaminer/docker/Dockerfile

@@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.13-alpine AS build
+FROM golang:1.14-alpine AS build
 
 RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 
@@ -20,7 +20,7 @@ WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspaminer
 RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
 RUN go vet ./...
 RUN golint -set_exit_status ./...
-RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o kaspaminer .
+RUN GOOS=linux go build -a -installsuffix cgo -o kaspaminer .
 
 # --- multistage docker build: stage #2: runtime image
 FROM alpine

cmd/kaspaminer/log.go

@@ -2,8 +2,8 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/logs"
-	"github.com/kaspanet/kaspad/rpcclient"
+	"github.com/kaspanet/kaspad/infrastructure/logs"
+	"github.com/kaspanet/kaspad/network/rpc/client"
 	"github.com/kaspanet/kaspad/util/panics"
 	"os"
 )
@@ -28,7 +28,5 @@ func initLog(logFile, errLogFile string) {
 }
 
 func enableRPCLogging() {
-	rpclog := backendLog.Logger("RPCC")
-	rpclog.SetLevel(logs.LevelTrace)
-	rpcclient.UseLogger(rpclog)
+	client.UseLogger(backendLog, logs.LevelTrace)
 }

cmd/kaspaminer/main.go

@@ -2,17 +2,22 @@ package main
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/util"
 	"os"
 
+	"github.com/kaspanet/kaspad/version"
+
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/cmd/kaspaminer/version"
-	"github.com/kaspanet/kaspad/signal"
+	_ "net/http/pprof"
+
+	"github.com/kaspanet/kaspad/infrastructure/signal"
 	"github.com/kaspanet/kaspad/util/panics"
+	"github.com/kaspanet/kaspad/util/profiling"
 )
 
 func main() {
-	defer panics.HandlePanic(log, nil, nil)
+	defer panics.HandlePanic(log, "MAIN", nil)
 	interrupt := signal.InterruptListener()
 
 	cfg, err := parseConfig()
@@ -28,17 +33,27 @@ func main() {
 		enableRPCLogging()
 	}
 
+	// Enable http profiling server if requested.
+	if cfg.Profile != "" {
+		profiling.Start(cfg.Profile, log)
+	}
+
 	client, err := connectToServer(cfg)
 	if err != nil {
-		panic(errors.Wrap(err, "Error connecting to the RPC server"))
+		panic(errors.Wrap(err, "error connecting to the RPC server"))
 	}
 	defer client.Disconnect()
 
+	miningAddr, err := util.DecodeAddress(cfg.MiningAddr, cfg.ActiveNetParams.Prefix)
+	if err != nil {
+		panic(errors.Wrap(err, "error decoding mining address"))
+	}
+
 	doneChan := make(chan struct{})
-	spawn(func() {
-		err = mineLoop(client, cfg.NumberOfBlocks, cfg.BlockDelay)
+	spawn("mineLoop", func() {
+		err = mineLoop(client, cfg.NumberOfBlocks, cfg.BlockDelay, cfg.MineWhenNotSynced, miningAddr)
 		if err != nil {
-			panic(errors.Errorf("Error in mine loop: %s", err))
+			panic(errors.Wrap(err, "error in mine loop"))
 		}
 		doneChan <- struct{}{}
 	})

cmd/kaspaminer/mineloop.go

@@ -1,41 +1,41 @@
 package main
 
 import (
-	"encoding/hex"
 	nativeerrors "errors"
 	"math/rand"
-	"strconv"
-	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/pkg/errors"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/rpcmodel"
+	clientpkg "github.com/kaspanet/kaspad/network/rpc/client"
+	"github.com/kaspanet/kaspad/network/rpc/model"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
 )
 
 var random = rand.New(rand.NewSource(time.Now().UnixNano()))
+var hashesTried uint64
+
+const logHashRateInterval = 10 * time.Second
+
+func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64, mineWhenNotSynced bool,
+	miningAddr util.Address) error {
 
-func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64) error {
 	errChan := make(chan error)
 
 	templateStopChan := make(chan struct{})
 
 	doneChan := make(chan struct{})
-	spawn(func() {
+	spawn("mineLoop-internalLoop", func() {
 		wg := sync.WaitGroup{}
 		for i := uint64(0); numberOfBlocks == 0 || i < numberOfBlocks; i++ {
 			foundBlock := make(chan *util.Block)
-			mineNextBlock(client, foundBlock, templateStopChan, errChan)
+			mineNextBlock(client, miningAddr, foundBlock, mineWhenNotSynced, templateStopChan, errChan)
 			block := <-foundBlock
 			templateStopChan <- struct{}{}
 			wg.Add(1)
-			spawn(func() {
+			spawn("mineLoop-handleFoundBlock", func() {
 				if blockDelay != 0 {
 					time.Sleep(time.Duration(blockDelay) * time.Millisecond)
 				}
@@ -50,6 +50,8 @@ func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64) err
 		doneChan <- struct{}{}
 	})
 
+	logHashRate()
+
 	select {
 	case err := <-errChan:
 		return err
@@ -58,79 +60,56 @@ func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64) err
 	}
 }
 
-func mineNextBlock(client *minerClient, foundBlock chan *util.Block, templateStopChan chan struct{}, errChan chan error) {
-	newTemplateChan := make(chan *rpcmodel.GetBlockTemplateResult)
-	go templatesLoop(client, newTemplateChan, errChan, templateStopChan)
-	go solveLoop(newTemplateChan, foundBlock, errChan)
+func logHashRate() {
+	spawn("logHashRate", func() {
+		lastCheck := time.Now()
+		for range time.Tick(logHashRateInterval) {
+			currentHashesTried := hashesTried
+			currentTime := time.Now()
+			kiloHashesTried := float64(currentHashesTried) / 1000.0
+			hashRate := kiloHashesTried / currentTime.Sub(lastCheck).Seconds()
+			log.Infof("Current hash rate is %.2f Khash/s", hashRate)
+			lastCheck = currentTime
+			// subtract from hashesTried the hashes we already sampled
+			atomic.AddUint64(&hashesTried, -currentHashesTried)
+		}
+	})
+}
+
+func mineNextBlock(client *minerClient, miningAddr util.Address, foundBlock chan *util.Block, mineWhenNotSynced bool,
+	templateStopChan chan struct{}, errChan chan error) {
+
+	newTemplateChan := make(chan *model.GetBlockTemplateResult)
+	spawn("templatesLoop", func() {
+		templatesLoop(client, miningAddr, newTemplateChan, errChan, templateStopChan)
+	})
+	spawn("solveLoop", func() {
+		solveLoop(newTemplateChan, foundBlock, mineWhenNotSynced, errChan)
+	})
 }
 
 func handleFoundBlock(client *minerClient, block *util.Block) error {
 	log.Infof("Found block %s with parents %s. Submitting to %s", block.Hash(), block.MsgBlock().Header.ParentHashes, client.Host())
 
-	err := client.SubmitBlock(block, &rpcmodel.SubmitBlockOptions{})
+	err := client.SubmitBlock(block, &model.SubmitBlockOptions{})
 	if err != nil {
 		return errors.Errorf("Error submitting block %s to %s: %s", block.Hash(), client.Host(), err)
 	}
 	return nil
 }
 
-func parseBlock(template *rpcmodel.GetBlockTemplateResult) (*util.Block, error) {
-	// parse parent hashes
-	parentHashes := make([]*daghash.Hash, len(template.ParentHashes))
-	for i, parentHash := range template.ParentHashes {
-		hash, err := daghash.NewHashFromStr(parentHash)
-		if err != nil {
-			return nil, errors.Errorf("Error decoding hash %s: %s", parentHash, err)
-		}
-		parentHashes[i] = hash
-	}
-
-	// parse Bits
-	bitsUint64, err := strconv.ParseUint(template.Bits, 16, 32)
-	if err != nil {
-		return nil, errors.Errorf("Error decoding bits %s: %s", template.Bits, err)
-	}
-	bits := uint32(bitsUint64)
-
-	// parseAcceptedIDMerkleRoot
-	acceptedIDMerkleRoot, err := daghash.NewHashFromStr(template.AcceptedIDMerkleRoot)
-	if err != nil {
-		return nil, errors.Errorf("Error parsing acceptedIDMerkleRoot: %s", err)
-	}
-	utxoCommitment, err := daghash.NewHashFromStr(template.UTXOCommitment)
-	if err != nil {
-		return nil, errors.Errorf("Error parsing utxoCommitment: %s", err)
-	}
-	// parse rest of block
-	msgBlock := wire.NewMsgBlock(
-		wire.NewBlockHeader(template.Version, parentHashes, &daghash.Hash{},
-			acceptedIDMerkleRoot, utxoCommitment, bits, 0))
-
-	for i, txResult := range append([]rpcmodel.GetBlockTemplateResultTx{*template.CoinbaseTxn}, template.Transactions...) {
-		reader := hex.NewDecoder(strings.NewReader(txResult.Data))
-		tx := &wire.MsgTx{}
-		if err := tx.KaspaDecode(reader, 0); err != nil {
-			return nil, errors.Errorf("Error decoding tx #%d: %s", i, err)
-		}
-		msgBlock.AddTransaction(tx)
-	}
-
-	block := util.NewBlock(msgBlock)
-	msgBlock.Header.HashMerkleRoot = blockdag.BuildHashMerkleTreeStore(block.Transactions()).Root()
-	return block, nil
-}
-
 func solveBlock(block *util.Block, stopChan chan struct{}, foundBlock chan *util.Block) {
 	msgBlock := block.MsgBlock()
 	targetDifficulty := util.CompactToBig(msgBlock.Header.Bits)
 	initialNonce := random.Uint64()
-	for i := random.Uint64(); i != initialNonce-1; i++ {
+	for i := initialNonce; i != initialNonce-1; i++ {
 		select {
 		case <-stopChan:
 			return
 		default:
 			msgBlock.Header.Nonce = i
 			hash := msgBlock.BlockHash()
+			atomic.AddUint64(&hashesTried, 1)
 			if daghash.HashToBig(hash).Cmp(targetDifficulty) <= 0 {
 				foundBlock <- block
 				return
@@ -140,7 +119,9 @@ func solveBlock(block *util.Block, stopChan chan struct{}, foundBlock chan *util
 
 }
 
-func templatesLoop(client *minerClient, newTemplateChan chan *rpcmodel.GetBlockTemplateResult, errChan chan error, stopChan chan struct{}) {
+func templatesLoop(client *minerClient, miningAddr util.Address,
+	newTemplateChan chan *model.GetBlockTemplateResult, errChan chan error, stopChan chan struct{}) {
+
 	longPollID := ""
 	getBlockTemplateLongPoll := func() {
 		if longPollID != "" {
@@ -148,8 +129,8 @@ func templatesLoop(client *minerClient, newTemplateChan chan *rpcmodel.GetBlockT
 		} else {
 			log.Infof("Requesting template without longPollID from %s", client.Host())
 		}
-		template, err := getBlockTemplate(client, longPollID)
-		if nativeerrors.Is(err, rpcclient.ErrResponseTimedOut) {
+		template, err := getBlockTemplate(client, miningAddr, longPollID)
+		if nativeerrors.Is(err, clientpkg.ErrResponseTimedOut) {
 			log.Infof("Got timeout while requesting template '%s' from %s", longPollID, client.Host())
 			return
 		} else if err != nil {
@@ -176,24 +157,37 @@ func templatesLoop(client *minerClient, newTemplateChan chan *rpcmodel.GetBlockT
 	}
 }
 
-func getBlockTemplate(client *minerClient, longPollID string) (*rpcmodel.GetBlockTemplateResult, error) {
-	return client.GetBlockTemplate([]string{"coinbasetxn"}, longPollID)
+func getBlockTemplate(client *minerClient, miningAddr util.Address, longPollID string) (*model.GetBlockTemplateResult, error) {
+	return client.GetBlockTemplate(miningAddr.String(), longPollID)
 }
 
-func solveLoop(newTemplateChan chan *rpcmodel.GetBlockTemplateResult, foundBlock chan *util.Block, errChan chan error) {
+func solveLoop(newTemplateChan chan *model.GetBlockTemplateResult, foundBlock chan *util.Block,
+	mineWhenNotSynced bool, errChan chan error) {
+
 	var stopOldTemplateSolving chan struct{}
 	for template := range newTemplateChan {
 		if stopOldTemplateSolving != nil {
 			close(stopOldTemplateSolving)
 		}
+
+		if !template.IsSynced {
+			if !mineWhenNotSynced {
+				errChan <- errors.Errorf("got template with isSynced=false")
+				return
+			}
+			log.Warnf("Got template with isSynced=false")
+		}
+
 		stopOldTemplateSolving = make(chan struct{})
-		block, err := parseBlock(template)
+		block, err := clientpkg.ConvertGetBlockTemplateResultToBlock(template)
 		if err != nil {
 			errChan <- errors.Errorf("Error parsing block: %s", err)
 			return
 		}
 
-		go solveBlock(block, stopOldTemplateSolving, foundBlock)
+		spawn("solveBlock", func() {
+			solveBlock(block, stopOldTemplateSolving, foundBlock)
+		})
 	}
 	if stopOldTemplateSolving != nil {
 		close(stopOldTemplateSolving)

cmd/kaspaminer/version/version.go

@@ -1,50 +0,0 @@
-package version
-
-import (
-	"fmt"
-	"strings"
-)
-
-// validCharacters  is a list of characters valid in the appBuild string
-const validCharacters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-"
-
-const (
-	appMajor uint = 0
-	appMinor uint = 1
-	appPatch uint = 0
-)
-
-// appBuild is defined as a variable so it can be overridden during the build
-// process with '-ldflags "-X github.com/kaspanet/kaspad/cmd/kaspaminer/version.appBuild=foo"' if needed.
-// It MUST only contain characters from validCharacters.
-var appBuild string
-
-var version = "" // string used for memoization of version
-
-// Version returns the application version as a properly formed string
-func Version() string {
-	if version == "" {
-		// Start with the major, minor, and patch versions.
-		version = fmt.Sprintf("%d.%d.%d", appMajor, appMinor, appPatch)
-
-		// Append build metadata if there is any.
-		// Panic if any invalid characters are encountered
-		if appBuild != "" {
-			checkAppBuild(appBuild)
-
-			version = fmt.Sprintf("%s-%s", version, appBuild)
-		}
-	}
-
-	return version
-}
-
-// checkAppBuild verifies that appBuild does not contain any characters outside of validCharacters.
-// In case of any invalid characters checkAppBuild panics
-func checkAppBuild(appBuild string) {
-	for _, r := range appBuild {
-		if !strings.ContainsRune(validCharacters, r) {
-			panic(fmt.Errorf("appBuild string (%s) contains forbidden characters. Only alphanumeric characters and dashes are allowed", appBuild))
-		}
-	}
-}

cmd/txsigner/config.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/infrastructure/config"
 )
 
 var activeConfig *ConfigFlags

cmd/txsigner/txsigner.go

@@ -4,10 +4,11 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/txscript"
+	"github.com/kaspanet/go-secp256k1"
+	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/network/domainmessage"
 	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
 	"os"
 )
 
@@ -27,7 +28,11 @@ func main() {
 		printErrorAndExit(err, "Failed to decode transaction")
 	}
 
-	scriptPubKey, err := createScriptPubKey(privateKey.PubKey())
+	pubkey, err := privateKey.SchnorrPublicKey()
+	if err != nil {
+		printErrorAndExit(err, "Failed to generate a public key")
+	}
+	scriptPubKey, err := createScriptPubKey(pubkey)
 	if err != nil {
 		printErrorAndExit(err, "Failed to create scriptPubKey")
 	}
@@ -45,26 +50,38 @@ func main() {
 	fmt.Printf("Signed Transaction (hex): %s\n\n", serializedTransaction)
 }
 
-func parsePrivateKey(privateKeyHex string) (*ecc.PrivateKey, error) {
+func parsePrivateKey(privateKeyHex string) (*secp256k1.PrivateKey, error) {
 	privateKeyBytes, err := hex.DecodeString(privateKeyHex)
-	privateKey, _ := ecc.PrivKeyFromBytes(ecc.S256(), privateKeyBytes)
-	return privateKey, err
+	if err != nil {
+		return nil, errors.Errorf("'%s' isn't a valid hex. err: '%s' ", privateKeyHex, err)
+	}
+	return secp256k1.DeserializePrivateKeyFromSlice(privateKeyBytes)
 }
 
-func parseTransaction(transactionHex string) (*wire.MsgTx, error) {
+func parseTransaction(transactionHex string) (*domainmessage.MsgTx, error) {
 	serializedTx, err := hex.DecodeString(transactionHex)
-	var transaction wire.MsgTx
+	if err != nil {
+		return nil, errors.Wrap(err, "couldn't decode transaction hex")
+	}
+	var transaction domainmessage.MsgTx
 	err = transaction.Deserialize(bytes.NewReader(serializedTx))
 	return &transaction, err
 }
 
-func createScriptPubKey(publicKey *ecc.PublicKey) ([]byte, error) {
-	p2pkhAddress, err := util.NewAddressPubKeyHashFromPublicKey(publicKey.SerializeCompressed(), ActiveConfig().NetParams().Prefix)
+func createScriptPubKey(publicKey *secp256k1.SchnorrPublicKey) ([]byte, error) {
+	serializedKey, err := publicKey.SerializeCompressed()
+	if err != nil {
+		return nil, err
+	}
+	p2pkhAddress, err := util.NewAddressPubKeyHashFromPublicKey(serializedKey, ActiveConfig().NetParams().Prefix)
+	if err != nil {
+		return nil, err
+	}
 	scriptPubKey, err := txscript.PayToAddrScript(p2pkhAddress)
 	return scriptPubKey, err
 }
 
-func signTransaction(transaction *wire.MsgTx, privateKey *ecc.PrivateKey, scriptPubKey []byte) error {
+func signTransaction(transaction *domainmessage.MsgTx, privateKey *secp256k1.PrivateKey, scriptPubKey []byte) error {
 	for i, transactionInput := range transaction.TxIn {
 		signatureScript, err := txscript.SignatureScript(transaction, i, scriptPubKey, txscript.SigHashAll, privateKey, true)
 		if err != nil {
@@ -75,7 +92,7 @@ func signTransaction(transaction *wire.MsgTx, privateKey *ecc.PrivateKey, script
 	return nil
 }
 
-func serializeTransaction(transaction *wire.MsgTx) (string, error) {
+func serializeTransaction(transaction *domainmessage.MsgTx) (string, error) {
 	buf := bytes.NewBuffer(make([]byte, 0, transaction.SerializeSize()))
 	err := transaction.Serialize(buf)
 	serializedTransaction := hex.EncodeToString(buf.Bytes())

connmgr/README.md

@@ -1,27 +0,0 @@
-connmgr
-=======
-
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/connmgr)
-
-Package connmgr implements a generic Kaspa network connection manager.
-
-## Overview
-
-Connection Manager handles all the general connection concerns such as
-maintaining a set number of outbound connections, sourcing peers, banning,
-limiting max connections, etc.
-
-The package provides a generic connection manager which is able to accept
-connection requests from a source or a set of given addresses, dial them and
-notify the caller on connections. The main intended use is to initialize a pool
-of active connections and maintain them to remain connected to the P2P network.
-
-In addition the connection manager provides the following utilities:
-
-- Notifications on connections or disconnections
-- Handle failures and retry new addresses from the source
-- Connect only to specified addresses
-- Permanent connections with increasing backoff retry timers
-- Disconnect or Remove an established connection
-

connmgr/connmanager.go

@@ -1,648 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package connmgr
-
-import (
-	nativeerrors "errors"
-	"fmt"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/pkg/errors"
-)
-
-// maxFailedAttempts is the maximum number of successive failed connection
-// attempts after which network failure is assumed and new connections will
-// be delayed by the configured retry duration.
-const maxFailedAttempts = 25
-
-var (
-	// maxRetryDuration is the max duration of time retrying of a persistent
-	// connection is allowed to grow to. This is necessary since the retry
-	// logic uses a backoff mechanism which increases the interval base times
-	// the number of retries that have been done.
-	maxRetryDuration = time.Minute * 5
-
-	// defaultRetryDuration is the default duration of time for retrying
-	// persistent connections.
-	defaultRetryDuration = time.Second * 5
-
-	// defaultTargetOutbound is the default number of outbound connections to
-	// maintain.
-	defaultTargetOutbound = uint32(8)
-)
-
-var (
-	//ErrDialNil is used to indicate that Dial cannot be nil in the configuration.
-	ErrDialNil = errors.New("Config: Dial cannot be nil")
-
-	// ErrMaxOutboundPeers is an error that is thrown when the max amount of peers had
-	// been reached.
-	ErrMaxOutboundPeers = errors.New("max outbound peers reached")
-
-	// ErrAlreadyConnected is an error that is thrown if the peer is already
-	// connected.
-	ErrAlreadyConnected = errors.New("peer already connected")
-
-	// ErrAlreadyPermanent is an error that is thrown if the peer is already
-	// connected as a permanent peer.
-	ErrAlreadyPermanent = errors.New("peer exists as a permanent peer")
-
-	// ErrPeerNotFound is an error that is thrown if the peer was not found.
-	ErrPeerNotFound = errors.New("peer not found")
-)
-
-// ConnState represents the state of the requested connection.
-type ConnState uint8
-
-// ConnState can be either pending, established, disconnected or failed. When
-// a new connection is requested, it is attempted and categorized as
-// established or failed depending on the connection result. An established
-// connection which was disconnected is categorized as disconnected.
-const (
-	ConnPending ConnState = iota
-	ConnFailing
-	ConnCanceled
-	ConnEstablished
-	ConnDisconnected
-)
-
-// ConnReq is the connection request to a network address. If permanent, the
-// connection will be retried on disconnection.
-type ConnReq struct {
-	// The following variables must only be used atomically.
-	id uint64
-
-	Addr      net.Addr
-	Permanent bool
-
-	conn       net.Conn
-	state      ConnState
-	stateMtx   sync.RWMutex
-	retryCount uint32
-}
-
-// updateState updates the state of the connection request.
-func (c *ConnReq) updateState(state ConnState) {
-	c.stateMtx.Lock()
-	c.state = state
-	c.stateMtx.Unlock()
-}
-
-// ID returns a unique identifier for the connection request.
-func (c *ConnReq) ID() uint64 {
-	return atomic.LoadUint64(&c.id)
-}
-
-// State is the connection state of the requested connection.
-func (c *ConnReq) State() ConnState {
-	c.stateMtx.RLock()
-	state := c.state
-	c.stateMtx.RUnlock()
-	return state
-}
-
-// String returns a human-readable string for the connection request.
-func (c *ConnReq) String() string {
-	if c.Addr == nil || c.Addr.String() == "" {
-		return fmt.Sprintf("reqid %d", atomic.LoadUint64(&c.id))
-	}
-	return fmt.Sprintf("%s (reqid %d)", c.Addr, atomic.LoadUint64(&c.id))
-}
-
-// Config holds the configuration options related to the connection manager.
-type Config struct {
-	// Listeners defines a slice of listeners for which the connection
-	// manager will take ownership of and accept connections. When a
-	// connection is accepted, the OnAccept handler will be invoked with the
-	// connection. Since the connection manager takes ownership of these
-	// listeners, they will be closed when the connection manager is
-	// stopped.
-	//
-	// This field will not have any effect if the OnAccept field is not
-	// also specified. It may be nil if the caller does not wish to listen
-	// for incoming connections.
-	Listeners []net.Listener
-
-	// OnAccept is a callback that is fired when an inbound connection is
-	// accepted. It is the caller's responsibility to close the connection.
-	// Failure to close the connection will result in the connection manager
-	// believing the connection is still active and thus have undesirable
-	// side effects such as still counting toward maximum connection limits.
-	//
-	// This field will not have any effect if the Listeners field is not
-	// also specified since there couldn't possibly be any accepted
-	// connections in that case.
-	OnAccept func(net.Conn)
-
-	// TargetOutbound is the number of outbound network connections to
-	// maintain. Defaults to 8.
-	TargetOutbound uint32
-
-	// RetryDuration is the duration to wait before retrying connection
-	// requests. Defaults to 5s.
-	RetryDuration time.Duration
-
-	// OnConnection is a callback that is fired when a new outbound
-	// connection is established.
-	OnConnection func(*ConnReq, net.Conn)
-
-	// OnDisconnection is a callback that is fired when an outbound
-	// connection is disconnected.
-	OnDisconnection func(*ConnReq)
-
-	// GetNewAddress is a way to get an address to make a network connection
-	// to. If nil, no new connections will be made automatically.
-	GetNewAddress func() (net.Addr, error)
-
-	// Dial connects to the address on the named network. It cannot be nil.
-	Dial func(net.Addr) (net.Conn, error)
-}
-
-// registerPending is used to register a pending connection attempt. By
-// registering pending connection attempts we allow callers to cancel pending
-// connection attempts before their successful or in the case they're not
-// longer wanted.
-type registerPending struct {
-	c    *ConnReq
-	done chan struct{}
-}
-
-// handleConnected is used to queue a successful connection.
-type handleConnected struct {
-	c    *ConnReq
-	conn net.Conn
-}
-
-// handleDisconnected is used to remove a connection.
-type handleDisconnected struct {
-	id    uint64
-	retry bool
-}
-
-// handleFailed is used to remove a pending connection.
-type handleFailed struct {
-	c   *ConnReq
-	err error
-}
-
-// ConnManager provides a manager to handle network connections.
-type ConnManager struct {
-	// The following variables must only be used atomically.
-	connReqCount uint64
-	start        int32
-	stop         int32
-
-	newConnReqMtx sync.Mutex
-
-	cfg            Config
-	wg             sync.WaitGroup
-	failedAttempts uint64
-	requests       chan interface{}
-	quit           chan struct{}
-}
-
-// handleFailedConn handles a connection failed due to a disconnect or any
-// other failure. If permanent, it retries the connection after the configured
-// retry duration. Otherwise, if required, it makes a new connection request.
-// After maxFailedConnectionAttempts new connections will be retried after the
-// configured retry duration.
-func (cm *ConnManager) handleFailedConn(c *ConnReq, err error) {
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		return
-	}
-
-	// Don't write throttled logs more than once every throttledConnFailedLogInterval
-	shouldWriteLog := shouldWriteConnFailedLog(err)
-	if shouldWriteLog {
-		// If we are to write a log, set its lastLogTime to now
-		setConnFailedLastLogTime(err, time.Now())
-	}
-
-	if c.Permanent {
-		c.retryCount++
-		d := time.Duration(c.retryCount) * cm.cfg.RetryDuration
-		if d > maxRetryDuration {
-			d = maxRetryDuration
-		}
-		if shouldWriteLog {
-			log.Debugf("Retrying further connections to %s every %s", c, d)
-		}
-		spawnAfter(d, func() {
-			cm.Connect(c)
-		}, nil)
-	} else if cm.cfg.GetNewAddress != nil {
-		cm.failedAttempts++
-		if cm.failedAttempts >= maxFailedAttempts {
-			if shouldWriteLog {
-				log.Debugf("Max failed connection attempts reached: [%d] "+
-					"-- retrying further connections every %s", maxFailedAttempts,
-					cm.cfg.RetryDuration)
-			}
-			spawnAfter(cm.cfg.RetryDuration, cm.NewConnReq, cm.handlePanic)
-		} else {
-			spawn(cm.NewConnReq, cm.handlePanic)
-		}
-	}
-}
-
-// throttledError defines an error type whose logs get throttled. This is to
-// prevent flooding the logs with identical errors.
-type throttledError error
-
-var (
-	// throttledConnFailedLogInterval is the minimum duration of time between
-	// the logs defined in throttledConnFailedLogs.
-	throttledConnFailedLogInterval = time.Minute * 10
-
-	// throttledConnFailedLogs are logs that get written at most every
-	// throttledConnFailedLogInterval. Each entry in this map defines a type
-	// of error that we want to throttle. The value of each entry is the last
-	// time that type of log had been written.
-	throttledConnFailedLogs = map[throttledError]time.Time{
-		ErrNoAddress: {},
-	}
-
-	// ErrNoAddress is an error that is thrown when there aren't any
-	// valid connection addresses.
-	ErrNoAddress throttledError = errors.New("no valid connect address")
-)
-
-// shouldWriteConnFailedLog resolves whether to write logs related to connection
-// failures. Errors that had not been previously registered in throttledConnFailedLogs
-// and non-error (nil values) must always be logged.
-func shouldWriteConnFailedLog(err error) bool {
-	if err == nil {
-		return true
-	}
-	lastLogTime, ok := throttledConnFailedLogs[err]
-	return !ok || lastLogTime.Add(throttledConnFailedLogInterval).Before(time.Now())
-}
-
-// setConnFailedLastLogTime sets the last log time of the specified error
-func setConnFailedLastLogTime(err error, lastLogTime time.Time) {
-	var throttledErr throttledError
-	nativeerrors.As(err, &throttledErr)
-	throttledConnFailedLogs[err] = lastLogTime
-}
-
-// connHandler handles all connection related requests. It must be run as a
-// goroutine.
-//
-// The connection handler makes sure that we maintain a pool of active outbound
-// connections so that we remain connected to the network. Connection requests
-// are processed and mapped by their assigned ids.
-func (cm *ConnManager) connHandler() {
-
-	var (
-		// pending holds all registered conn requests that have yet to
-		// succeed.
-		pending = make(map[uint64]*ConnReq)
-
-		// conns represents the set of all actively connected peers.
-		conns = make(map[uint64]*ConnReq, cm.cfg.TargetOutbound)
-	)
-
-out:
-	for {
-		select {
-		case req := <-cm.requests:
-			switch msg := req.(type) {
-
-			case registerPending:
-				connReq := msg.c
-				connReq.updateState(ConnPending)
-				pending[msg.c.id] = connReq
-				close(msg.done)
-
-			case handleConnected:
-				connReq := msg.c
-
-				if _, ok := pending[connReq.id]; !ok {
-					if msg.conn != nil {
-						msg.conn.Close()
-					}
-					log.Debugf("Ignoring connection for "+
-						"canceled connreq=%s", connReq)
-					continue
-				}
-
-				connReq.updateState(ConnEstablished)
-				connReq.conn = msg.conn
-				conns[connReq.id] = connReq
-				log.Debugf("Connected to %s", connReq)
-				connReq.retryCount = 0
-				cm.failedAttempts = 0
-
-				delete(pending, connReq.id)
-
-				if cm.cfg.OnConnection != nil {
-					cm.cfg.OnConnection(connReq, msg.conn)
-				}
-
-			case handleDisconnected:
-				connReq, ok := conns[msg.id]
-				if !ok {
-					connReq, ok = pending[msg.id]
-					if !ok {
-						log.Errorf("Unknown connid=%d",
-							msg.id)
-						continue
-					}
-
-					// Pending connection was found, remove
-					// it from pending map if we should
-					// ignore a later, successful
-					// connection.
-					connReq.updateState(ConnCanceled)
-					log.Debugf("Canceling: %s", connReq)
-					delete(pending, msg.id)
-					continue
-
-				}
-
-				// An existing connection was located, mark as
-				// disconnected and execute disconnection
-				// callback.
-				log.Debugf("Disconnected from %s", connReq)
-				delete(conns, msg.id)
-
-				if connReq.conn != nil {
-					connReq.conn.Close()
-				}
-
-				if cm.cfg.OnDisconnection != nil {
-					go cm.cfg.OnDisconnection(connReq)
-				}
-
-				// All internal state has been cleaned up, if
-				// this connection is being removed, we will
-				// make no further attempts with this request.
-				if !msg.retry {
-					connReq.updateState(ConnDisconnected)
-					continue
-				}
-
-				// Otherwise, we will attempt a reconnection if
-				// we do not have enough peers, or if this is a
-				// persistent peer. The connection request is
-				// re added to the pending map, so that
-				// subsequent processing of connections and
-				// failures do not ignore the request.
-				if uint32(len(conns)) < cm.cfg.TargetOutbound ||
-					connReq.Permanent {
-
-					connReq.updateState(ConnPending)
-					log.Debugf("Reconnecting to %s",
-						connReq)
-					pending[msg.id] = connReq
-					cm.handleFailedConn(connReq, nil)
-				}
-
-			case handleFailed:
-				connReq := msg.c
-
-				if _, ok := pending[connReq.id]; !ok {
-					log.Debugf("Ignoring connection for "+
-						"canceled conn req: %s", connReq)
-					continue
-				}
-
-				connReq.updateState(ConnFailing)
-				if shouldWriteConnFailedLog(msg.err) {
-					log.Debugf("Failed to connect to %s: %s",
-						connReq, msg.err)
-				}
-				cm.handleFailedConn(connReq, msg.err)
-			}
-
-		case <-cm.quit:
-			break out
-		}
-	}
-
-	cm.wg.Done()
-	log.Trace("Connection handler done")
-}
-
-// NewConnReq creates a new connection request and connects to the
-// corresponding address.
-func (cm *ConnManager) NewConnReq() {
-	cm.newConnReqMtx.Lock()
-	defer cm.newConnReqMtx.Unlock()
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		return
-	}
-	if cm.cfg.GetNewAddress == nil {
-		return
-	}
-
-	c := &ConnReq{}
-	atomic.StoreUint64(&c.id, atomic.AddUint64(&cm.connReqCount, 1))
-
-	// Submit a request of a pending connection attempt to the connection
-	// manager. By registering the id before the connection is even
-	// established, we'll be able to later cancel the connection via the
-	// Remove method.
-	done := make(chan struct{})
-	select {
-	case cm.requests <- registerPending{c, done}:
-	case <-cm.quit:
-		return
-	}
-
-	// Wait for the registration to successfully add the pending conn req to
-	// the conn manager's internal state.
-	select {
-	case <-done:
-	case <-cm.quit:
-		return
-	}
-
-	addr, err := cm.cfg.GetNewAddress()
-	if err != nil {
-		select {
-		case cm.requests <- handleFailed{c, err}:
-		case <-cm.quit:
-		}
-		return
-	}
-
-	c.Addr = addr
-
-	cm.Connect(c)
-}
-
-// Connect assigns an id and dials a connection to the address of the
-// connection request.
-func (cm *ConnManager) Connect(c *ConnReq) {
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		return
-	}
-	if atomic.LoadUint64(&c.id) == 0 {
-		atomic.StoreUint64(&c.id, atomic.AddUint64(&cm.connReqCount, 1))
-
-		// Submit a request of a pending connection attempt to the
-		// connection manager. By registering the id before the
-		// connection is even established, we'll be able to later
-		// cancel the connection via the Remove method.
-		done := make(chan struct{})
-		select {
-		case cm.requests <- registerPending{c, done}:
-		case <-cm.quit:
-			return
-		}
-
-		// Wait for the registration to successfully add the pending
-		// conn req to the conn manager's internal state.
-		select {
-		case <-done:
-		case <-cm.quit:
-			return
-		}
-	}
-
-	log.Debugf("Attempting to connect to %s", c)
-
-	conn, err := cm.cfg.Dial(c.Addr)
-	if err != nil {
-		select {
-		case cm.requests <- handleFailed{c, err}:
-		case <-cm.quit:
-		}
-		return
-	}
-
-	select {
-	case cm.requests <- handleConnected{c, conn}:
-	case <-cm.quit:
-	}
-}
-
-// Disconnect disconnects the connection corresponding to the given connection
-// id. If permanent, the connection will be retried with an increasing backoff
-// duration.
-func (cm *ConnManager) Disconnect(id uint64) {
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		return
-	}
-
-	select {
-	case cm.requests <- handleDisconnected{id, true}:
-	case <-cm.quit:
-	}
-}
-
-// Remove removes the connection corresponding to the given connection id from
-// known connections.
-//
-// NOTE: This method can also be used to cancel a lingering connection attempt
-// that hasn't yet succeeded.
-func (cm *ConnManager) Remove(id uint64) {
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		return
-	}
-
-	select {
-	case cm.requests <- handleDisconnected{id, false}:
-	case <-cm.quit:
-	}
-}
-
-// listenHandler accepts incoming connections on a given listener. It must be
-// run as a goroutine.
-func (cm *ConnManager) listenHandler(listener net.Listener) {
-	log.Infof("Server listening on %s", listener.Addr())
-	for atomic.LoadInt32(&cm.stop) == 0 {
-		conn, err := listener.Accept()
-		if err != nil {
-			// Only log the error if not forcibly shutting down.
-			if atomic.LoadInt32(&cm.stop) == 0 {
-				log.Errorf("Can't accept connection: %s", err)
-			}
-			continue
-		}
-		go cm.cfg.OnAccept(conn)
-	}
-
-	cm.wg.Done()
-	log.Tracef("Listener handler done for %s", listener.Addr())
-}
-
-// Start launches the connection manager and begins connecting to the network.
-func (cm *ConnManager) Start() {
-	// Already started?
-	if atomic.AddInt32(&cm.start, 1) != 1 {
-		return
-	}
-
-	log.Trace("Connection manager started")
-	cm.wg.Add(1)
-	spawn(cm.connHandler, cm.handlePanic)
-
-	// Start all the listeners so long as the caller requested them and
-	// provided a callback to be invoked when connections are accepted.
-	if cm.cfg.OnAccept != nil {
-		for _, listner := range cm.cfg.Listeners {
-			cm.wg.Add(1)
-			go cm.listenHandler(listner)
-		}
-	}
-
-	for i := atomic.LoadUint64(&cm.connReqCount); i < uint64(cm.cfg.TargetOutbound); i++ {
-		spawn(cm.NewConnReq, cm.handlePanic)
-	}
-}
-
-// Wait blocks until the connection manager halts gracefully.
-func (cm *ConnManager) Wait() {
-	cm.wg.Wait()
-}
-
-func (cm *ConnManager) handlePanic() {
-	atomic.AddInt32(&cm.stop, 1)
-}
-
-// Stop gracefully shuts down the connection manager.
-func (cm *ConnManager) Stop() {
-	if atomic.AddInt32(&cm.stop, 1) != 1 {
-		log.Warnf("Connection manager already stopped")
-		return
-	}
-
-	// Stop all the listeners. There will not be any listeners if
-	// listening is disabled.
-	for _, listener := range cm.cfg.Listeners {
-		// Ignore the error since this is shutdown and there is no way
-		// to recover anyways.
-		_ = listener.Close()
-	}
-
-	close(cm.quit)
-	log.Trace("Connection manager stopped")
-}
-
-// New returns a new connection manager.
-// Use Start to start connecting to the network.
-func New(cfg *Config) (*ConnManager, error) {
-	if cfg.Dial == nil {
-		return nil, ErrDialNil
-	}
-	// Default to sane values
-	if cfg.RetryDuration <= 0 {
-		cfg.RetryDuration = defaultRetryDuration
-	}
-	if cfg.TargetOutbound == 0 {
-		cfg.TargetOutbound = defaultTargetOutbound
-	}
-	cm := ConnManager{
-		cfg:      *cfg, // Copy so caller can't mutate
-		requests: make(chan interface{}),
-		quit:     make(chan struct{}),
-	}
-	return &cm, nil
-}

connmgr/connmanager_test.go

@@ -1,688 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package connmgr
-
-import (
-	"github.com/pkg/errors"
-	"io"
-	"net"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func init() {
-	// Override the max retry duration when running tests.
-	maxRetryDuration = 2 * time.Millisecond
-}
-
-// mockAddr mocks a network address
-type mockAddr struct {
-	net, address string
-}
-
-func (m mockAddr) Network() string { return m.net }
-func (m mockAddr) String() string  { return m.address }
-
-// mockConn mocks a network connection by implementing the net.Conn interface.
-type mockConn struct {
-	io.Reader
-	io.Writer
-	io.Closer
-
-	// local network, address for the connection.
-	lnet, laddr string
-
-	// remote network, address for the connection.
-	rAddr net.Addr
-}
-
-// LocalAddr returns the local address for the connection.
-func (c mockConn) LocalAddr() net.Addr {
-	return &mockAddr{c.lnet, c.laddr}
-}
-
-// RemoteAddr returns the remote address for the connection.
-func (c mockConn) RemoteAddr() net.Addr {
-	return &mockAddr{c.rAddr.Network(), c.rAddr.String()}
-}
-
-// Close handles closing the connection.
-func (c mockConn) Close() error {
-	return nil
-}
-
-func (c mockConn) SetDeadline(t time.Time) error      { return nil }
-func (c mockConn) SetReadDeadline(t time.Time) error  { return nil }
-func (c mockConn) SetWriteDeadline(t time.Time) error { return nil }
-
-// mockDialer mocks the net.Dial interface by returning a mock connection to
-// the given address.
-func mockDialer(addr net.Addr) (net.Conn, error) {
-	r, w := io.Pipe()
-	c := &mockConn{rAddr: addr}
-	c.Reader = r
-	c.Writer = w
-	return c, nil
-}
-
-// TestNewConfig tests that new ConnManager config is validated as expected.
-func TestNewConfig(t *testing.T) {
-	_, err := New(&Config{})
-	if err == nil {
-		t.Fatalf("New expected error: 'Dial can't be nil', got nil")
-	}
-	_, err = New(&Config{
-		Dial: mockDialer,
-	})
-	if err != nil {
-		t.Fatalf("New unexpected error: %v", err)
-	}
-}
-
-// TestStartStop tests that the connection manager starts and stops as
-// expected.
-func TestStartStop(t *testing.T) {
-	connected := make(chan *ConnReq)
-	disconnected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		TargetOutbound: 1,
-		GetNewAddress: func() (net.Addr, error) {
-			return &net.TCPAddr{
-				IP:   net.ParseIP("127.0.0.1"),
-				Port: 18555,
-			}, nil
-		},
-		Dial: mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		OnDisconnection: func(c *ConnReq) {
-			disconnected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-	gotConnReq := <-connected
-	cmgr.Stop()
-	// already stopped
-	cmgr.Stop()
-	// ignored
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	cmgr.Connect(cr)
-	if cr.ID() != 0 {
-		t.Fatalf("start/stop: got id: %v, want: 0", cr.ID())
-	}
-	cmgr.Disconnect(gotConnReq.ID())
-	cmgr.Remove(gotConnReq.ID())
-	select {
-	case <-disconnected:
-		t.Fatalf("start/stop: unexpected disconnection")
-	case <-time.Tick(10 * time.Millisecond):
-		break
-	}
-}
-
-// TestConnectMode tests that the connection manager works in the connect mode.
-//
-// In connect mode, automatic connections are disabled, so we test that
-// requests using Connect are handled and that no other connections are made.
-func TestConnectMode(t *testing.T) {
-	connected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		TargetOutbound: 2,
-		Dial:           mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	cmgr.Start()
-	cmgr.Connect(cr)
-	gotConnReq := <-connected
-	wantID := cr.ID()
-	gotID := gotConnReq.ID()
-	if gotID != wantID {
-		t.Fatalf("connect mode: %v - want ID %v, got ID %v", cr.Addr, wantID, gotID)
-	}
-	gotState := cr.State()
-	wantState := ConnEstablished
-	if gotState != wantState {
-		t.Fatalf("connect mode: %v - want state %v, got state %v", cr.Addr, wantState, gotState)
-	}
-	select {
-	case c := <-connected:
-		t.Fatalf("connect mode: got unexpected connection - %v", c.Addr)
-	case <-time.After(time.Millisecond):
-		break
-	}
-	cmgr.Stop()
-}
-
-// TestTargetOutbound tests the target number of outbound connections.
-//
-// We wait until all connections are established, then test they there are the
-// only connections made.
-func TestTargetOutbound(t *testing.T) {
-	targetOutbound := uint32(10)
-	connected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		TargetOutbound: targetOutbound,
-		Dial:           mockDialer,
-		GetNewAddress: func() (net.Addr, error) {
-			return &net.TCPAddr{
-				IP:   net.ParseIP("127.0.0.1"),
-				Port: 18555,
-			}, nil
-		},
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-	for i := uint32(0); i < targetOutbound; i++ {
-		<-connected
-	}
-
-	select {
-	case c := <-connected:
-		t.Fatalf("target outbound: got unexpected connection - %v", c.Addr)
-	case <-time.After(time.Millisecond):
-		break
-	}
-	cmgr.Stop()
-}
-
-// TestRetryPermanent tests that permanent connection requests are retried.
-//
-// We make a permanent connection request using Connect, disconnect it using
-// Disconnect and we wait for it to be connected back.
-func TestRetryPermanent(t *testing.T) {
-	connected := make(chan *ConnReq)
-	disconnected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		RetryDuration:  time.Millisecond,
-		TargetOutbound: 1,
-		Dial:           mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		OnDisconnection: func(c *ConnReq) {
-			disconnected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	go cmgr.Connect(cr)
-	cmgr.Start()
-	gotConnReq := <-connected
-	wantID := cr.ID()
-	gotID := gotConnReq.ID()
-	if gotID != wantID {
-		t.Fatalf("retry: %v - want ID %v, got ID %v", cr.Addr, wantID, gotID)
-	}
-	gotState := cr.State()
-	wantState := ConnEstablished
-	if gotState != wantState {
-		t.Fatalf("retry: %v - want state %v, got state %v", cr.Addr, wantState, gotState)
-	}
-
-	cmgr.Disconnect(cr.ID())
-	gotConnReq = <-disconnected
-	wantID = cr.ID()
-	gotID = gotConnReq.ID()
-	if gotID != wantID {
-		t.Fatalf("retry: %v - want ID %v, got ID %v", cr.Addr, wantID, gotID)
-	}
-	gotState = cr.State()
-	wantState = ConnPending
-	if gotState != wantState {
-		// There is a small chance that connection has already been established,
-		// so check for that as well
-		if gotState != ConnEstablished {
-			t.Fatalf("retry: %v - want state %v, got state %v", cr.Addr, wantState, gotState)
-		}
-	}
-
-	gotConnReq = <-connected
-	wantID = cr.ID()
-	gotID = gotConnReq.ID()
-	if gotID != wantID {
-		t.Fatalf("retry: %v - want ID %v, got ID %v", cr.Addr, wantID, gotID)
-	}
-	gotState = cr.State()
-	wantState = ConnEstablished
-	if gotState != wantState {
-		t.Fatalf("retry: %v - want state %v, got state %v", cr.Addr, wantState, gotState)
-	}
-
-	cmgr.Remove(cr.ID())
-	gotConnReq = <-disconnected
-	wantID = cr.ID()
-	gotID = gotConnReq.ID()
-	if gotID != wantID {
-		t.Fatalf("retry: %v - want ID %v, got ID %v", cr.Addr, wantID, gotID)
-	}
-	gotState = cr.State()
-	wantState = ConnDisconnected
-	if gotState != wantState {
-		t.Fatalf("retry: %v - want state %v, got state %v", cr.Addr, wantState, gotState)
-	}
-	cmgr.Stop()
-}
-
-// TestMaxRetryDuration tests the maximum retry duration.
-//
-// We have a timed dialer which initially returns err but after RetryDuration
-// hits maxRetryDuration returns a mock conn.
-func TestMaxRetryDuration(t *testing.T) {
-	networkUp := make(chan struct{})
-	time.AfterFunc(5*time.Millisecond, func() {
-		close(networkUp)
-	})
-	timedDialer := func(addr net.Addr) (net.Conn, error) {
-		select {
-		case <-networkUp:
-			return mockDialer(addr)
-		default:
-			return nil, errors.New("network down")
-		}
-	}
-
-	connected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		RetryDuration:  time.Millisecond,
-		TargetOutbound: 1,
-		Dial:           timedDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	go cmgr.Connect(cr)
-	cmgr.Start()
-	// retry in 1ms
-	// retry in 2ms - max retry duration reached
-	// retry in 2ms - timedDialer returns mockDial
-	select {
-	case <-connected:
-	case <-time.Tick(100 * time.Millisecond):
-		t.Fatalf("max retry duration: connection timeout")
-	}
-}
-
-// TestNetworkFailure tests that the connection manager handles a network
-// failure gracefully.
-func TestNetworkFailure(t *testing.T) {
-	var dials uint32
-	errDialer := func(net net.Addr) (net.Conn, error) {
-		atomic.AddUint32(&dials, 1)
-		return nil, errors.New("network down")
-	}
-	cmgr, err := New(&Config{
-		TargetOutbound: 5,
-		RetryDuration:  5 * time.Millisecond,
-		Dial:           errDialer,
-		GetNewAddress: func() (net.Addr, error) {
-			return &net.TCPAddr{
-				IP:   net.ParseIP("127.0.0.1"),
-				Port: 18555,
-			}, nil
-		},
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			t.Fatalf("network failure: got unexpected connection - %v", c.Addr)
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-	time.AfterFunc(10*time.Millisecond, cmgr.Stop)
-	cmgr.Wait()
-	wantMaxDials := uint32(75)
-	if atomic.LoadUint32(&dials) > wantMaxDials {
-		t.Fatalf("network failure: unexpected number of dials - got %v, want < %v",
-			atomic.LoadUint32(&dials), wantMaxDials)
-	}
-}
-
-// TestStopFailed tests that failed connections are ignored after connmgr is
-// stopped.
-//
-// We have a dailer which sets the stop flag on the conn manager and returns an
-// err so that the handler assumes that the conn manager is stopped and ignores
-// the failure.
-func TestStopFailed(t *testing.T) {
-	done := make(chan struct{}, 1)
-	waitDialer := func(addr net.Addr) (net.Conn, error) {
-		done <- struct{}{}
-		time.Sleep(time.Millisecond)
-		return nil, errors.New("network down")
-	}
-	cmgr, err := New(&Config{
-		Dial: waitDialer,
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-	go func() {
-		<-done
-		atomic.StoreInt32(&cmgr.stop, 1)
-		time.Sleep(2 * time.Millisecond)
-		atomic.StoreInt32(&cmgr.stop, 0)
-		cmgr.Stop()
-	}()
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	go cmgr.Connect(cr)
-	cmgr.Wait()
-}
-
-// TestRemovePendingConnection tests that it's possible to cancel a pending
-// connection, removing its internal state from the ConnMgr.
-func TestRemovePendingConnection(t *testing.T) {
-	// Create a ConnMgr instance with an instance of a dialer that'll never
-	// succeed.
-	wait := make(chan struct{})
-	indefiniteDialer := func(addr net.Addr) (net.Conn, error) {
-		<-wait
-		return nil, errors.Errorf("error")
-	}
-	cmgr, err := New(&Config{
-		Dial: indefiniteDialer,
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-
-	// Establish a connection request to a random IP we've chosen.
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	go cmgr.Connect(cr)
-
-	time.Sleep(10 * time.Millisecond)
-
-	if cr.State() != ConnPending {
-		t.Fatalf("pending request hasn't been registered, status: %v",
-			cr.State())
-	}
-
-	// The request launched above will actually never be able to establish
-	// a connection. So we'll cancel it _before_ it's able to be completed.
-	cmgr.Remove(cr.ID())
-
-	time.Sleep(10 * time.Millisecond)
-
-	// Now examine the status of the connection request, it should read a
-	// status of failed.
-	if cr.State() != ConnCanceled {
-		t.Fatalf("request wasn't canceled, status is: %v", cr.State())
-	}
-
-	close(wait)
-	cmgr.Stop()
-}
-
-// TestCancelIgnoreDelayedConnection tests that a canceled connection request will
-// not execute the on connection callback, even if an outstanding retry
-// succeeds.
-func TestCancelIgnoreDelayedConnection(t *testing.T) {
-	retryTimeout := 10 * time.Millisecond
-
-	// Setup a dialer that will continue to return an error until the
-	// connect chan is signaled, the dial attempt immediately after will
-	// succeed in returning a connection.
-	connect := make(chan struct{})
-	failingDialer := func(addr net.Addr) (net.Conn, error) {
-		select {
-		case <-connect:
-			return mockDialer(addr)
-		default:
-		}
-
-		return nil, errors.Errorf("error")
-	}
-
-	connected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		Dial:          failingDialer,
-		RetryDuration: retryTimeout,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-	defer cmgr.Stop()
-
-	// Establish a connection request to a random IP we've chosen.
-	cr := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-	}
-	cmgr.Connect(cr)
-
-	// Allow for the first retry timeout to elapse.
-	time.Sleep(2 * retryTimeout)
-
-	// Connection be marked as failed, even after reattempting to
-	// connect.
-	if cr.State() != ConnFailing {
-		t.Fatalf("failing request should have status failed, status: %v",
-			cr.State())
-	}
-
-	// Remove the connection, and then immediately allow the next connection
-	// to succeed.
-	cmgr.Remove(cr.ID())
-	close(connect)
-
-	// Allow the connection manager to process the removal.
-	time.Sleep(5 * time.Millisecond)
-
-	// Now examine the status of the connection request, it should read a
-	// status of canceled.
-	if cr.State() != ConnCanceled {
-		t.Fatalf("request wasn't canceled, status is: %v", cr.State())
-	}
-
-	// Finally, the connection manager should not signal the on-connection
-	// callback, since we explicitly canceled this request. We give a
-	// generous window to ensure the connection manager's lienar backoff is
-	// allowed to properly elapse.
-	select {
-	case <-connected:
-		t.Fatalf("on-connect should not be called for canceled req")
-	case <-time.After(5 * retryTimeout):
-	}
-
-}
-
-// mockListener implements the net.Listener interface and is used to test
-// code that deals with net.Listeners without having to actually make any real
-// connections.
-type mockListener struct {
-	localAddr   string
-	provideConn chan net.Conn
-}
-
-// Accept returns a mock connection when it receives a signal via the Connect
-// function.
-//
-// This is part of the net.Listener interface.
-func (m *mockListener) Accept() (net.Conn, error) {
-	for conn := range m.provideConn {
-		return conn, nil
-	}
-	return nil, errors.New("network connection closed")
-}
-
-// Close closes the mock listener which will cause any blocked Accept
-// operations to be unblocked and return errors.
-//
-// This is part of the net.Listener interface.
-func (m *mockListener) Close() error {
-	close(m.provideConn)
-	return nil
-}
-
-// Addr returns the address the mock listener was configured with.
-//
-// This is part of the net.Listener interface.
-func (m *mockListener) Addr() net.Addr {
-	return &mockAddr{"tcp", m.localAddr}
-}
-
-// Connect fakes a connection to the mock listener from the provided remote
-// address. It will cause the Accept function to return a mock connection
-// configured with the provided remote address and the local address for the
-// mock listener.
-func (m *mockListener) Connect(ip string, port int) {
-	m.provideConn <- &mockConn{
-		laddr: m.localAddr,
-		lnet:  "tcp",
-		rAddr: &net.TCPAddr{
-			IP:   net.ParseIP(ip),
-			Port: port,
-		},
-	}
-}
-
-// newMockListener returns a new mock listener for the provided local address
-// and port. No ports are actually opened.
-func newMockListener(localAddr string) *mockListener {
-	return &mockListener{
-		localAddr:   localAddr,
-		provideConn: make(chan net.Conn),
-	}
-}
-
-// TestListeners ensures providing listeners to the connection manager along
-// with an accept callback works properly.
-func TestListeners(t *testing.T) {
-	// Setup a connection manager with a couple of mock listeners that
-	// notify a channel when they receive mock connections.
-	receivedConns := make(chan net.Conn)
-	listener1 := newMockListener("127.0.0.1:16111")
-	listener2 := newMockListener("127.0.0.1:9333")
-	listeners := []net.Listener{listener1, listener2}
-	cmgr, err := New(&Config{
-		Listeners: listeners,
-		OnAccept: func(conn net.Conn) {
-			receivedConns <- conn
-		},
-		Dial: mockDialer,
-	})
-	if err != nil {
-		t.Fatalf("New error: %v", err)
-	}
-	cmgr.Start()
-
-	// Fake a couple of mock connections to each of the listeners.
-	go func() {
-		for i, listener := range listeners {
-			l := listener.(*mockListener)
-			l.Connect("127.0.0.1", 10000+i*2)
-			l.Connect("127.0.0.1", 10000+i*2+1)
-		}
-	}()
-
-	// Tally the receive connections to ensure the expected number are
-	// received. Also, fail the test after a timeout so it will not hang
-	// forever should the test not work.
-	expectedNumConns := len(listeners) * 2
-	var numConns int
-out:
-	for {
-		select {
-		case <-receivedConns:
-			numConns++
-			if numConns == expectedNumConns {
-				break out
-			}
-
-		case <-time.After(time.Millisecond * 50):
-			t.Fatalf("Timeout waiting for %d expected connections",
-				expectedNumConns)
-		}
-	}
-
-	cmgr.Stop()
-	cmgr.Wait()
-}
-
-// TestConnReqString ensures that ConnReq.String() does not crash
-func TestConnReqString(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			t.Fatalf("ConnReq.String crashed %v", r)
-		}
-	}()
-	cr1 := &ConnReq{
-		Addr: &net.TCPAddr{
-			IP:   net.ParseIP("127.0.0.1"),
-			Port: 18555,
-		},
-		Permanent: true,
-	}
-	_ = cr1.String()
-	cr2 := &ConnReq{}
-	_ = cr2.String()
-}

connmgr/doc.go

@@ -1,23 +0,0 @@
-/*
-Package connmgr implements a generic Kaspa network connection manager.
-
-Connection Manager Overview
-
-Connection Manager handles all the general connection concerns such as
-maintaining a set number of outbound connections, sourcing peers, banning,
-limiting max connections, etc.
-
-The package provides a generic connection manager which is able to accept
-connection requests from a source or a set of given addresses, dial them and
-notify the caller on connections. The main intended use is to initialize a pool
-of active connections and maintain them to remain connected to the P2P network.
-
-In addition the connection manager provides the following utilities:
-
-- Notifications on connections or disconnections
-- Handle failures and retry new addresses from the source
-- Connect only to specified addresses
-- Permanent connections with increasing backoff retry timers
-- Disconnect or Remove an established connection
-*/
-package connmgr

connmgr/dynamicbanscore.go

@@ -1,144 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package connmgr
-
-import (
-	"fmt"
-	"math"
-	"sync"
-	"time"
-)
-
-const (
-	// Halflife defines the time (in seconds) by which the transient part
-	// of the ban score decays to one half of it's original value.
-	Halflife = 60
-
-	// lambda is the decaying constant.
-	lambda = math.Ln2 / Halflife
-
-	// Lifetime defines the maximum age of the transient part of the ban
-	// score to be considered a non-zero score (in seconds).
-	Lifetime = 1800
-
-	// precomputedLen defines the amount of decay factors (one per second) that
-	// should be precomputed at initialization.
-	precomputedLen = 64
-)
-
-// precomputedFactor stores precomputed exponential decay factors for the first
-// 'precomputedLen' seconds starting from t == 0.
-var precomputedFactor [precomputedLen]float64
-
-// init precomputes decay factors.
-func init() {
-	for i := range precomputedFactor {
-		precomputedFactor[i] = math.Exp(-1.0 * float64(i) * lambda)
-	}
-}
-
-// decayFactor returns the decay factor at t seconds, using precalculated values
-// if available, or calculating the factor if needed.
-func decayFactor(t int64) float64 {
-	if t < precomputedLen {
-		return precomputedFactor[t]
-	}
-	return math.Exp(-1.0 * float64(t) * lambda)
-}
-
-// DynamicBanScore provides dynamic ban scores consisting of a persistent and a
-// decaying component.
-//
-// The decaying score enables the creation of evasive logic which handles
-// misbehaving peers (especially application layer DoS attacks) gracefully
-// by disconnecting and banning peers attempting various kinds of flooding.
-// DynamicBanScore allows these two approaches to be used in tandem.
-//
-// Zero value: Values of type DynamicBanScore are immediately ready for use upon
-// declaration.
-type DynamicBanScore struct {
-	lastUnix   int64
-	transient  float64
-	persistent uint32
-	mtx        sync.Mutex
-}
-
-// String returns the ban score as a human-readable string.
-func (s *DynamicBanScore) String() string {
-	s.mtx.Lock()
-	r := fmt.Sprintf("persistent %d + transient %f at %d = %d as of now",
-		s.persistent, s.transient, s.lastUnix, s.Int())
-	s.mtx.Unlock()
-	return r
-}
-
-// Int returns the current ban score, the sum of the persistent and decaying
-// scores.
-//
-// This function is safe for concurrent access.
-func (s *DynamicBanScore) Int() uint32 {
-	s.mtx.Lock()
-	r := s.int(time.Now())
-	s.mtx.Unlock()
-	return r
-}
-
-// Increase increases both the persistent and decaying scores by the values
-// passed as parameters. The resulting score is returned.
-//
-// This function is safe for concurrent access.
-func (s *DynamicBanScore) Increase(persistent, transient uint32) uint32 {
-	s.mtx.Lock()
-	r := s.increase(persistent, transient, time.Now())
-	s.mtx.Unlock()
-	return r
-}
-
-// Reset set both persistent and decaying scores to zero.
-//
-// This function is safe for concurrent access.
-func (s *DynamicBanScore) Reset() {
-	s.mtx.Lock()
-	s.persistent = 0
-	s.transient = 0
-	s.lastUnix = 0
-	s.mtx.Unlock()
-}
-
-// int returns the ban score, the sum of the persistent and decaying scores at a
-// given point in time.
-//
-// This function is not safe for concurrent access. It is intended to be used
-// internally and during testing.
-func (s *DynamicBanScore) int(t time.Time) uint32 {
-	dt := t.Unix() - s.lastUnix
-	if s.transient < 1 || dt < 0 || Lifetime < dt {
-		return s.persistent
-	}
-	return s.persistent + uint32(s.transient*decayFactor(dt))
-}
-
-// increase increases the persistent, the decaying or both scores by the values
-// passed as parameters. The resulting score is calculated as if the action was
-// carried out at the point time represented by the third parameter. The
-// resulting score is returned.
-//
-// This function is not safe for concurrent access.
-func (s *DynamicBanScore) increase(persistent, transient uint32, t time.Time) uint32 {
-	s.persistent += persistent
-	tu := t.Unix()
-	dt := tu - s.lastUnix
-
-	if transient > 0 {
-		if Lifetime < dt {
-			s.transient = 0
-		} else if s.transient > 1 && dt > 0 {
-			s.transient *= decayFactor(dt)
-		}
-		s.transient += float64(transient)
-		s.lastUnix = tu
-	}
-	return s.persistent + uint32(s.transient)
-}

connmgr/dynamicbanscore_test.go

@@ -1,68 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package connmgr
-
-import (
-	"math"
-	"testing"
-	"time"
-)
-
-// TestDynamicBanScoreDecay tests the exponential decay implemented in
-// DynamicBanScore.
-func TestDynamicBanScoreDecay(t *testing.T) {
-	var bs DynamicBanScore
-	base := time.Now()
-
-	r := bs.increase(100, 50, base)
-	if r != 150 {
-		t.Errorf("Unexpected result %d after ban score increase.", r)
-	}
-
-	r = bs.int(base.Add(time.Minute))
-	if r != 125 {
-		t.Errorf("Halflife check failed - %d instead of 125", r)
-	}
-
-	r = bs.int(base.Add(7 * time.Minute))
-	if r != 100 {
-		t.Errorf("Decay after 7m - %d instead of 100", r)
-	}
-}
-
-// TestDynamicBanScoreLifetime tests that DynamicBanScore properly yields zero
-// once the maximum age is reached.
-func TestDynamicBanScoreLifetime(t *testing.T) {
-	var bs DynamicBanScore
-	base := time.Now()
-
-	r := bs.increase(0, math.MaxUint32, base)
-	r = bs.int(base.Add(Lifetime * time.Second))
-	if r != 3 { // 3, not 4 due to precision loss and truncating 3.999...
-		t.Errorf("Pre max age check with MaxUint32 failed - %d", r)
-	}
-	r = bs.int(base.Add((Lifetime + 1) * time.Second))
-	if r != 0 {
-		t.Errorf("Zero after max age check failed - %d instead of 0", r)
-	}
-}
-
-// TestDynamicBanScore tests exported functions of DynamicBanScore. Exponential
-// decay or other time based behavior is tested by other functions.
-func TestDynamicBanScoreReset(t *testing.T) {
-	var bs DynamicBanScore
-	if bs.Int() != 0 {
-		t.Errorf("Initial state is not zero.")
-	}
-	bs.Increase(100, 0)
-	r := bs.Int()
-	if r != 100 {
-		t.Errorf("Unexpected result %d after ban score increase.", r)
-	}
-	bs.Reset()
-	if bs.Int() != 0 {
-		t.Errorf("Failed to reset ban score.")
-	}
-}

dagconfig/genesis_test.go

@@ -1,334 +0,0 @@
-// Copyright (c) 2014-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package dagconfig
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// TestGenesisBlock tests the genesis block of the main network for validity by
-// checking the encoded bytes and hashes.
-func TestGenesisBlock(t *testing.T) {
-	// Encode the genesis block to raw bytes.
-	var buf bytes.Buffer
-	err := MainnetParams.GenesisBlock.Serialize(&buf)
-	if err != nil {
-		t.Fatalf("TestGenesisBlock: %v", err)
-	}
-
-	// Ensure the encoded block matches the expected bytes.
-	if !bytes.Equal(buf.Bytes(), genesisBlockBytes) {
-		t.Fatalf("TestGenesisBlock: Genesis block does not appear valid - "+
-			"got %v, want %v", spew.Sdump(buf.Bytes()),
-			spew.Sdump(genesisBlockBytes))
-	}
-
-	// Check hash of the block against expected hash.
-	hash := MainnetParams.GenesisBlock.BlockHash()
-	if !MainnetParams.GenesisHash.IsEqual(hash) {
-		t.Fatalf("TestGenesisBlock: Genesis block hash does not "+
-			"appear valid - got %v, want %v", spew.Sdump(hash),
-			spew.Sdump(MainnetParams.GenesisHash))
-	}
-}
-
-// TestRegtestGenesisBlock tests the genesis block of the regression test
-// network for validity by checking the encoded bytes and hashes.
-func TestRegtestGenesisBlock(t *testing.T) {
-	// Encode the genesis block to raw bytes.
-	var buf bytes.Buffer
-	err := RegressionNetParams.GenesisBlock.Serialize(&buf)
-	if err != nil {
-		t.Fatalf("TestRegtestGenesisBlock: %v", err)
-	}
-
-	// Ensure the encoded block matches the expected bytes.
-	if !bytes.Equal(buf.Bytes(), regtestGenesisBlockBytes) {
-		t.Fatalf("TestRegtestGenesisBlock: Genesis block does not "+
-			"appear valid - got %v, want %v",
-			spew.Sdump(buf.Bytes()),
-			spew.Sdump(regtestGenesisBlockBytes))
-	}
-
-	// Check hash of the block against expected hash.
-	hash := RegressionNetParams.GenesisBlock.BlockHash()
-	if !RegressionNetParams.GenesisHash.IsEqual(hash) {
-		t.Fatalf("TestRegtestGenesisBlock: Genesis block hash does "+
-			"not appear valid - got %v, want %v", spew.Sdump(hash),
-			spew.Sdump(RegressionNetParams.GenesisHash))
-	}
-}
-
-// TestTestnetGenesisBlock tests the genesis block of the test network for
-// validity by checking the encoded bytes and hashes.
-func TestTestnetGenesisBlock(t *testing.T) {
-	// Encode the genesis block to raw bytes.
-	var buf bytes.Buffer
-	err := TestnetParams.GenesisBlock.Serialize(&buf)
-	if err != nil {
-		t.Fatalf("TestTestnetGenesisBlock: %v", err)
-	}
-
-	// Ensure the encoded block matches the expected bytes.
-	if !bytes.Equal(buf.Bytes(), testnetGenesisBlockBytes) {
-		t.Fatalf("TestTestnetGenesisBlock: Genesis block does not "+
-			"appear valid - got %v, want %v",
-			spew.Sdump(buf.Bytes()),
-			spew.Sdump(testnetGenesisBlockBytes))
-	}
-
-	// Check hash of the block against expected hash.
-	hash := TestnetParams.GenesisBlock.BlockHash()
-	if !TestnetParams.GenesisHash.IsEqual(hash) {
-		t.Fatalf("TestTestnetGenesisBlock: Genesis block hash does "+
-			"not appear valid - got %v, want %v", spew.Sdump(hash),
-			spew.Sdump(TestnetParams.GenesisHash))
-	}
-}
-
-// TestSimnetGenesisBlock tests the genesis block of the simulation test network
-// for validity by checking the encoded bytes and hashes.
-func TestSimnetGenesisBlock(t *testing.T) {
-	// Encode the genesis block to raw bytes.
-	var buf bytes.Buffer
-	err := SimnetParams.GenesisBlock.Serialize(&buf)
-	if err != nil {
-		t.Fatalf("TestSimnetGenesisBlock: %v", err)
-	}
-
-	// Ensure the encoded block matches the expected bytes.
-	if !bytes.Equal(buf.Bytes(), simnetGenesisBlockBytes) {
-		t.Fatalf("TestSimnetGenesisBlock: Genesis block does not "+
-			"appear valid - got %v, want %v",
-			spew.Sdump(buf.Bytes()),
-			spew.Sdump(simnetGenesisBlockBytes))
-	}
-
-	// Check hash of the block against expected hash.
-	hash := SimnetParams.GenesisBlock.BlockHash()
-	if !SimnetParams.GenesisHash.IsEqual(hash) {
-		t.Fatalf("TestSimnetGenesisBlock: Genesis block hash does "+
-			"not appear valid - got %v, want %v", spew.Sdump(hash),
-			spew.Sdump(SimnetParams.GenesisHash))
-	}
-}
-
-// TestDevnetGenesisBlock tests the genesis block of the development network
-// for validity by checking the encoded bytes and hashes.
-func TestDevnetGenesisBlock(t *testing.T) {
-	// Encode the genesis block to raw bytes.
-	var buf bytes.Buffer
-	err := DevnetParams.GenesisBlock.Serialize(&buf)
-	if err != nil {
-		t.Fatalf("TestDevnetGenesisBlock: %v", err)
-	}
-
-	// Ensure the encoded block matches the expected bytes.
-	if !bytes.Equal(buf.Bytes(), devnetGenesisBlockBytes) {
-		t.Fatalf("TestDevnetGenesisBlock: Genesis block does not "+
-			"appear valid - got %v, want %v",
-			spew.Sdump(buf.Bytes()),
-			spew.Sdump(simnetGenesisBlockBytes))
-	}
-
-	// Check hash of the block against expected hash.
-	hash := DevnetParams.GenesisBlock.BlockHash()
-	if !DevnetParams.GenesisHash.IsEqual(hash) {
-		t.Fatalf("TestDevnetGenesisBlock: Genesis block hash does "+
-			"not appear valid - got %v, want %v", spew.Sdump(hash),
-			spew.Sdump(DevnetParams.GenesisHash))
-	}
-}
-
-// genesisBlockBytes are the wire encoded bytes for the genesis block of the
-// main network as of protocol version 1.
-var genesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x72, 0x10, 0x35, 0x85, 0xdd, 0xac, 0x82, 0x5c, 0x49, 0x13, 0x9f,
-	0xc0, 0x0e, 0x37, 0xc0, 0x45, 0x71, 0xdf, 0xd9, 0xf6, 0x36, 0xdf, 0x4c, 0x42, 0x72, 0x7b, 0x9e,
-	0x86, 0xdd, 0x37, 0xd2, 0xbd, 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, 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, 0xb0, 0xc4, 0xda, 0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd2,
-	0xea, 0x82, 0x4e, 0xb8, 0x87, 0x42, 0xd0, 0x6d, 0x1f, 0x8d, 0xc3, 0xad, 0x9f, 0x43, 0x9e, 0xed,
-	0x6f, 0x43, 0x3c, 0x02, 0x71, 0x71, 0x69, 0xfb, 0xbc, 0x91, 0x44, 0xac, 0xf1, 0x93, 0xd3, 0x18,
-	0x17, 0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5, 0x49, 0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71,
-	0xc7, 0x7e, 0xba, 0x30, 0xcd, 0x5a, 0x4b, 0x87,
-}
-
-// regtestGenesisBlockBytes are the wire encoded bytes for the genesis block of
-// the regression test network as of protocol version 1.
-var regtestGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x9f, 0x62,
-	0xc9, 0x2b, 0x16, 0x17, 0xb3, 0x41, 0x6d, 0x9e,
-	0x2d, 0x87, 0x93, 0xfd, 0x72, 0x77, 0x4d, 0x1d,
-	0x6f, 0x6d, 0x38, 0x5b, 0xf1, 0x24, 0x1b, 0xdc,
-	0x96, 0xce, 0xbf, 0xa1, 0x09, 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, 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, 0xd8, 0xe2, 0x15,
-	0x5e, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x1e, 0xa6, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
-	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xed,
-	0x32, 0xec, 0xb4, 0xf8, 0x3c, 0x7a, 0x32, 0x0f,
-	0xd2, 0xe5, 0x24, 0x77, 0x89, 0x43, 0x3a, 0x78,
-	0x0a, 0xda, 0x68, 0x2d, 0xf6, 0xaa, 0xb1, 0x19,
-	0xdd, 0xd8, 0x97, 0x15, 0x4b, 0xcb, 0x42, 0x25,
-	0x17, 0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5,
-	0x49, 0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71,
-	0xc7, 0x7e, 0xba, 0x30, 0xcd, 0x5a, 0x4b, 0x87,
-	0x6b, 0x61, 0x73, 0x70, 0x61, 0x2d, 0x72, 0x65,
-	0x67, 0x74, 0x65, 0x73, 0x74,
-}
-
-// testnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
-// the test network as of protocol version 1.
-var testnetGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x88, 0x05, 0xd0,
-	0xe7, 0x8f, 0x41, 0x77, 0x39, 0x2c, 0xb6, 0xbb,
-	0xb4, 0x19, 0xa8, 0x48, 0x4a, 0xdf, 0x77, 0xb0,
-	0x82, 0xd6, 0x70, 0xd8, 0x24, 0x6a, 0x36, 0x05,
-	0xaa, 0xbd, 0x7a, 0xd1, 0x62, 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, 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, 0xfe, 0xad, 0x15,
-	0x5e, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x1e, 0xa1, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
-	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc,
-	0x72, 0xe6, 0x7e, 0x37, 0xa1, 0x34, 0x89, 0x23,
-	0x24, 0xaf, 0xae, 0x99, 0x1f, 0x89, 0x09, 0x41,
-	0x1a, 0x4d, 0x58, 0xfe, 0x5a, 0x04, 0xb0, 0x3e,
-	0xeb, 0x1b, 0x5b, 0xb8, 0x65, 0xa8, 0x65, 0x0f,
-	0x01, 0x00, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x2d,
-	0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74,
-}
-
-// simnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
-// the simulation test network as of protocol version 1.
-var simnetGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x1c, 0x3b,
-	0x9e, 0x0d, 0x9a, 0xc0, 0x80, 0x0a, 0x08, 0x42,
-	0x50, 0x02, 0xa3, 0xea, 0xdb, 0xed, 0xc8, 0xd0,
-	0xad, 0x35, 0x03, 0xd8, 0x0e, 0x11, 0x3c, 0x7b,
-	0xb2, 0xb5, 0x20, 0xe5, 0x84, 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, 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, 0x1c, 0xd3, 0x15,
-	0x5e, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x20, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
-	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x89,
-	0x48, 0xd3, 0x23, 0x9c, 0xf9, 0x88, 0x2b, 0x63,
-	0xc7, 0x33, 0x0f, 0xa3, 0x64, 0xf2, 0xdb, 0x39,
-	0x73, 0x5f, 0x2b, 0xa8, 0xd5, 0x7b, 0x5c, 0x31,
-	0x68, 0xc9, 0x63, 0x37, 0x5c, 0xe7, 0x41, 0x24,
-	0x17, 0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5,
-	0x49, 0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71,
-	0xc7, 0x7e, 0xba, 0x30, 0xcd, 0x5a, 0x4b, 0x87,
-	0x6b, 0x61, 0x73, 0x70, 0x61, 0x2d, 0x73, 0x69,
-	0x6d, 0x6e, 0x65, 0x74,
-}
-
-// devnetGenesisBlockBytes are the wire encoded bytes for the genesis block of
-// the development network as of protocol version 1.
-var devnetGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x16, 0x0a, 0xc6,
-	0x8b, 0x77, 0x08, 0xf4, 0x96, 0xa3, 0x07, 0x05,
-	0xbc, 0x92, 0xda, 0xee, 0x73, 0x26, 0x5e, 0xd0,
-	0x85, 0x78, 0xa2, 0x5d, 0x02, 0x49, 0x8a, 0x2a,
-	0x22, 0xef, 0x41, 0xc9, 0xc3, 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, 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, 0x58, 0xe7, 0x15,
-	0x5e, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x1e, 0xac, 0x82, 0x02, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xff, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
-	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
-	0xc7, 0x0c, 0x02, 0x9e, 0xb2, 0x2e, 0xb3, 0xad,
-	0x24, 0x10, 0xfe, 0x2c, 0xdb, 0x8e, 0x1d, 0xde,
-	0x81, 0x5b, 0xbb, 0x42, 0xfe, 0xb4, 0x93, 0xd6,
-	0xe3, 0xbe, 0x86, 0x02, 0xe6, 0x3a, 0x65, 0x24,
-	0x17, 0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5,
-	0x49, 0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71,
-	0xc7, 0x7e, 0xba, 0x30, 0xcd, 0x5a, 0x4b, 0x87,
-	0x6b, 0x61, 0x73, 0x70, 0x61, 0x2d, 0x64, 0x65,
-	0x76, 0x6e, 0x65, 0x74,
-}

dagconfig/register_test.go

@@ -1,209 +0,0 @@
-package dagconfig_test
-
-import (
-	"bytes"
-	"github.com/kaspanet/kaspad/util/hdkeychain"
-	"reflect"
-	"testing"
-
-	. "github.com/kaspanet/kaspad/dagconfig"
-)
-
-// Define some of the required parameters for a user-registered
-// network. This is necessary to test the registration of and
-// lookup of encoding magics from the network.
-var mockNetParams = Params{
-	Name: "mocknet",
-	Net:  1<<32 - 1,
-	HDKeyIDPair: hdkeychain.HDKeyIDPair{
-		PrivateKeyID: [4]byte{0x01, 0x02, 0x03, 0x04},
-		PublicKeyID:  [4]byte{0x05, 0x06, 0x07, 0x08},
-	},
-}
-
-func TestRegister(t *testing.T) {
-	type registerTest struct {
-		name   string
-		params *Params
-		err    error
-	}
-	type hdTest struct {
-		priv []byte
-		want []byte
-		err  error
-	}
-
-	tests := []struct {
-		name     string
-		register []registerTest
-		hdMagics []hdTest
-	}{
-		{
-			name: "default networks",
-			register: []registerTest{
-				{
-					name:   "duplicate mainnet",
-					params: &MainnetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate regtest",
-					params: &RegressionNetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate testnet",
-					params: &TestnetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate simnet",
-					params: &SimnetParams,
-					err:    ErrDuplicateNet,
-				},
-			},
-			hdMagics: []hdTest{
-				{
-					priv: MainnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: MainnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: TestnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: TestnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: RegressionNetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: RegressionNetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: SimnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: SimnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: mockNetParams.HDKeyIDPair.PrivateKeyID[:],
-					err:  hdkeychain.ErrUnknownHDKeyID,
-				},
-				{
-					priv: []byte{0xff, 0xff, 0xff, 0xff},
-					err:  hdkeychain.ErrUnknownHDKeyID,
-				},
-				{
-					priv: []byte{0xff},
-					err:  hdkeychain.ErrUnknownHDKeyID,
-				},
-			},
-		},
-		{
-			name: "register mocknet",
-			register: []registerTest{
-				{
-					name:   "mocknet",
-					params: &mockNetParams,
-					err:    nil,
-				},
-			},
-			hdMagics: []hdTest{
-				{
-					priv: mockNetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: mockNetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-			},
-		},
-		{
-			name: "more duplicates",
-			register: []registerTest{
-				{
-					name:   "duplicate mainnet",
-					params: &MainnetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate regtest",
-					params: &RegressionNetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate testnet",
-					params: &TestnetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate simnet",
-					params: &SimnetParams,
-					err:    ErrDuplicateNet,
-				},
-				{
-					name:   "duplicate mocknet",
-					params: &mockNetParams,
-					err:    ErrDuplicateNet,
-				},
-			},
-			hdMagics: []hdTest{
-				{
-					priv: MainnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: MainnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: TestnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: TestnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: RegressionNetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: RegressionNetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: SimnetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: SimnetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: mockNetParams.HDKeyIDPair.PrivateKeyID[:],
-					want: mockNetParams.HDKeyIDPair.PublicKeyID[:],
-					err:  nil,
-				},
-				{
-					priv: []byte{0xff, 0xff, 0xff, 0xff},
-					err:  hdkeychain.ErrUnknownHDKeyID,
-				},
-				{
-					priv: []byte{0xff},
-					err:  hdkeychain.ErrUnknownHDKeyID,
-				},
-			},
-		},
-	}
-
-	for _, test := range tests {
-		for _, regtest := range test.register {
-			err := Register(regtest.params)
-
-			// HDKeyIDPairs must be registered separately
-			hdkeychain.RegisterHDKeyIDPair(regtest.params.HDKeyIDPair)
-
-			if err != regtest.err {
-				t.Errorf("%s:%s: Registered network with unexpected error: got %v expected %v",
-					test.name, regtest.name, err, regtest.err)
-			}
-		}
-		for i, magTest := range test.hdMagics {
-			pubKey, err := hdkeychain.HDPrivateKeyToPublicKeyID(magTest.priv[:])
-			if !reflect.DeepEqual(err, magTest.err) {
-				t.Errorf("%s: HD magic %d mismatched error: got %v expected %v ",
-					test.name, i, err, magTest.err)
-				continue
-			}
-			if magTest.err == nil && !bytes.Equal(pubKey, magTest.want[:]) {
-				t.Errorf("%s: HD magic %d private and public mismatch: got %v expected %v ",
-					test.name, i, pubKey, magTest.want[:])
-			}
-		}
-	}
-}

database/README.md

@@ -1,32 +0,0 @@
-database
-========
-
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/database)
-
-Package database provides a block and metadata storage database.
-
-Please note that this package is intended to enable kaspad to support different
-database backends and is not something that a client can directly access as only
-one entity can have the database open at a time (for most database backends),
-and that entity will be kaspad.
-
-When a client wants programmatic access to the data provided by kaspad, they'll
-likely want to use the [rpcclient](https://github.com/kaspanet/kaspad/tree/master/rpcclient)
-package which makes use of the [JSON-RPC API](https://github.com/kaspanet/kaspad/tree/master/docs/json_rpc_api.md).
-
-The default backend, ffldb, has a strong focus on speed, efficiency, and
-robustness. It makes use of leveldb for the metadata, flat files for block
-storage, and strict checksums in key areas to ensure data integrity.
-
-## Feature Overview
-
-- Key/value metadata store
-- Kaspa block storage
-- Efficient retrieval of block headers and regions (transactions, scripts, etc)
-- Read-only and read-write transactions with both manual and managed modes
-- Nested buckets
-- Iteration support including cursors with seek capability
-- Supports registration of backend databases
-- Comprehensive test coverage
-

database/cmd/dbtool/fetchblock.go

@@ -1,62 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"encoding/hex"
-	"github.com/pkg/errors"
-	"time"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// fetchBlockCmd defines the configuration options for the fetchblock command.
-type fetchBlockCmd struct{}
-
-var (
-	// fetchBlockCfg defines the configuration options for the command.
-	fetchBlockCfg = fetchBlockCmd{}
-)
-
-// Execute is the main entry point for the command. It's invoked by the parser.
-func (cmd *fetchBlockCmd) Execute(args []string) error {
-	// Setup the global config options and ensure they are valid.
-	if err := setupGlobalConfig(); err != nil {
-		return err
-	}
-
-	if len(args) < 1 {
-		return errors.New("required block hash parameter not specified")
-	}
-	blockHash, err := daghash.NewHashFromStr(args[0])
-	if err != nil {
-		return err
-	}
-
-	// Load the block database.
-	db, err := loadBlockDB()
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	return db.View(func(dbTx database.Tx) error {
-		log.Infof("Fetching block %s", blockHash)
-		startTime := time.Now()
-		blockBytes, err := dbTx.FetchBlock(blockHash)
-		if err != nil {
-			return err
-		}
-		log.Infof("Loaded block in %s", time.Since(startTime))
-		log.Infof("Block Hex: %s", hex.EncodeToString(blockBytes))
-		return nil
-	})
-}
-
-// Usage overrides the usage display for the command.
-func (cmd *fetchBlockCmd) Usage() string {
-	return "<block-hash>"
-}

database/cmd/dbtool/fetchblockregion.go

@@ -1,90 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"encoding/hex"
-	"github.com/pkg/errors"
-	"strconv"
-	"time"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// blockRegionCmd defines the configuration options for the fetchblockregion
-// command.
-type blockRegionCmd struct{}
-
-var (
-	// blockRegionCfg defines the configuration options for the command.
-	blockRegionCfg = blockRegionCmd{}
-)
-
-// Execute is the main entry point for the command. It's invoked by the parser.
-func (cmd *blockRegionCmd) Execute(args []string) error {
-	// Setup the global config options and ensure they are valid.
-	if err := setupGlobalConfig(); err != nil {
-		return err
-	}
-
-	// Ensure expected arguments.
-	if len(args) < 1 {
-		return errors.New("required block hash parameter not specified")
-	}
-	if len(args) < 2 {
-		return errors.New("required start offset parameter not " +
-			"specified")
-	}
-	if len(args) < 3 {
-		return errors.New("required region length parameter not " +
-			"specified")
-	}
-
-	// Parse arguments.
-	blockHash, err := daghash.NewHashFromStr(args[0])
-	if err != nil {
-		return err
-	}
-	startOffset, err := strconv.ParseUint(args[1], 10, 32)
-	if err != nil {
-		return err
-	}
-	regionLen, err := strconv.ParseUint(args[2], 10, 32)
-	if err != nil {
-		return err
-	}
-
-	// Load the block database.
-	db, err := loadBlockDB()
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	return db.View(func(dbTx database.Tx) error {
-		log.Infof("Fetching block region %s<%d:%d>", blockHash,
-			startOffset, startOffset+regionLen-1)
-		region := database.BlockRegion{
-			Hash:   blockHash,
-			Offset: uint32(startOffset),
-			Len:    uint32(regionLen),
-		}
-		startTime := time.Now()
-		regionBytes, err := dbTx.FetchBlockRegion(&region)
-		if err != nil {
-			return err
-		}
-		log.Infof("Loaded block region in %s", time.Since(startTime))
-		log.Infof("Double Hash: %s", daghash.DoubleHashH(regionBytes))
-		log.Infof("Region Hex: %s", hex.EncodeToString(regionBytes))
-		return nil
-	})
-}
-
-// Usage overrides the usage display for the command.
-func (cmd *blockRegionCmd) Usage() string {
-	return "<block-hash> <start-offset> <length-of-region>"
-}

database/cmd/dbtool/globalconfig.go

@@ -1,111 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"github.com/pkg/errors"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	_ "github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/kaspanet/kaspad/util"
-)
-
-var (
-	kaspadHomeDir   = util.AppDataDir("kaspad", false)
-	knownDbTypes    = database.SupportedDrivers()
-	activeNetParams = &dagconfig.MainnetParams
-
-	// Default global config.
-	cfg = &config{
-		DataDir: filepath.Join(kaspadHomeDir, "data"),
-		DbType:  "ffldb",
-	}
-)
-
-// config defines the global configuration options.
-type config struct {
-	DataDir        string `short:"b" long:"datadir" description:"Location of the kaspad data directory"`
-	DbType         string `long:"dbtype" description:"Database backend to use for the Block DAG"`
-	Testnet        bool   `long:"testnet" description:"Use the test network"`
-	RegressionTest bool   `long:"regtest" description:"Use the regression test network"`
-	Simnet         bool   `long:"simnet" description:"Use the simulation test network"`
-	Devnet         bool   `long:"devnet" description:"Use the development test network"`
-}
-
-// fileExists reports whether the named file or directory exists.
-func fileExists(name string) bool {
-	if _, err := os.Stat(name); err != nil {
-		if os.IsNotExist(err) {
-			return false
-		}
-	}
-	return true
-}
-
-// validDbType returns whether or not dbType is a supported database type.
-func validDbType(dbType string) bool {
-	for _, knownType := range knownDbTypes {
-		if dbType == knownType {
-			return true
-		}
-	}
-
-	return false
-}
-
-// setupGlobalConfig examine the global configuration options for any conditions
-// which are invalid as well as performs any addition setup necessary after the
-// initial parse.
-func setupGlobalConfig() error {
-	// Multiple networks can't be selected simultaneously.
-	// Count number of network flags passed; assign active network params
-	// while we're at it
-	numNets := 0
-	if cfg.Testnet {
-		numNets++
-		activeNetParams = &dagconfig.TestnetParams
-	}
-	if cfg.RegressionTest {
-		numNets++
-		activeNetParams = &dagconfig.RegressionNetParams
-	}
-	if cfg.Simnet {
-		numNets++
-		activeNetParams = &dagconfig.SimnetParams
-	}
-	if cfg.Devnet {
-		numNets++
-		activeNetParams = &dagconfig.DevnetParams
-	}
-	if numNets > 1 {
-		return errors.New("The testnet, regtest, simnet and devnet params " +
-			"can't be used together -- choose one of the four")
-	}
-
-	if numNets == 0 {
-		return errors.New("Mainnet has not launched yet, use --testnet to run in testnet mode")
-	}
-
-	// Validate database type.
-	if !validDbType(cfg.DbType) {
-		str := "The specified database type [%s] is invalid -- " +
-			"supported types: %s"
-		return errors.Errorf(str, cfg.DbType, strings.Join(knownDbTypes, ", "))
-	}
-
-	// Append the network type to the data directory so it is "namespaced"
-	// per network. In addition to the block database, there are other
-	// pieces of data that are saved to disk such as address manager state.
-	// All data is specific to a network, so namespacing the data directory
-	// means each individual piece of serialized data does not have to
-	// worry about changing names per network and such.
-	cfg.DataDir = filepath.Join(cfg.DataDir, activeNetParams.Name)
-
-	return nil
-}

database/cmd/dbtool/insecureimport.go

@@ -1,391 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"encoding/binary"
-	"github.com/pkg/errors"
-	"io"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// importCmd defines the configuration options for the insecureimport command.
-type importCmd struct {
-	InFile   string `short:"i" long:"infile" description:"File containing the block(s)"`
-	Progress int    `short:"p" long:"progress" description:"Show a progress message each time this number of seconds have passed -- Use 0 to disable progress announcements"`
-}
-
-var (
-	// importCfg defines the configuration options for the command.
-	importCfg = importCmd{
-		InFile:   "bootstrap.dat",
-		Progress: 10,
-	}
-)
-
-// importResults houses the stats and result as an import operation.
-type importResults struct {
-	blocksProcessed int64
-	blocksImported  int64
-	err             error
-}
-
-// blockImporter houses information about an ongoing import from a block data
-// file to the block database.
-type blockImporter struct {
-	db                database.DB
-	r                 io.ReadSeeker
-	processQueue      chan []byte
-	doneChan          chan bool
-	errChan           chan error
-	quit              chan struct{}
-	wg                sync.WaitGroup
-	blocksProcessed   int64
-	blocksImported    int64
-	receivedLogBlocks int64
-	receivedLogTx     int64
-	lastHeight        int64
-	lastBlockTime     time.Time
-	lastLogTime       time.Time
-}
-
-// readBlock reads the next block from the input file.
-func (bi *blockImporter) readBlock() ([]byte, error) {
-	// The block file format is:
-	//  <network> <block length> <serialized block>
-	var net uint32
-	err := binary.Read(bi.r, binary.LittleEndian, &net)
-	if err != nil {
-		if err != io.EOF {
-			return nil, err
-		}
-
-		// No block and no error means there are no more blocks to read.
-		return nil, nil
-	}
-	if net != uint32(activeNetParams.Net) {
-		return nil, errors.Errorf("network mismatch -- got %x, want %x",
-			net, uint32(activeNetParams.Net))
-	}
-
-	// Read the block length and ensure it is sane.
-	var blockLen uint32
-	if err := binary.Read(bi.r, binary.LittleEndian, &blockLen); err != nil {
-		return nil, err
-	}
-	if blockLen > wire.MaxMessagePayload {
-		return nil, errors.Errorf("block payload of %d bytes is larger "+
-			"than the max allowed %d bytes", blockLen,
-			wire.MaxMessagePayload)
-	}
-
-	serializedBlock := make([]byte, blockLen)
-	if _, err := io.ReadFull(bi.r, serializedBlock); err != nil {
-		return nil, err
-	}
-
-	return serializedBlock, nil
-}
-
-// processBlock potentially imports the block into the database. It first
-// deserializes the raw block while checking for errors. Already known blocks
-// are skipped and orphan blocks are considered errors. Returns whether the
-// block was imported along with any potential errors.
-//
-// NOTE: This is not a safe import as it does not verify DAG rules.
-func (bi *blockImporter) processBlock(serializedBlock []byte) (bool, error) {
-	// Deserialize the block which includes checks for malformed blocks.
-	block, err := util.NewBlockFromBytes(serializedBlock)
-	if err != nil {
-		return false, err
-	}
-
-	// update progress statistics
-	bi.lastBlockTime = block.MsgBlock().Header.Timestamp
-	bi.receivedLogTx += int64(len(block.MsgBlock().Transactions))
-
-	// Skip blocks that already exist.
-	var exists bool
-	err = bi.db.View(func(dbTx database.Tx) error {
-		exists, err = dbTx.HasBlock(block.Hash())
-		return err
-	})
-	if err != nil {
-		return false, err
-	}
-	if exists {
-		return false, nil
-	}
-
-	// Don't bother trying to process orphans.
-	parentHashes := block.MsgBlock().Header.ParentHashes
-	for _, parentHash := range parentHashes {
-		var exists bool
-		err := bi.db.View(func(dbTx database.Tx) error {
-			exists, err = dbTx.HasBlock(parentHash)
-			return err
-		})
-		if err != nil {
-			return false, err
-		}
-		if !exists {
-			return false, errors.Errorf("import file contains block "+
-				"%s which does not link to the available "+
-				"block DAG", parentHash)
-		}
-	}
-
-	// Put the blocks into the database with no checking of DAG rules.
-	err = bi.db.Update(func(dbTx database.Tx) error {
-		return dbTx.StoreBlock(block)
-	})
-	if err != nil {
-		return false, err
-	}
-
-	return true, nil
-}
-
-// readHandler is the main handler for reading blocks from the import file.
-// This allows block processing to take place in parallel with block reads.
-// It must be run as a goroutine.
-func (bi *blockImporter) readHandler() {
-out:
-	for {
-		// Read the next block from the file and if anything goes wrong
-		// notify the status handler with the error and bail.
-		serializedBlock, err := bi.readBlock()
-		if err != nil {
-			bi.errChan <- errors.Errorf("Error reading from input "+
-				"file: %s", err.Error())
-			break out
-		}
-
-		// A nil block with no error means we're done.
-		if serializedBlock == nil {
-			break out
-		}
-
-		// Send the block or quit if we've been signalled to exit by
-		// the status handler due to an error elsewhere.
-		select {
-		case bi.processQueue <- serializedBlock:
-		case <-bi.quit:
-			break out
-		}
-	}
-
-	// Close the processing channel to signal no more blocks are coming.
-	close(bi.processQueue)
-	bi.wg.Done()
-}
-
-// logProgress logs block progress as an information message. In order to
-// prevent spam, it limits logging to one message every importCfg.Progress
-// seconds with duration and totals included.
-func (bi *blockImporter) logProgress() {
-	bi.receivedLogBlocks++
-
-	now := time.Now()
-	duration := now.Sub(bi.lastLogTime)
-	if duration < time.Second*time.Duration(importCfg.Progress) {
-		return
-	}
-
-	// Truncate the duration to 10s of milliseconds.
-	durationMillis := int64(duration / time.Millisecond)
-	tDuration := 10 * time.Millisecond * time.Duration(durationMillis/10)
-
-	// Log information about new block height.
-	blockStr := "blocks"
-	if bi.receivedLogBlocks == 1 {
-		blockStr = "block"
-	}
-	txStr := "transactions"
-	if bi.receivedLogTx == 1 {
-		txStr = "transaction"
-	}
-	log.Infof("Processed %d %s in the last %s (%d %s, height %d, %s)",
-		bi.receivedLogBlocks, blockStr, tDuration, bi.receivedLogTx,
-		txStr, bi.lastHeight, bi.lastBlockTime)
-
-	bi.receivedLogBlocks = 0
-	bi.receivedLogTx = 0
-	bi.lastLogTime = now
-}
-
-// processHandler is the main handler for processing blocks. This allows block
-// processing to take place in parallel with block reads from the import file.
-// It must be run as a goroutine.
-func (bi *blockImporter) processHandler() {
-out:
-	for {
-		select {
-		case serializedBlock, ok := <-bi.processQueue:
-			// We're done when the channel is closed.
-			if !ok {
-				break out
-			}
-
-			bi.blocksProcessed++
-			bi.lastHeight++
-			imported, err := bi.processBlock(serializedBlock)
-			if err != nil {
-				bi.errChan <- err
-				break out
-			}
-
-			if imported {
-				bi.blocksImported++
-			}
-
-			bi.logProgress()
-
-		case <-bi.quit:
-			break out
-		}
-	}
-	bi.wg.Done()
-}
-
-// statusHandler waits for updates from the import operation and notifies
-// the passed doneChan with the results of the import. It also causes all
-// goroutines to exit if an error is reported from any of them.
-func (bi *blockImporter) statusHandler(resultsChan chan *importResults) {
-	select {
-	// An error from either of the goroutines means we're done so signal
-	// caller with the error and signal all goroutines to quit.
-	case err := <-bi.errChan:
-		resultsChan <- &importResults{
-			blocksProcessed: bi.blocksProcessed,
-			blocksImported:  bi.blocksImported,
-			err:             err,
-		}
-		close(bi.quit)
-
-	// The import finished normally.
-	case <-bi.doneChan:
-		resultsChan <- &importResults{
-			blocksProcessed: bi.blocksProcessed,
-			blocksImported:  bi.blocksImported,
-			err:             nil,
-		}
-	}
-}
-
-// Import is the core function which handles importing the blocks from the file
-// associated with the block importer to the database. It returns a channel
-// on which the results will be returned when the operation has completed.
-func (bi *blockImporter) Import() chan *importResults {
-	// Start up the read and process handling goroutines. This setup allows
-	// blocks to be read from disk in parallel while being processed.
-	bi.wg.Add(2)
-	spawn(bi.readHandler)
-	spawn(bi.processHandler)
-
-	// Wait for the import to finish in a separate goroutine and signal
-	// the status handler when done.
-	spawn(func() {
-		bi.wg.Wait()
-		bi.doneChan <- true
-	})
-
-	// Start the status handler and return the result channel that it will
-	// send the results on when the import is done.
-	resultChan := make(chan *importResults)
-	go bi.statusHandler(resultChan)
-	return resultChan
-}
-
-// newBlockImporter returns a new importer for the provided file reader seeker
-// and database.
-func newBlockImporter(db database.DB, r io.ReadSeeker) *blockImporter {
-	return &blockImporter{
-		db:           db,
-		r:            r,
-		processQueue: make(chan []byte, 2),
-		doneChan:     make(chan bool),
-		errChan:      make(chan error),
-		quit:         make(chan struct{}),
-		lastLogTime:  time.Now(),
-	}
-}
-
-// Execute is the main entry point for the command. It's invoked by the parser.
-func (cmd *importCmd) Execute(args []string) error {
-	// Setup the global config options and ensure they are valid.
-	if err := setupGlobalConfig(); err != nil {
-		return err
-	}
-
-	// Ensure the specified block file exists.
-	if !fileExists(cmd.InFile) {
-		str := "The specified block file [%s] does not exist"
-		return errors.Errorf(str, cmd.InFile)
-	}
-
-	// Load the block database.
-	db, err := loadBlockDB()
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	// Ensure the database is sync'd and closed on Ctrl+C.
-	addInterruptHandler(func() {
-		log.Infof("Gracefully shutting down the database...")
-		db.Close()
-	})
-
-	fi, err := os.Open(importCfg.InFile)
-	if err != nil {
-		return err
-	}
-	defer fi.Close()
-
-	// Create a block importer for the database and input file and start it.
-	// The results channel returned from start will contain an error if
-	// anything went wrong.
-	importer := newBlockImporter(db, fi)
-
-	// Perform the import asynchronously and signal the main goroutine when
-	// done. This allows blocks to be processed and read in parallel. The
-	// results channel returned from Import contains the statistics about
-	// the import including an error if something went wrong. This is done
-	// in a separate goroutine rather than waiting directly so the main
-	// goroutine can be signaled for shutdown by either completion, error,
-	// or from the main interrupt handler. This is necessary since the main
-	// goroutine must be kept running long enough for the interrupt handler
-	// goroutine to finish.
-	spawn(func() {
-		log.Info("Starting import")
-		resultsChan := importer.Import()
-		results := <-resultsChan
-		if results.err != nil {
-			dbErr, ok := results.err.(database.Error)
-			if !ok || ok && dbErr.ErrorCode != database.ErrDbNotOpen {
-				shutdownChannel <- results.err
-				return
-			}
-		}
-
-		log.Infof("Processed a total of %d blocks (%d imported, %d "+
-			"already known)", results.blocksProcessed,
-			results.blocksImported,
-			results.blocksProcessed-results.blocksImported)
-		shutdownChannel <- nil
-	})
-
-	// Wait for shutdown signal from either a normal completion or from the
-	// interrupt handler.
-	err = <-shutdownChannel
-	return err
-}

database/cmd/dbtool/loadheaders.go

@@ -1,93 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"time"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// headersCmd defines the configuration options for the loadheaders command.
-type headersCmd struct {
-	Bulk bool `long:"bulk" description:"Use bulk loading of headers instead of one at a time"`
-}
-
-var (
-	// headersCfg defines the configuration options for the command.
-	headersCfg = headersCmd{
-		Bulk: false,
-	}
-)
-
-// Execute is the main entry point for the command. It's invoked by the parser.
-func (cmd *headersCmd) Execute(args []string) error {
-	// Setup the global config options and ensure they are valid.
-	if err := setupGlobalConfig(); err != nil {
-		return err
-	}
-
-	// Load the block database.
-	db, err := loadBlockDB()
-	if err != nil {
-		return err
-	}
-	defer db.Close()
-
-	// NOTE: This code will only work for ffldb. Ideally the package using
-	// the database would keep a metadata index of its own.
-	blockIdxName := []byte("ffldb-blockidx")
-	if !headersCfg.Bulk {
-		err = db.View(func(dbTx database.Tx) error {
-			totalHdrs := 0
-			blockIdxBucket := dbTx.Metadata().Bucket(blockIdxName)
-			blockIdxBucket.ForEach(func(k, v []byte) error {
-				totalHdrs++
-				return nil
-			})
-			log.Infof("Loading headers for %d blocks...", totalHdrs)
-			numLoaded := 0
-			startTime := time.Now()
-			blockIdxBucket.ForEach(func(k, v []byte) error {
-				var hash daghash.Hash
-				copy(hash[:], k)
-				_, err := dbTx.FetchBlockHeader(&hash)
-				if err != nil {
-					return err
-				}
-				numLoaded++
-				return nil
-			})
-			log.Infof("Loaded %d headers in %s", numLoaded,
-				time.Since(startTime))
-			return nil
-		})
-		return err
-	}
-
-	// Bulk load headers.
-	err = db.View(func(dbTx database.Tx) error {
-		blockIdxBucket := dbTx.Metadata().Bucket(blockIdxName)
-		hashes := make([]*daghash.Hash, 0, 500000)
-		blockIdxBucket.ForEach(func(k, v []byte) error {
-			var hash daghash.Hash
-			copy(hash[:], k)
-			hashes = append(hashes, &hash)
-			return nil
-		})
-
-		log.Infof("Loading headers for %d blocks...", len(hashes))
-		startTime := time.Now()
-		hdrs, err := dbTx.FetchBlockHeaders(hashes)
-		if err != nil {
-			return err
-		}
-		log.Infof("Loaded %d headers in %s", len(hdrs),
-			time.Since(startTime))
-		return nil
-	})
-	return err
-}

database/cmd/dbtool/main.go

@@ -1,119 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"github.com/kaspanet/kaspad/util/panics"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-
-	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/logger"
-	"github.com/kaspanet/kaspad/logs"
-)
-
-const (
-	// blockDbNamePrefix is the prefix for the kaspad block database.
-	blockDbNamePrefix = "blocks"
-)
-
-var (
-	log             logs.Logger
-	spawn           func(func())
-	shutdownChannel = make(chan error)
-)
-
-// loadBlockDB opens the block database and returns a handle to it.
-func loadBlockDB() (database.DB, error) {
-	// The database name is based on the database type.
-	dbName := blockDbNamePrefix + "_" + cfg.DbType
-	dbPath := filepath.Join(cfg.DataDir, dbName)
-
-	log.Infof("Loading block database from '%s'", dbPath)
-	db, err := database.Open(cfg.DbType, dbPath, activeNetParams.Net)
-	if err != nil {
-		// Return the error if it's not because the database doesn't
-		// exist.
-		if dbErr, ok := err.(database.Error); !ok || dbErr.ErrorCode !=
-			database.ErrDbDoesNotExist {
-
-			return nil, err
-		}
-
-		// Create the db if it does not exist.
-		err = os.MkdirAll(cfg.DataDir, 0700)
-		if err != nil {
-			return nil, err
-		}
-		db, err = database.Create(cfg.DbType, dbPath, activeNetParams.Net)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	log.Info("Block database loaded")
-	return db, nil
-}
-
-// realMain is the real main function for the utility. It is necessary to work
-// around the fact that deferred functions do not run when os.Exit() is called.
-func realMain() error {
-	// Setup logging.
-	backendLogger := logs.NewBackend()
-	defer os.Stdout.Sync()
-	log = backendLogger.Logger("MAIN")
-	spawn = panics.GoroutineWrapperFunc(log)
-	dbLog, _ := logger.Get(logger.SubsystemTags.BCDB)
-	dbLog.SetLevel(logs.LevelDebug)
-
-	// Setup the parser options and commands.
-	appName := filepath.Base(os.Args[0])
-	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
-	parserFlags := flags.Options(flags.HelpFlag | flags.PassDoubleDash)
-	parser := flags.NewNamedParser(appName, parserFlags)
-	parser.AddGroup("Global Options", "", cfg)
-	parser.AddCommand("insecureimport",
-		"Insecurely import bulk block data from bootstrap.dat",
-		"Insecurely import bulk block data from bootstrap.dat. "+
-			"WARNING: This is NOT secure because it does NOT "+
-			"verify DAG rules. It is only provided for testing "+
-			"purposes.", &importCfg)
-	parser.AddCommand("loadheaders",
-		"Time how long to load headers for all blocks in the database",
-		"", &headersCfg)
-	parser.AddCommand("fetchblock",
-		"Fetch the specific block hash from the database", "",
-		&fetchBlockCfg)
-	parser.AddCommand("fetchblockregion",
-		"Fetch the specified block region from the database", "",
-		&blockRegionCfg)
-
-	// Parse command line and invoke the Execute function for the specified
-	// command.
-	if _, err := parser.Parse(); err != nil {
-		if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp {
-			parser.WriteHelp(os.Stderr)
-		} else {
-			log.Error(err)
-		}
-
-		return err
-	}
-
-	return nil
-}
-
-func main() {
-	// Use all processor cores.
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	// Work around defer not working after os.Exit()
-	if err := realMain(); err != nil {
-		os.Exit(1)
-	}
-}

database/cmd/dbtool/signal.go

@@ -1,82 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"os"
-	"os/signal"
-)
-
-// interruptChannel is used to receive SIGINT (Ctrl+C) signals.
-var interruptChannel chan os.Signal
-
-// addHandlerChannel is used to add an interrupt handler to the list of handlers
-// to be invoked on SIGINT (Ctrl+C) signals.
-var addHandlerChannel = make(chan func())
-
-// mainInterruptHandler listens for SIGINT (Ctrl+C) signals on the
-// interruptChannel and invokes the registered interruptCallbacks accordingly.
-// It also listens for callback registration. It must be run as a goroutine.
-func mainInterruptHandler() {
-	// interruptCallbacks is a list of callbacks to invoke when a
-	// SIGINT (Ctrl+C) is received.
-	var interruptCallbacks []func()
-
-	// isShutdown is a flag which is used to indicate whether or not
-	// the shutdown signal has already been received and hence any future
-	// attempts to add a new interrupt handler should invoke them
-	// immediately.
-	var isShutdown bool
-
-	for {
-		select {
-		case <-interruptChannel:
-			// Ignore more than one shutdown signal.
-			if isShutdown {
-				log.Infof("Received SIGINT (Ctrl+C). " +
-					"Already shutting down...")
-				continue
-			}
-
-			isShutdown = true
-			log.Infof("Received SIGINT (Ctrl+C). Shutting down...")
-
-			// Run handlers in LIFO order.
-			for i := range interruptCallbacks {
-				idx := len(interruptCallbacks) - 1 - i
-				callback := interruptCallbacks[idx]
-				callback()
-			}
-
-			// Signal the main goroutine to shutdown.
-			spawn(func() {
-				shutdownChannel <- nil
-			})
-
-		case handler := <-addHandlerChannel:
-			// The shutdown signal has already been received, so
-			// just invoke and new handlers immediately.
-			if isShutdown {
-				handler()
-			}
-
-			interruptCallbacks = append(interruptCallbacks, handler)
-		}
-	}
-}
-
-// addInterruptHandler adds a handler to call when a SIGINT (Ctrl+C) is
-// received.
-func addInterruptHandler(handler func()) {
-	// Create the channel and start the main interrupt handler which invokes
-	// all other callbacks and exits if not already done.
-	if interruptChannel == nil {
-		interruptChannel = make(chan os.Signal, 1)
-		signal.Notify(interruptChannel, os.Interrupt)
-		spawn(mainInterruptHandler)
-	}
-
-	addHandlerChannel <- handler
-}

database/doc.go

@@ -1,85 +0,0 @@
-/*
-Package database provides a block and metadata storage database.
-
-Overview
-
-This package provides a database layer to store and retrieve this data in a
-simple and efficient manner.
-
-The default backend, ffldb, has a strong focus on speed, efficiency, and
-robustness. It makes use leveldb for the metadata, flat files for block
-storage, and strict checksums in key areas to ensure data integrity.
-
-A quick overview of the features database provides are as follows:
-
- - Key/value metadata store
- - Kaspa block storage
- - Efficient retrieval of block headers and regions (transactions, scripts, etc)
- - Read-only and read-write transactions with both manual and managed modes
- - Nested buckets
- - Supports registration of backend databases
- - Comprehensive test coverage
-
-Database
-
-The main entry point is the DB interface. It exposes functionality for
-transactional-based access and storage of metadata and block data. It is
-obtained via the Create and Open functions which take a database type string
-that identifies the specific database driver (backend) to use as well as
-arguments specific to the specified driver.
-
-The interface provides facilities for obtaining transactions (the Tx interface)
-that are the basis of all database reads and writes. Unlike some database
-interfaces that support reading and writing without transactions, this interface
-requires transactions even when only reading or writing a single key.
-
-The Begin function provides an unmanaged transaction while the View and Update
-functions provide a managed transaction. These are described in more detail
-below.
-
-Transactions
-
-The Tx interface provides facilities for rolling back or committing changes that
-took place while the transaction was active. It also provides the root metadata
-bucket under which all keys, values, and nested buckets are stored. A
-transaction can either be read-only or read-write and managed or unmanaged.
-
-Managed versus Unmanaged Transactions
-
-A managed transaction is one where the caller provides a function to execute
-within the context of the transaction and the commit or rollback is handled
-automatically depending on whether or not the provided function returns an
-error. Attempting to manually call Rollback or Commit on the managed
-transaction will result in a panic.
-
-An unmanaged transaction, on the other hand, requires the caller to manually
-call Commit or Rollback when they are finished with it. Leaving transactions
-open for long periods of time can have several adverse effects, so it is
-recommended that managed transactions are used instead.
-
-Buckets
-
-The Bucket interface provides the ability to manipulate key/value pairs and
-nested buckets as well as iterate through them.
-
-The Get, Put, and Delete functions work with key/value pairs, while the Bucket,
-CreateBucket, CreateBucketIfNotExists, and DeleteBucket functions work with
-buckets. The ForEach function allows the caller to provide a function to be
-called with each key/value pair and nested bucket in the current bucket.
-
-Metadata Bucket
-
-As discussed above, all of the functions which are used to manipulate key/value
-pairs and nested buckets exist on the Bucket interface. The root metadata
-bucket is the upper-most bucket in which data is stored and is created at the
-same time as the database. Use the Metadata function on the Tx interface
-to retrieve it.
-
-Nested Buckets
-
-The CreateBucket and CreateBucketIfNotExists functions on the Bucket interface
-provide the ability to create an arbitrary number of nested buckets. It is
-a good idea to avoid a lot of buckets with little data in them as it could lead
-to poor page utilization depending on the specific driver in use.
-*/
-package database

database/driver.go

@@ -1,84 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package database
-
-import (
-	"fmt"
-)
-
-// Driver defines a structure for backend drivers to use when they registered
-// themselves as a backend which implements the DB interface.
-type Driver struct {
-	// DbType is the identifier used to uniquely identify a specific
-	// database driver. There can be only one driver with the same name.
-	DbType string
-
-	// Create is the function that will be invoked with all user-specified
-	// arguments to create the database. This function must return
-	// ErrDbExists if the database already exists.
-	Create func(args ...interface{}) (DB, error)
-
-	// Open is the function that will be invoked with all user-specified
-	// arguments to open the database. This function must return
-	// ErrDbDoesNotExist if the database has not already been created.
-	Open func(args ...interface{}) (DB, error)
-}
-
-// driverList holds all of the registered database backends.
-var drivers = make(map[string]*Driver)
-
-// RegisterDriver adds a backend database driver to available interfaces.
-// ErrDbTypeRegistered will be returned if the database type for the driver has
-// already been registered.
-func RegisterDriver(driver Driver) error {
-	if _, exists := drivers[driver.DbType]; exists {
-		str := fmt.Sprintf("driver %q is already registered",
-			driver.DbType)
-		return makeError(ErrDbTypeRegistered, str, nil)
-	}
-
-	drivers[driver.DbType] = &driver
-	return nil
-}
-
-// SupportedDrivers returns a slice of strings that represent the database
-// drivers that have been registered and are therefore supported.
-func SupportedDrivers() []string {
-	supportedDBs := make([]string, 0, len(drivers))
-	for _, drv := range drivers {
-		supportedDBs = append(supportedDBs, drv.DbType)
-	}
-	return supportedDBs
-}
-
-// Create initializes and opens a database for the specified type. The
-// arguments are specific to the database type driver. See the documentation
-// for the database driver for further details.
-//
-// ErrDbUnknownType will be returned if the the database type is not registered.
-func Create(dbType string, args ...interface{}) (DB, error) {
-	drv, exists := drivers[dbType]
-	if !exists {
-		str := fmt.Sprintf("driver %q is not registered", dbType)
-		return nil, makeError(ErrDbUnknownType, str, nil)
-	}
-
-	return drv.Create(args...)
-}
-
-// Open opens an existing database for the specified type. The arguments are
-// specific to the database type driver. See the documentation for the database
-// driver for further details.
-//
-// ErrDbUnknownType will be returned if the the database type is not registered.
-func Open(dbType string, args ...interface{}) (DB, error) {
-	drv, exists := drivers[dbType]
-	if !exists {
-		str := fmt.Sprintf("driver %q is not registered", dbType)
-		return nil, makeError(ErrDbUnknownType, str, nil)
-	}
-
-	return drv.Open(args...)
-}

database/driver_test.go

@@ -1,136 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package database_test
-
-import (
-	"github.com/pkg/errors"
-	"testing"
-
-	"github.com/kaspanet/kaspad/database"
-	_ "github.com/kaspanet/kaspad/database/ffldb"
-)
-
-var (
-	// ignoreDbTypes are types which should be ignored when running tests
-	// that iterate all supported DB types. This allows some tests to add
-	// bogus drivers for testing purposes while still allowing other tests
-	// to easily iterate all supported drivers.
-	ignoreDbTypes = map[string]bool{"createopenfail": true}
-)
-
-// checkDbError ensures the passed error is a database.Error with an error code
-// that matches the passed  error code.
-func checkDbError(t *testing.T, testName string, gotErr error, wantErrCode database.ErrorCode) bool {
-	dbErr, ok := gotErr.(database.Error)
-	if !ok {
-		t.Errorf("%s: unexpected error type - got %T, want %T",
-			testName, gotErr, database.Error{})
-		return false
-	}
-	if dbErr.ErrorCode != wantErrCode {
-		t.Errorf("%s: unexpected error code - got %s (%s), want %s",
-			testName, dbErr.ErrorCode, dbErr.Description,
-			wantErrCode)
-		return false
-	}
-
-	return true
-}
-
-// TestAddDuplicateDriver ensures that adding a duplicate driver does not
-// overwrite an existing one.
-func TestAddDuplicateDriver(t *testing.T) {
-	supportedDrivers := database.SupportedDrivers()
-	if len(supportedDrivers) == 0 {
-		t.Errorf("no backends to test")
-		return
-	}
-	dbType := supportedDrivers[0]
-
-	// bogusCreateDB is a function which acts as a bogus create and open
-	// driver function and intentionally returns a failure that can be
-	// detected if the interface allows a duplicate driver to overwrite an
-	// existing one.
-	bogusCreateDB := func(args ...interface{}) (database.DB, error) {
-		return nil, errors.Errorf("duplicate driver allowed for database "+
-			"type [%v]", dbType)
-	}
-
-	// Create a driver that tries to replace an existing one. Set its
-	// create and open functions to a function that causes a test failure if
-	// they are invoked.
-	driver := database.Driver{
-		DbType: dbType,
-		Create: bogusCreateDB,
-		Open:   bogusCreateDB,
-	}
-	testName := "duplicate driver registration"
-	err := database.RegisterDriver(driver)
-	if !checkDbError(t, testName, err, database.ErrDbTypeRegistered) {
-		return
-	}
-}
-
-// TestCreateOpenFail ensures that errors which occur while opening or closing
-// a database are handled properly.
-func TestCreateOpenFail(t *testing.T) {
-	// bogusCreateDB is a function which acts as a bogus create and open
-	// driver function that intentionally returns a failure which can be
-	// detected.
-	dbType := "createopenfail"
-	openError := errors.Errorf("failed to create or open database for "+
-		"database type [%v]", dbType)
-	bogusCreateDB := func(args ...interface{}) (database.DB, error) {
-		return nil, openError
-	}
-
-	// Create and add driver that intentionally fails when created or opened
-	// to ensure errors on database open and create are handled properly.
-	driver := database.Driver{
-		DbType: dbType,
-		Create: bogusCreateDB,
-		Open:   bogusCreateDB,
-	}
-	database.RegisterDriver(driver)
-
-	// Ensure creating a database with the new type fails with the expected
-	// error.
-	_, err := database.Create(dbType)
-	if err != openError {
-		t.Errorf("expected error not received - got: %v, want %v", err,
-			openError)
-		return
-	}
-
-	// Ensure opening a database with the new type fails with the expected
-	// error.
-	_, err = database.Open(dbType)
-	if err != openError {
-		t.Errorf("expected error not received - got: %v, want %v", err,
-			openError)
-		return
-	}
-}
-
-// TestCreateOpenUnsupported ensures that attempting to create or open an
-// unsupported database type is handled properly.
-func TestCreateOpenUnsupported(t *testing.T) {
-	// Ensure creating a database with an unsupported type fails with the
-	// expected error.
-	testName := "create with unsupported database type"
-	dbType := "unsupported"
-	_, err := database.Create(dbType)
-	if !checkDbError(t, testName, err, database.ErrDbUnknownType) {
-		return
-	}
-
-	// Ensure opening a database with the an unsupported type fails with the
-	// expected error.
-	testName = "open with unsupported database type"
-	_, err = database.Open(dbType)
-	if !checkDbError(t, testName, err, database.ErrDbUnknownType) {
-		return
-	}
-}

database/error.go

@@ -1,207 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package database
-
-import "fmt"
-
-// ErrorCode identifies a kind of error.
-type ErrorCode int
-
-// These constants are used to identify a specific database Error.
-const (
-	// **************************************
-	// Errors related to driver registration.
-	// **************************************
-
-	// ErrDbTypeRegistered indicates two different database drivers
-	// attempt to register with the name database type.
-	ErrDbTypeRegistered ErrorCode = iota
-
-	// *************************************
-	// Errors related to database functions.
-	// *************************************
-
-	// ErrDbUnknownType indicates there is no driver registered for
-	// the specified database type.
-	ErrDbUnknownType
-
-	// ErrDbDoesNotExist indicates open is called for a database that
-	// does not exist.
-	ErrDbDoesNotExist
-
-	// ErrDbExists indicates create is called for a database that
-	// already exists.
-	ErrDbExists
-
-	// ErrDbNotOpen indicates a database instance is accessed before
-	// it is opened or after it is closed.
-	ErrDbNotOpen
-
-	// ErrDbAlreadyOpen indicates open was called on a database that
-	// is already open.
-	ErrDbAlreadyOpen
-
-	// ErrInvalid indicates the specified database is not valid.
-	ErrInvalid
-
-	// ErrCorruption indicates a checksum failure occurred which invariably
-	// means the database is corrupt.
-	ErrCorruption
-
-	// ****************************************
-	// Errors related to database transactions.
-	// ****************************************
-
-	// ErrTxClosed indicates an attempt was made to commit or rollback a
-	// transaction that has already had one of those operations performed.
-	ErrTxClosed
-
-	// ErrTxNotWritable indicates an operation that requires write access to
-	// the database was attempted against a read-only transaction.
-	ErrTxNotWritable
-
-	// **************************************
-	// Errors related to metadata operations.
-	// **************************************
-
-	// ErrBucketNotFound indicates an attempt to access a bucket that has
-	// not been created yet.
-	ErrBucketNotFound
-
-	// ErrBucketExists indicates an attempt to create a bucket that already
-	// exists.
-	ErrBucketExists
-
-	// ErrBucketNameRequired indicates an attempt to create a bucket with a
-	// blank name.
-	ErrBucketNameRequired
-
-	// ErrKeyRequired indicates at attempt to insert a zero-length key.
-	ErrKeyRequired
-
-	// ErrKeyTooLarge indicates an attmempt to insert a key that is larger
-	// than the max allowed key size. The max key size depends on the
-	// specific backend driver being used. As a general rule, key sizes
-	// should be relatively, so this should rarely be an issue.
-	ErrKeyTooLarge
-
-	// ErrValueTooLarge indicates an attmpt to insert a value that is larger
-	// than max allowed value size. The max key size depends on the
-	// specific backend driver being used.
-	ErrValueTooLarge
-
-	// ErrIncompatibleValue indicates the value in question is invalid for
-	// the specific requested operation. For example, trying create or
-	// delete a bucket with an existing non-bucket key, attempting to create
-	// or delete a non-bucket key with an existing bucket key, or trying to
-	// delete a value via a cursor when it points to a nested bucket.
-	ErrIncompatibleValue
-
-	// ***************************************
-	// Errors related to block I/O operations.
-	// ***************************************
-
-	// ErrBlockNotFound indicates a block with the provided hash does not
-	// exist in the database.
-	ErrBlockNotFound
-
-	// ErrBlockExists indicates a block with the provided hash already
-	// exists in the database.
-	ErrBlockExists
-
-	// ErrBlockRegionInvalid indicates a region that exceeds the bounds of
-	// the specified block was requested. When the hash provided by the
-	// region does not correspond to an existing block, the error will be
-	// ErrBlockNotFound instead.
-	ErrBlockRegionInvalid
-
-	// ***********************************
-	// Support for driver-specific errors.
-	// ***********************************
-
-	// ErrDriverSpecific indicates the Err field is a driver-specific error.
-	// This provides a mechanism for drivers to plug-in their own custom
-	// errors for any situations which aren't already covered by the error
-	// codes provided by this package.
-	ErrDriverSpecific
-
-	// numErrorCodes is the maximum error code number used in tests.
-	numErrorCodes
-)
-
-// Map of ErrorCode values back to their constant names for pretty printing.
-var errorCodeStrings = map[ErrorCode]string{
-	ErrDbTypeRegistered:   "ErrDbTypeRegistered",
-	ErrDbUnknownType:      "ErrDbUnknownType",
-	ErrDbDoesNotExist:     "ErrDbDoesNotExist",
-	ErrDbExists:           "ErrDbExists",
-	ErrDbNotOpen:          "ErrDbNotOpen",
-	ErrDbAlreadyOpen:      "ErrDbAlreadyOpen",
-	ErrInvalid:            "ErrInvalid",
-	ErrCorruption:         "ErrCorruption",
-	ErrTxClosed:           "ErrTxClosed",
-	ErrTxNotWritable:      "ErrTxNotWritable",
-	ErrBucketNotFound:     "ErrBucketNotFound",
-	ErrBucketExists:       "ErrBucketExists",
-	ErrBucketNameRequired: "ErrBucketNameRequired",
-	ErrKeyRequired:        "ErrKeyRequired",
-	ErrKeyTooLarge:        "ErrKeyTooLarge",
-	ErrValueTooLarge:      "ErrValueTooLarge",
-	ErrIncompatibleValue:  "ErrIncompatibleValue",
-	ErrBlockNotFound:      "ErrBlockNotFound",
-	ErrBlockExists:        "ErrBlockExists",
-	ErrBlockRegionInvalid: "ErrBlockRegionInvalid",
-	ErrDriverSpecific:     "ErrDriverSpecific",
-}
-
-// String returns the ErrorCode as a human-readable name.
-func (e ErrorCode) String() string {
-	if s := errorCodeStrings[e]; s != "" {
-		return s
-	}
-	return fmt.Sprintf("Unknown ErrorCode (%d)", int(e))
-}
-
-// Error provides a single type for errors that can happen during database
-// operation. It is used to indicate several types of failures including errors
-// with caller requests such as specifying invalid block regions or attempting
-// to access data against closed database transactions, driver errors, errors
-// retrieving data, and errors communicating with database servers.
-//
-// The caller can use type assertions to determine if an error is an Error and
-// access the ErrorCode field to ascertain the specific reason for the failure.
-//
-// The ErrDriverSpecific error code will also have the Err field set with the
-// underlying error. Depending on the backend driver, the Err field might be
-// set to the underlying error for other error codes as well.
-type Error struct {
-	ErrorCode   ErrorCode // Describes the kind of error
-	Description string    // Human readable description of the issue
-	Err         error     // Underlying error
-}
-
-// Error satisfies the error interface and prints human-readable errors.
-func (e Error) Error() string {
-	if e.Err != nil {
-		return e.Description + ": " + e.Err.Error()
-	}
-	return e.Description
-}
-
-// makeError creates an Error given a set of arguments. The error code must
-// be one of the error codes provided by this package.
-func makeError(c ErrorCode, desc string, err error) Error {
-	return Error{ErrorCode: c, Description: desc, Err: err}
-}
-
-// IsErrorCode returns whether or not the provided error is a script error with
-// the provided error code.
-func IsErrorCode(err error, c ErrorCode) bool {
-	if err, ok := err.(Error); ok {
-		return err.ErrorCode == c
-	}
-
-	return false
-}

database/error_test.go

@@ -1,118 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package database
-
-import (
-	"github.com/pkg/errors"
-	"testing"
-)
-
-// TestErrorCodeStringer tests the stringized output for the ErrorCode type.
-func TestErrorCodeStringer(t *testing.T) {
-	tests := []struct {
-		in   ErrorCode
-		want string
-	}{
-		{ErrDbTypeRegistered, "ErrDbTypeRegistered"},
-		{ErrDbUnknownType, "ErrDbUnknownType"},
-		{ErrDbDoesNotExist, "ErrDbDoesNotExist"},
-		{ErrDbExists, "ErrDbExists"},
-		{ErrDbNotOpen, "ErrDbNotOpen"},
-		{ErrDbAlreadyOpen, "ErrDbAlreadyOpen"},
-		{ErrInvalid, "ErrInvalid"},
-		{ErrCorruption, "ErrCorruption"},
-		{ErrTxClosed, "ErrTxClosed"},
-		{ErrTxNotWritable, "ErrTxNotWritable"},
-		{ErrBucketNotFound, "ErrBucketNotFound"},
-		{ErrBucketExists, "ErrBucketExists"},
-		{ErrBucketNameRequired, "ErrBucketNameRequired"},
-		{ErrKeyRequired, "ErrKeyRequired"},
-		{ErrKeyTooLarge, "ErrKeyTooLarge"},
-		{ErrValueTooLarge, "ErrValueTooLarge"},
-		{ErrIncompatibleValue, "ErrIncompatibleValue"},
-		{ErrBlockNotFound, "ErrBlockNotFound"},
-		{ErrBlockExists, "ErrBlockExists"},
-		{ErrBlockRegionInvalid, "ErrBlockRegionInvalid"},
-		{ErrDriverSpecific, "ErrDriverSpecific"},
-
-		{0xffff, "Unknown ErrorCode (65535)"},
-	}
-
-	// Detect additional error codes that don't have the stringer added.
-	if len(tests)-1 != int(TstNumErrorCodes) {
-		t.Errorf("It appears an error code was added without adding " +
-			"an associated stringer test")
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		result := test.in.String()
-		if result != test.want {
-			t.Errorf("String #%d\ngot: %s\nwant: %s", i, result,
-				test.want)
-			continue
-		}
-	}
-}
-
-// TestError tests the error output for the Error type.
-func TestError(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		in   Error
-		want string
-	}{
-		{
-			Error{Description: "some error"},
-			"some error",
-		},
-		{
-			Error{Description: "human-readable error"},
-			"human-readable error",
-		},
-		{
-			Error{
-				ErrorCode:   ErrDriverSpecific,
-				Description: "some error",
-				Err:         errors.New("driver-specific error"),
-			},
-			"some error: driver-specific error",
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		result := test.in.Error()
-		if result != test.want {
-			t.Errorf("Error #%d\n got: %s want: %s", i, result,
-				test.want)
-			continue
-		}
-	}
-}
-
-func TestIsErrorCode(t *testing.T) {
-	dummyError := errors.New("")
-
-	tests := []struct {
-		err            error
-		code           ErrorCode
-		expectedResult bool
-	}{
-		{makeError(ErrBucketExists, "", dummyError), ErrBucketExists, true},
-		{makeError(ErrBucketExists, "", dummyError), ErrBlockExists, false},
-		{dummyError, ErrBlockExists, false},
-		{nil, ErrBlockExists, false},
-	}
-
-	for i, test := range tests {
-		actualResult := IsErrorCode(test.err, test.code)
-		if test.expectedResult != actualResult {
-			t.Errorf("TestIsErrorCode: %d: Expected: %t, but got: %t",
-				i, test.expectedResult, actualResult)
-		}
-	}
-}

database/example_test.go

@@ -1,180 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package database_test
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/pkg/errors"
-	"os"
-	"path/filepath"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	_ "github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// This example demonstrates creating a new database.
-func ExampleCreate() {
-	// This example assumes the ffldb driver is imported.
-	//
-	// import (
-	// 	"github.com/kaspanet/kaspad/database"
-	// 	_ "github.com/kaspanet/kaspad/database/ffldb"
-	// )
-
-	// Create a database and schedule it to be closed and removed on exit.
-	// Typically you wouldn't want to remove the database right away like
-	// this, nor put it in the temp directory, but it's done here to ensure
-	// the example cleans up after itself.
-	dbPath := filepath.Join(os.TempDir(), "examplecreate")
-	db, err := database.Create("ffldb", dbPath, wire.Mainnet)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-
-	// Output:
-}
-
-// This example demonstrates creating a new database and using a managed
-// read-write transaction to store and retrieve metadata.
-func Example_basicUsage() {
-	// This example assumes the ffldb driver is imported.
-	//
-	// import (
-	// 	"github.com/kaspanet/kaspad/database"
-	// 	_ "github.com/kaspanet/kaspad/database/ffldb"
-	// )
-
-	// Create a database and schedule it to be closed and removed on exit.
-	// Typically you wouldn't want to remove the database right away like
-	// this, nor put it in the temp directory, but it's done here to ensure
-	// the example cleans up after itself.
-	dbPath := filepath.Join(os.TempDir(), "exampleusage")
-	// ensure that DB does not exist before test starts
-	os.RemoveAll(dbPath)
-	db, err := database.Create("ffldb", dbPath, wire.Mainnet)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-
-	// Use the Update function of the database to perform a managed
-	// read-write transaction. The transaction will automatically be rolled
-	// back if the supplied inner function returns a non-nil error.
-	err = db.Update(func(dbTx database.Tx) error {
-		// Store a key/value pair directly in the metadata bucket.
-		// Typically a nested bucket would be used for a given feature,
-		// but this example is using the metadata bucket directly for
-		// simplicity.
-		key := []byte("mykey")
-		value := []byte("myvalue")
-		if err := dbTx.Metadata().Put(key, value); err != nil {
-			return err
-		}
-
-		// Read the key back and ensure it matches.
-		if !bytes.Equal(dbTx.Metadata().Get(key), value) {
-			return errors.Errorf("unexpected value for key '%s'", key)
-		}
-
-		// Create a new nested bucket under the metadata bucket.
-		nestedBucketKey := []byte("mybucket")
-		nestedBucket, err := dbTx.Metadata().CreateBucket(nestedBucketKey)
-		if err != nil {
-			return err
-		}
-
-		// The key from above that was set in the metadata bucket does
-		// not exist in this new nested bucket.
-		if nestedBucket.Get(key) != nil {
-			return errors.Errorf("key '%s' is not expected nil", key)
-		}
-
-		return nil
-	})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	// Output:
-}
-
-// This example demonstrates creating a new database, using a managed read-write
-// transaction to store a block, and using a managed read-only transaction to
-// fetch the block.
-func Example_blockStorageAndRetrieval() {
-	// This example assumes the ffldb driver is imported.
-	//
-	// import (
-	// 	"github.com/kaspanet/kaspad/database"
-	// 	_ "github.com/kaspanet/kaspad/database/ffldb"
-	// )
-
-	// Create a database and schedule it to be closed and removed on exit.
-	// Typically you wouldn't want to remove the database right away like
-	// this, nor put it in the temp directory, but it's done here to ensure
-	// the example cleans up after itself.
-	dbPath := filepath.Join(os.TempDir(), "exampleblkstorage")
-	db, err := database.Create("ffldb", dbPath, wire.Mainnet)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-
-	// Use the Update function of the database to perform a managed
-	// read-write transaction and store a genesis block in the database as
-	// and example.
-	err = db.Update(func(dbTx database.Tx) error {
-		genesisBlock := dagconfig.MainnetParams.GenesisBlock
-		return dbTx.StoreBlock(util.NewBlock(genesisBlock))
-	})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	// Use the View function of the database to perform a managed read-only
-	// transaction and fetch the block stored above.
-	var loadedBlockBytes []byte
-	err = db.Update(func(dbTx database.Tx) error {
-		genesisHash := dagconfig.MainnetParams.GenesisHash
-		blockBytes, err := dbTx.FetchBlock(genesisHash)
-		if err != nil {
-			return err
-		}
-
-		// As documented, all data fetched from the database is only
-		// valid during a database transaction in order to support
-		// zero-copy backends. Thus, make a copy of the data so it
-		// can be used outside of the transaction.
-		loadedBlockBytes = make([]byte, len(blockBytes))
-		copy(loadedBlockBytes, blockBytes)
-		return nil
-	})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	// Typically at this point, the block could be deserialized via the
-	// wire.MsgBlock.Deserialize function or used in its serialized form
-	// depending on need. However, for this example, just display the
-	// number of serialized bytes to show it was loaded as expected.
-	fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes))
-
-	// Output:
-	// Serialized block size: 280 bytes
-}

database/export_test.go

@@ -1,17 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-/*
-This test file is part of the database package rather than than the
-database_test package so it can bridge access to the internals to properly test
-cases which are either not possible or can't reliably be tested via the public
-interface. The functions, constants, and variables are only exported while the
-tests are being run.
-*/
-
-package database
-
-// TstNumErrorCodes makes the internal numErrorCodes parameter available to the
-// test package.
-const TstNumErrorCodes = numErrorCodes

database/ffldb/README.md

@@ -1,34 +0,0 @@
-ffldb
-=====
-
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
-[![GoDoc](https://godoc.org/github.com/kaspanet/kaspad/database/ffldb?status.png)](http://godoc.org/github.com/kaspanet/kaspad/database/ffldb)
-=======
-
-Package ffldb implements a driver for the database package that uses leveldb for
-the backing metadata and flat files for block storage.
-
-This driver is the recommended driver for use with kaspad. It makes use of leveldb
-for the metadata, flat files for block storage, and checksums in key areas to
-ensure data integrity.
-
-## Usage
-
-This package is a driver to the database package and provides the database type
-of "ffldb". The parameters the Open and Create functions take are the
-database path as a string and the block network.
-
-```Go
-db, err := database.Open("ffldb", "path/to/database", wire.Mainnet)
-if err != nil {
-	// Handle error
-}
-```
-
-```Go
-db, err := database.Create("ffldb", "path/to/database", wire.Mainnet)
-if err != nil {
-	// Handle error
-}
-```
-

database/ffldb/bench_test.go

@@ -1,97 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package ffldb
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-)
-
-// BenchmarkBlockHeader benchmarks how long it takes to load the mainnet genesis
-// block header.
-func BenchmarkBlockHeader(b *testing.B) {
-	// Start by creating a new database and populating it with the mainnet
-	// genesis block.
-	dbPath := filepath.Join(os.TempDir(), "ffldb-benchblkhdr")
-	_ = os.RemoveAll(dbPath)
-	db, err := database.Create("ffldb", dbPath, blockDataNet)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-	err = db.Update(func(dbTx database.Tx) error {
-		block := util.NewBlock(dagconfig.MainnetParams.GenesisBlock)
-		return dbTx.StoreBlock(block)
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	err = db.View(func(dbTx database.Tx) error {
-		blockHash := dagconfig.MainnetParams.GenesisHash
-		for i := 0; i < b.N; i++ {
-			_, err := dbTx.FetchBlockHeader(blockHash)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// Don't benchmark teardown.
-	b.StopTimer()
-}
-
-// BenchmarkBlockHeader benchmarks how long it takes to load the mainnet genesis
-// block.
-func BenchmarkBlock(b *testing.B) {
-	// Start by creating a new database and populating it with the mainnet
-	// genesis block.
-	dbPath := filepath.Join(os.TempDir(), "ffldb-benchblk")
-	_ = os.RemoveAll(dbPath)
-	db, err := database.Create("ffldb", dbPath, blockDataNet)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-	err = db.Update(func(dbTx database.Tx) error {
-		block := util.NewBlock(dagconfig.MainnetParams.GenesisBlock)
-		return dbTx.StoreBlock(block)
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	err = db.View(func(dbTx database.Tx) error {
-		blockHash := dagconfig.MainnetParams.GenesisHash
-		for i := 0; i < b.N; i++ {
-			_, err := dbTx.FetchBlock(blockHash)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	// Don't benchmark teardown.
-	b.StopTimer()
-}

database/ffldb/blockio.go

@@ -1,773 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-// This file contains the implementation functions for reading, writing, and
-// otherwise working with the flat files that house the actual blocks.
-
-package ffldb
-
-import (
-	"container/list"
-	"encoding/binary"
-	"fmt"
-	"hash/crc32"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-	"syscall"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const (
-	// maxOpenFiles is the max number of open files to maintain in the
-	// open blocks cache. Note that this does not include the current
-	// write file, so there will typically be one more than this value open.
-	maxOpenFiles = 25
-
-	// maxBlockFileSize is the maximum size for each file used to store
-	// blocks.
-	//
-	// NOTE: The current code uses uint32 for all offsets, so this value
-	// must be less than 2^32 (4 GiB). This is also why it's a typed
-	// constant.
-	maxBlockFileSize uint32 = 512 * 1024 * 1024 // 512 MiB
-
-	// blockLocSize is the number of bytes the serialized block location
-	// data that is stored in the block index.
-	//
-	// The serialized block location format is:
-	//
-	//  [0:4]  Block file (4 bytes)
-	//  [4:8]  File offset (4 bytes)
-	//  [8:12] Block length (4 bytes)
-	blockLocSize = 12
-)
-
-var (
-	// castagnoli houses the Catagnoli polynomial used for CRC-32 checksums.
-	castagnoli = crc32.MakeTable(crc32.Castagnoli)
-)
-
-// filer is an interface which acts very similar to a *os.File and is typically
-// implemented by it. It exists so the test code can provide mock files for
-// properly testing corruption and file system issues.
-type filer interface {
-	io.Closer
-	io.WriterAt
-	io.ReaderAt
-	Truncate(size int64) error
-	Sync() error
-}
-
-// lockableFile represents a block file on disk that has been opened for either
-// read or read/write access. It also contains a read-write mutex to support
-// multiple concurrent readers.
-type lockableFile struct {
-	sync.RWMutex
-	file filer
-}
-
-// writeCursor represents the current file and offset of the block file on disk
-// for performing all writes. It also contains a read-write mutex to support
-// multiple concurrent readers which can reuse the file handle.
-type writeCursor struct {
-	sync.RWMutex
-
-	// curFile is the current block file that will be appended to when
-	// writing new blocks.
-	curFile *lockableFile
-
-	// curFileNum is the current block file number and is used to allow
-	// readers to use the same open file handle.
-	curFileNum uint32
-
-	// curOffset is the offset in the current write block file where the
-	// next new block will be written.
-	curOffset uint32
-}
-
-// blockStore houses information used to handle reading and writing blocks (and
-// part of blocks) into flat files with support for multiple concurrent readers.
-type blockStore struct {
-	// network is the specific network to use in the flat files for each
-	// block.
-	network wire.KaspaNet
-
-	// basePath is the base path used for the flat block files and metadata.
-	basePath string
-
-	// maxBlockFileSize is the maximum size for each file used to store
-	// blocks. It is defined on the store so the whitebox tests can
-	// override the value.
-	maxBlockFileSize uint32
-
-	// maxOpenFiles is the max number of open files to maintain in the
-	// open blocks cache. Note that this does not include the current
-	// write file, so there will typically be one more than this value open.
-	// It is defined on the store so the whitebox tests can override the value.
-	maxOpenFiles int
-
-	// The following fields are related to the flat files which hold the
-	// actual blocks. The number of open files is limited by maxOpenFiles.
-	//
-	// obfMutex protects concurrent access to the openBlockFiles map. It is
-	// a RWMutex so multiple readers can simultaneously access open files.
-	//
-	// openBlockFiles houses the open file handles for existing block files
-	// which have been opened read-only along with an individual RWMutex.
-	// This scheme allows multiple concurrent readers to the same file while
-	// preventing the file from being closed out from under them.
-	//
-	// lruMutex protects concurrent access to the least recently used list
-	// and lookup map.
-	//
-	// openBlocksLRU tracks how the open files are refenced by pushing the
-	// most recently used files to the front of the list thereby trickling
-	// the least recently used files to end of the list. When a file needs
-	// to be closed due to exceeding the the max number of allowed open
-	// files, the one at the end of the list is closed.
-	//
-	// fileNumToLRUElem is a mapping between a specific block file number
-	// and the associated list element on the least recently used list.
-	//
-	// Thus, with the combination of these fields, the database supports
-	// concurrent non-blocking reads across multiple and individual files
-	// along with intelligently limiting the number of open file handles by
-	// closing the least recently used files as needed.
-	//
-	// NOTE: The locking order used throughout is well-defined and MUST be
-	// followed. Failure to do so could lead to deadlocks. In particular,
-	// the locking order is as follows:
-	//   1) obfMutex
-	//   2) lruMutex
-	//   3) writeCursor mutex
-	//   4) specific file mutexes
-	//
-	// None of the mutexes are required to be locked at the same time, and
-	// often aren't. However, if they are to be locked simultaneously, they
-	// MUST be locked in the order previously specified.
-	//
-	// Due to the high performance and multi-read concurrency requirements,
-	// write locks should only be held for the minimum time necessary.
-	obfMutex         sync.RWMutex
-	lruMutex         sync.Mutex
-	openBlocksLRU    *list.List // Contains uint32 block file numbers.
-	fileNumToLRUElem map[uint32]*list.Element
-	openBlockFiles   map[uint32]*lockableFile
-
-	// writeCursor houses the state for the current file and location that
-	// new blocks are written to.
-	writeCursor *writeCursor
-
-	// These functions are set to openFile, openWriteFile, and deleteFile by
-	// default, but are exposed here to allow the whitebox tests to replace
-	// them when working with mock files.
-	openFileFunc      func(fileNum uint32) (*lockableFile, error)
-	openWriteFileFunc func(fileNum uint32) (filer, error)
-	deleteFileFunc    func(fileNum uint32) error
-}
-
-// blockLocation identifies a particular block file and location.
-type blockLocation struct {
-	blockFileNum uint32
-	fileOffset   uint32
-	blockLen     uint32
-}
-
-// deserializeBlockLoc deserializes the passed serialized block location
-// information. This is data stored into the block index metadata for each
-// block. The serialized data passed to this function MUST be at least
-// blockLocSize bytes or it will panic. The error check is avoided here because
-// this information will always be coming from the block index which includes a
-// checksum to detect corruption. Thus it is safe to use this unchecked here.
-func deserializeBlockLoc(serializedLoc []byte) blockLocation {
-	// The serialized block location format is:
-	//
-	//  [0:4]  Block file (4 bytes)
-	//  [4:8]  File offset (4 bytes)
-	//  [8:12] Block length (4 bytes)
-	return blockLocation{
-		blockFileNum: byteOrder.Uint32(serializedLoc[0:4]),
-		fileOffset:   byteOrder.Uint32(serializedLoc[4:8]),
-		blockLen:     byteOrder.Uint32(serializedLoc[8:12]),
-	}
-}
-
-// serializeBlockLoc returns the serialization of the passed block location.
-// This is data to be stored into the block index metadata for each block.
-func serializeBlockLoc(loc blockLocation) []byte {
-	// The serialized block location format is:
-	//
-	//  [0:4]  Block file (4 bytes)
-	//  [4:8]  File offset (4 bytes)
-	//  [8:12] Block length (4 bytes)
-	var serializedData [12]byte
-	byteOrder.PutUint32(serializedData[0:4], loc.blockFileNum)
-	byteOrder.PutUint32(serializedData[4:8], loc.fileOffset)
-	byteOrder.PutUint32(serializedData[8:12], loc.blockLen)
-	return serializedData[:]
-}
-
-// blockFilePath return the file path for the provided block file number.
-func blockFilePath(dbPath string, fileNum uint32) string {
-	// Choose 9 digits of precision for the filenames. 9 digits provide
-	// 10^9 files @ 512MiB each a total of ~476.84PiB.
-
-	fileName := fmt.Sprintf("%09d.fdb", fileNum)
-	return filepath.Join(dbPath, fileName)
-}
-
-// openWriteFile returns a file handle for the passed flat file number in
-// read/write mode. The file will be created if needed. It is typically used
-// for the current file that will have all new data appended. Unlike openFile,
-// this function does not keep track of the open file and it is not subject to
-// the maxOpenFiles limit.
-func (s *blockStore) openWriteFile(fileNum uint32) (filer, error) {
-	// The current block file needs to be read-write so it is possible to
-	// append to it. Also, it shouldn't be part of the least recently used
-	// file.
-	filePath := blockFilePath(s.basePath, fileNum)
-	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0666)
-	if err != nil {
-		str := fmt.Sprintf("failed to open file %q: %s", filePath, err)
-		return nil, makeDbErr(database.ErrDriverSpecific, str, err)
-	}
-
-	return file, nil
-}
-
-// openFile returns a read-only file handle for the passed flat file number.
-// The function also keeps track of the open files, performs least recently
-// used tracking, and limits the number of open files to maxOpenFiles by closing
-// the least recently used file as needed.
-//
-// This function MUST be called with the overall files mutex (s.obfMutex) locked
-// for WRITES.
-func (s *blockStore) openFile(fileNum uint32) (*lockableFile, error) {
-	// Open the appropriate file as read-only.
-	filePath := blockFilePath(s.basePath, fileNum)
-	file, err := os.Open(filePath)
-	if err != nil {
-		return nil, makeDbErr(database.ErrDriverSpecific, err.Error(),
-			err)
-	}
-	blockFile := &lockableFile{file: file}
-
-	// Close the least recently used file if the file exceeds the max
-	// allowed open files. This is not done until after the file open in
-	// case the file fails to open, there is no need to close any files.
-	//
-	// A write lock is required on the LRU list here to protect against
-	// modifications happening as already open files are read from and
-	// shuffled to the front of the list.
-	//
-	// Also, add the file that was just opened to the front of the least
-	// recently used list to indicate it is the most recently used file and
-	// therefore should be closed last.
-	s.lruMutex.Lock()
-	lruList := s.openBlocksLRU
-	if lruList.Len() >= s.maxOpenFiles {
-		lruFileNum := lruList.Remove(lruList.Back()).(uint32)
-		oldBlockFile := s.openBlockFiles[lruFileNum]
-
-		// Close the old file under the write lock for the file in case
-		// any readers are currently reading from it so it's not closed
-		// out from under them.
-		oldBlockFile.Lock()
-		_ = oldBlockFile.file.Close()
-		oldBlockFile.Unlock()
-
-		delete(s.openBlockFiles, lruFileNum)
-		delete(s.fileNumToLRUElem, lruFileNum)
-	}
-	s.fileNumToLRUElem[fileNum] = lruList.PushFront(fileNum)
-	s.lruMutex.Unlock()
-
-	// Store a reference to it in the open block files map.
-	s.openBlockFiles[fileNum] = blockFile
-
-	return blockFile, nil
-}
-
-// deleteFile removes the block file for the passed flat file number. The file
-// must already be closed and it is the responsibility of the caller to do any
-// other state cleanup necessary.
-func (s *blockStore) deleteFile(fileNum uint32) error {
-	filePath := blockFilePath(s.basePath, fileNum)
-	if err := os.Remove(filePath); err != nil {
-		return makeDbErr(database.ErrDriverSpecific, err.Error(), err)
-	}
-
-	return nil
-}
-
-// blockFile attempts to return an existing file handle for the passed flat file
-// number if it is already open as well as marking it as most recently used. It
-// will also open the file when it's not already open subject to the rules
-// described in openFile.
-//
-// NOTE: The returned block file will already have the read lock acquired and
-// the caller MUST call .RUnlock() to release it once it has finished all read
-// operations. This is necessary because otherwise it would be possible for a
-// separate goroutine to close the file after it is returned from here, but
-// before the caller has acquired a read lock.
-func (s *blockStore) blockFile(fileNum uint32) (*lockableFile, error) {
-	// When the requested block file is open for writes, return it.
-	wc := s.writeCursor
-	wc.RLock()
-	if fileNum == wc.curFileNum && wc.curFile.file != nil {
-		obf := wc.curFile
-		obf.RLock()
-		wc.RUnlock()
-		return obf, nil
-	}
-	wc.RUnlock()
-
-	// Try to return an open file under the overall files read lock.
-	s.obfMutex.RLock()
-	if obf, ok := s.openBlockFiles[fileNum]; ok {
-		s.lruMutex.Lock()
-		s.openBlocksLRU.MoveToFront(s.fileNumToLRUElem[fileNum])
-		s.lruMutex.Unlock()
-
-		obf.RLock()
-		s.obfMutex.RUnlock()
-		return obf, nil
-	}
-	s.obfMutex.RUnlock()
-
-	// Since the file isn't open already, need to check the open block files
-	// map again under write lock in case multiple readers got here and a
-	// separate one is already opening the file.
-	s.obfMutex.Lock()
-	if obf, ok := s.openBlockFiles[fileNum]; ok {
-		obf.RLock()
-		s.obfMutex.Unlock()
-		return obf, nil
-	}
-
-	// The file isn't open, so open it while potentially closing the least
-	// recently used one as needed.
-	obf, err := s.openFileFunc(fileNum)
-	if err != nil {
-		s.obfMutex.Unlock()
-		return nil, err
-	}
-	obf.RLock()
-	s.obfMutex.Unlock()
-	return obf, nil
-}
-
-// writeData is a helper function for writeBlock which writes the provided data
-// at the current write offset and updates the write cursor accordingly. The
-// field name parameter is only used when there is an error to provide a nicer
-// error message.
-//
-// The write cursor will be advanced the number of bytes actually written in the
-// event of failure.
-//
-// NOTE: This function MUST be called with the write cursor current file lock
-// held and must only be called during a write transaction so it is effectively
-// locked for writes. Also, the write cursor current file must NOT be nil.
-func (s *blockStore) writeData(data []byte, fieldName string) error {
-	wc := s.writeCursor
-	n, err := wc.curFile.file.WriteAt(data, int64(wc.curOffset))
-	wc.curOffset += uint32(n)
-	if err != nil {
-		if pathErr, isOk := err.(*os.PathError); isOk && pathErr.Err == syscall.ENOSPC {
-			log.Errorf("No space left on the hard disk, exiting...")
-			os.Exit(1)
-		}
-		str := fmt.Sprintf("failed to write %s to file %d at "+
-			"offset %d: %s", fieldName, wc.curFileNum,
-			wc.curOffset-uint32(n), err)
-		return makeDbErr(database.ErrDriverSpecific, str, err)
-	}
-
-	return nil
-}
-
-// writeBlock appends the specified raw block bytes to the store's write cursor
-// location and increments it accordingly. When the block would exceed the max
-// file size for the current flat file, this function will close the current
-// file, create the next file, update the write cursor, and write the block to
-// the new file.
-//
-// The write cursor will also be advanced the number of bytes actually written
-// in the event of failure.
-//
-// Format: <network><block length><serialized block><checksum>
-func (s *blockStore) writeBlock(rawBlock []byte) (blockLocation, error) {
-	// Compute how many bytes will be written.
-	// 4 bytes each for block network + 4 bytes for block length +
-	// length of raw block + 4 bytes for checksum.
-	blockLen := uint32(len(rawBlock))
-	fullLen := blockLen + 12
-
-	// Move to the next block file if adding the new block would exceed the
-	// max allowed size for the current block file. Also detect overflow
-	// to be paranoid, even though it isn't possible currently, numbers
-	// might change in the future to make it possible.
-	//
-	// NOTE: The writeCursor.offset field isn't protected by the mutex
-	// since it's only read/changed during this function which can only be
-	// called during a write transaction, of which there can be only one at
-	// a time.
-	wc := s.writeCursor
-	finalOffset := wc.curOffset + fullLen
-	if finalOffset < wc.curOffset || finalOffset > s.maxBlockFileSize {
-		// This is done under the write cursor lock since the curFileNum
-		// field is accessed elsewhere by readers.
-		//
-		// Close the current write file to force a read-only reopen
-		// with LRU tracking. The close is done under the write lock
-		// for the file to prevent it from being closed out from under
-		// any readers currently reading from it.
-		wc.Lock()
-		wc.curFile.Lock()
-		if wc.curFile.file != nil {
-			_ = wc.curFile.file.Close()
-			wc.curFile.file = nil
-		}
-		wc.curFile.Unlock()
-
-		// Start writes into next file.
-		wc.curFileNum++
-		wc.curOffset = 0
-		wc.Unlock()
-	}
-
-	// All writes are done under the write lock for the file to ensure any
-	// readers are finished and blocked first.
-	wc.curFile.Lock()
-	defer wc.curFile.Unlock()
-
-	// Open the current file if needed. This will typically only be the
-	// case when moving to the next file to write to or on initial database
-	// load. However, it might also be the case if rollbacks happened after
-	// file writes started during a transaction commit.
-	if wc.curFile.file == nil {
-		file, err := s.openWriteFileFunc(wc.curFileNum)
-		if err != nil {
-			return blockLocation{}, err
-		}
-		wc.curFile.file = file
-	}
-
-	// Kaspa network.
-	origOffset := wc.curOffset
-	hasher := crc32.New(castagnoli)
-	var scratch [4]byte
-	byteOrder.PutUint32(scratch[:], uint32(s.network))
-	if err := s.writeData(scratch[:], "network"); err != nil {
-		return blockLocation{}, err
-	}
-	_, _ = hasher.Write(scratch[:])
-
-	// Block length.
-	byteOrder.PutUint32(scratch[:], blockLen)
-	if err := s.writeData(scratch[:], "block length"); err != nil {
-		return blockLocation{}, err
-	}
-	_, _ = hasher.Write(scratch[:])
-
-	// Serialized block.
-	if err := s.writeData(rawBlock[:], "block"); err != nil {
-		return blockLocation{}, err
-	}
-	_, _ = hasher.Write(rawBlock)
-
-	// Castagnoli CRC-32 as a checksum of all the previous.
-	if err := s.writeData(hasher.Sum(nil), "checksum"); err != nil {
-		return blockLocation{}, err
-	}
-
-	loc := blockLocation{
-		blockFileNum: wc.curFileNum,
-		fileOffset:   origOffset,
-		blockLen:     fullLen,
-	}
-	return loc, nil
-}
-
-// readBlock reads the specified block record and returns the serialized block.
-// It ensures the integrity of the block data by checking that the serialized
-// network matches the current network associated with the block store and
-// comparing the calculated checksum against the one stored in the flat file.
-// This function also automatically handles all file management such as opening
-// and closing files as necessary to stay within the maximum allowed open files
-// limit.
-//
-// Returns ErrDriverSpecific if the data fails to read for any reason and
-// ErrCorruption if the checksum of the read data doesn't match the checksum
-// read from the file.
-//
-// Format: <network><block length><serialized block><checksum>
-func (s *blockStore) readBlock(hash *daghash.Hash, loc blockLocation) ([]byte, error) {
-	// Get the referenced block file handle opening the file as needed. The
-	// function also handles closing files as needed to avoid going over the
-	// max allowed open files.
-	blockFile, err := s.blockFile(loc.blockFileNum)
-	if err != nil {
-		return nil, err
-	}
-
-	serializedData := make([]byte, loc.blockLen)
-	n, err := blockFile.file.ReadAt(serializedData, int64(loc.fileOffset))
-	blockFile.RUnlock()
-	if err != nil {
-		str := fmt.Sprintf("failed to read block %s from file %d, "+
-			"offset %d: %s", hash, loc.blockFileNum, loc.fileOffset,
-			err)
-		return nil, makeDbErr(database.ErrDriverSpecific, str, err)
-	}
-
-	// Calculate the checksum of the read data and ensure it matches the
-	// serialized checksum. This will detect any data corruption in the
-	// flat file without having to do much more expensive merkle root
-	// calculations on the loaded block.
-	serializedChecksum := binary.BigEndian.Uint32(serializedData[n-4:])
-	calculatedChecksum := crc32.Checksum(serializedData[:n-4], castagnoli)
-	if serializedChecksum != calculatedChecksum {
-		str := fmt.Sprintf("block data for block %s checksum "+
-			"does not match - got %x, want %x", hash,
-			calculatedChecksum, serializedChecksum)
-		return nil, makeDbErr(database.ErrCorruption, str, nil)
-	}
-
-	// The network associated with the block must match the current active
-	// network, otherwise somebody probably put the block files for the
-	// wrong network in the directory.
-	serializedNet := byteOrder.Uint32(serializedData[:4])
-	if serializedNet != uint32(s.network) {
-		str := fmt.Sprintf("block data for block %s is for the "+
-			"wrong network - got %d, want %d", hash, serializedNet,
-			uint32(s.network))
-		return nil, makeDbErr(database.ErrDriverSpecific, str, nil)
-	}
-
-	// The raw block excludes the network, length of the block, and
-	// checksum.
-	return serializedData[8 : n-4], nil
-}
-
-// readBlockRegion reads the specified amount of data at the provided offset for
-// a given block location. The offset is relative to the start of the
-// serialized block (as opposed to the beginning of the block record). This
-// function automatically handles all file management such as opening and
-// closing files as necessary to stay within the maximum allowed open files
-// limit.
-//
-// Returns ErrDriverSpecific if the data fails to read for any reason.
-func (s *blockStore) readBlockRegion(loc blockLocation, offset, numBytes uint32) ([]byte, error) {
-	// Get the referenced block file handle opening the file as needed. The
-	// function also handles closing files as needed to avoid going over the
-	// max allowed open files.
-	blockFile, err := s.blockFile(loc.blockFileNum)
-	if err != nil {
-		return nil, err
-	}
-
-	// Regions are offsets into the actual block, however the serialized
-	// data for a block includes an initial 4 bytes for network + 4 bytes
-	// for block length. Thus, add 8 bytes to adjust.
-	readOffset := loc.fileOffset + 8 + offset
-	serializedData := make([]byte, numBytes)
-	_, err = blockFile.file.ReadAt(serializedData, int64(readOffset))
-	blockFile.RUnlock()
-	if err != nil {
-		str := fmt.Sprintf("failed to read region from block file %d, "+
-			"offset %d, len %d: %s", loc.blockFileNum, readOffset,
-			numBytes, err)
-		return nil, makeDbErr(database.ErrDriverSpecific, str, err)
-	}
-
-	return serializedData, nil
-}
-
-// syncBlocks performs a file system sync on the flat file associated with the
-// store's current write cursor. It is safe to call even when there is not a
-// current write file in which case it will have no effect.
-//
-// This is used when flushing cached metadata updates to disk to ensure all the
-// block data is fully written before updating the metadata. This ensures the
-// metadata and block data can be properly reconciled in failure scenarios.
-func (s *blockStore) syncBlocks() error {
-	wc := s.writeCursor
-	wc.RLock()
-	defer wc.RUnlock()
-
-	// Nothing to do if there is no current file associated with the write
-	// cursor.
-	wc.curFile.RLock()
-	defer wc.curFile.RUnlock()
-	if wc.curFile.file == nil {
-		return nil
-	}
-
-	// Sync the file to disk.
-	if err := wc.curFile.file.Sync(); err != nil {
-		str := fmt.Sprintf("failed to sync file %d: %s", wc.curFileNum,
-			err)
-		return makeDbErr(database.ErrDriverSpecific, str, err)
-	}
-
-	return nil
-}
-
-// handleRollback rolls the block files on disk back to the provided file number
-// and offset. This involves potentially deleting and truncating the files that
-// were partially written.
-//
-// There are effectively two scenarios to consider here:
-//   1) Transient write failures from which recovery is possible
-//   2) More permanent failures such as hard disk death and/or removal
-//
-// In either case, the write cursor will be repositioned to the old block file
-// offset regardless of any other errors that occur while attempting to undo
-// writes.
-//
-// For the first scenario, this will lead to any data which failed to be undone
-// being overwritten and thus behaves as desired as the system continues to run.
-//
-// For the second scenario, the metadata which stores the current write cursor
-// position within the block files will not have been updated yet and thus if
-// the system eventually recovers (perhaps the hard drive is reconnected), it
-// will also lead to any data which failed to be undone being overwritten and
-// thus behaves as desired.
-//
-// Therefore, any errors are simply logged at a warning level rather than being
-// returned since there is nothing more that could be done about it anyways.
-func (s *blockStore) handleRollback(oldBlockFileNum, oldBlockOffset uint32) {
-	// Grab the write cursor mutex since it is modified throughout this
-	// function.
-	wc := s.writeCursor
-	wc.Lock()
-	defer wc.Unlock()
-
-	// Nothing to do if the rollback point is the same as the current write
-	// cursor.
-	if wc.curFileNum == oldBlockFileNum && wc.curOffset == oldBlockOffset {
-		return
-	}
-
-	// Regardless of any failures that happen below, reposition the write
-	// cursor to the old block file and offset.
-	defer func() {
-		wc.curFileNum = oldBlockFileNum
-		wc.curOffset = oldBlockOffset
-	}()
-
-	log.Debugf("ROLLBACK: Rolling back to file %d, offset %d",
-		oldBlockFileNum, oldBlockOffset)
-
-	// Close the current write file if it needs to be deleted. Then delete
-	// all files that are newer than the provided rollback file while
-	// also moving the write cursor file backwards accordingly.
-	if wc.curFileNum > oldBlockFileNum {
-		wc.curFile.Lock()
-		if wc.curFile.file != nil {
-			_ = wc.curFile.file.Close()
-			wc.curFile.file = nil
-		}
-		wc.curFile.Unlock()
-	}
-	for ; wc.curFileNum > oldBlockFileNum; wc.curFileNum-- {
-		if err := s.deleteFileFunc(wc.curFileNum); err != nil {
-			log.Warnf("ROLLBACK: Failed to delete block file "+
-				"number %d: %s", wc.curFileNum, err)
-			return
-		}
-	}
-
-	// Open the file for the current write cursor if needed.
-	wc.curFile.Lock()
-	if wc.curFile.file == nil {
-		obf, err := s.openWriteFileFunc(wc.curFileNum)
-		if err != nil {
-			wc.curFile.Unlock()
-			log.Warnf("ROLLBACK: %s", err)
-			return
-		}
-		wc.curFile.file = obf
-	}
-
-	// Truncate the to the provided rollback offset.
-	if err := wc.curFile.file.Truncate(int64(oldBlockOffset)); err != nil {
-		wc.curFile.Unlock()
-		log.Warnf("ROLLBACK: Failed to truncate file %d: %s",
-			wc.curFileNum, err)
-		return
-	}
-
-	// Sync the file to disk.
-	err := wc.curFile.file.Sync()
-	wc.curFile.Unlock()
-	if err != nil {
-		log.Warnf("ROLLBACK: Failed to sync file %d: %s",
-			wc.curFileNum, err)
-		return
-	}
-}
-
-// scanBlockFiles searches the database directory for all flat block files to
-// find the end of the most recent file. This position is considered the
-// current write cursor which is also stored in the metadata. Thus, it is used
-// to detect unexpected shutdowns in the middle of writes so the block files
-// can be reconciled.
-func scanBlockFiles(dbPath string) (int, uint32) {
-	lastFile := -1
-	fileLen := uint32(0)
-	for i := 0; ; i++ {
-		filePath := blockFilePath(dbPath, uint32(i))
-		st, err := os.Stat(filePath)
-		if err != nil {
-			break
-		}
-		lastFile = i
-
-		fileLen = uint32(st.Size())
-	}
-
-	log.Tracef("Scan found latest block file #%d with length %d", lastFile,
-		fileLen)
-	return lastFile, fileLen
-}
-
-// newBlockStore returns a new block store with the current block file number
-// and offset set and all fields initialized.
-func newBlockStore(basePath string, network wire.KaspaNet) *blockStore {
-	// Look for the end of the latest block to file to determine what the
-	// write cursor position is from the viewpoing of the block files on
-	// disk.
-	fileNum, fileOff := scanBlockFiles(basePath)
-	if fileNum == -1 {
-		fileNum = 0
-		fileOff = 0
-	}
-
-	store := &blockStore{
-		network:          network,
-		basePath:         basePath,
-		maxBlockFileSize: maxBlockFileSize,
-		maxOpenFiles:     maxOpenFiles,
-		openBlockFiles:   make(map[uint32]*lockableFile),
-		openBlocksLRU:    list.New(),
-		fileNumToLRUElem: make(map[uint32]*list.Element),
-
-		writeCursor: &writeCursor{
-			curFile:    &lockableFile{},
-			curFileNum: uint32(fileNum),
-			curOffset:  fileOff,
-		},
-	}
-	store.openFileFunc = store.openFile
-	store.openWriteFileFunc = store.openWriteFile
-	store.deleteFileFunc = store.deleteFile
-	return store
-}

database/ffldb/blockio_test.go

@@ -1,108 +0,0 @@
-package ffldb
-
-import (
-	"os"
-	"testing"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func TestDeleteFile(t *testing.T) {
-	testBlock := util.NewBlock(wire.NewMsgBlock(
-		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
-
-	tests := []struct {
-		fileNum     uint32
-		expectedErr bool
-	}{
-		{0, false},
-		{1, true},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestDeleteFile", t)
-			defer func() {
-				if !pdb.closed {
-					pdb.Close()
-				}
-			}()
-
-			err := pdb.Update(func(dbTx database.Tx) error {
-				dbTx.StoreBlock(testBlock)
-				return nil
-			})
-			if err != nil {
-				t.Fatalf("TestDeleteFile: Error storing block: %s", err)
-			}
-
-			err = pdb.Close()
-			if err != nil {
-				t.Fatalf("TestDeleteFile: Error closing file before deletion: %s", err)
-			}
-
-			err = pdb.store.deleteFile(test.fileNum)
-			if (err != nil) != test.expectedErr {
-				t.Errorf("TestDeleteFile: %d: Expected error status: %t, but got: %t",
-					test.fileNum, test.expectedErr, (err != nil))
-			}
-			if err == nil {
-				filePath := blockFilePath(pdb.store.basePath, test.fileNum)
-				if _, err := os.Stat(filePath); !os.IsNotExist(err) {
-					t.Errorf("TestDeleteFile: %d: File %s still exists", test.fileNum, filePath)
-				}
-			}
-		}()
-	}
-}
-
-// TestHandleRollbackErrors tests all error-cases in *blockStore.handleRollback().
-// The non-error-cases are tested in the more general tests.
-// Since handleRollback just logs errors, this test simply causes all error-cases to be hit,
-// and makes sure no panic occurs, as well as ensures the writeCursor was updated correctly.
-func TestHandleRollbackErrors(t *testing.T) {
-	testBlock := util.NewBlock(wire.NewMsgBlock(
-		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
-
-	testBlockSize := uint32(testBlock.MsgBlock().SerializeSize())
-	tests := []struct {
-		name    string
-		fileNum uint32
-		offset  uint32
-	}{
-		// offset should be size of block + 12 bytes for block network, size and checksum
-		{"Nothing to rollback", 1, testBlockSize + 12},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestHandleRollbackErrors", t)
-			defer pdb.Close()
-
-			// Set maxBlockFileSize to testBlockSize so that writeCursor.curFileNum increments
-			pdb.store.maxBlockFileSize = testBlockSize
-
-			err := pdb.Update(func(dbTx database.Tx) error {
-				return dbTx.StoreBlock(testBlock)
-			})
-			if err != nil {
-				t.Fatalf("TestHandleRollbackErrors: %s: Error adding test block to database: %s", test.name, err)
-			}
-
-			pdb.store.handleRollback(test.fileNum, test.offset)
-
-			if pdb.store.writeCursor.curFileNum != test.fileNum {
-				t.Errorf("TestHandleRollbackErrors: %s: Expected fileNum: %d, but got: %d",
-					test.name, test.fileNum, pdb.store.writeCursor.curFileNum)
-			}
-
-			if pdb.store.writeCursor.curOffset != test.offset {
-				t.Errorf("TestHandleRollbackErrors: %s: offset fileNum: %d, but got: %d",
-					test.name, test.offset, pdb.store.writeCursor.curOffset)
-			}
-		}()
-	}
-}

database/ffldb/common_test.go

@@ -1,43 +0,0 @@
-package ffldb
-
-import (
-	"os"
-	"path"
-	"path/filepath"
-	"testing"
-
-	"github.com/btcsuite/goleveldb/leveldb"
-	"github.com/btcsuite/goleveldb/leveldb/filter"
-	"github.com/btcsuite/goleveldb/leveldb/opt"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func newTestDb(testName string, t *testing.T) *db {
-	dbPath := path.Join(os.TempDir(), "db_test", testName)
-	err := os.RemoveAll(dbPath)
-	if err != nil && !os.IsNotExist(err) {
-		t.Fatalf("%s: Error deleting database folder before starting: %s", testName, err)
-	}
-
-	network := wire.Simnet
-
-	opts := opt.Options{
-		ErrorIfExist: true,
-		Strict:       opt.DefaultStrict,
-		Compression:  opt.NoCompression,
-		Filter:       filter.NewBloomFilter(10),
-	}
-	metadataDbPath := filepath.Join(dbPath, metadataDbName)
-	ldb, err := leveldb.OpenFile(metadataDbPath, &opts)
-	if err != nil {
-		t.Errorf("%s: Error opening metadataDbPath: %s", testName, err)
-	}
-	err = initDB(ldb)
-	if err != nil {
-		t.Errorf("%s: Error initializing metadata Db: %s", testName, err)
-	}
-
-	store := newBlockStore(dbPath, network)
-	cache := newDbCache(ldb, store, defaultCacheSize, defaultFlushSecs)
-	return &db{store: store, cache: cache}
-}

database/ffldb/db_test.go

@@ -1,658 +0,0 @@
-package ffldb
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/pkg/errors"
-
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// TestCursorDeleteErrors tests all error-cases in *cursor.Delete().
-// The non-error-cases are tested in the more general tests.
-func TestCursorDeleteErrors(t *testing.T) {
-	pdb := newTestDb("TestCursorDeleteErrors", t)
-
-	nestedBucket := []byte("nestedBucket")
-	key := []byte("key")
-	value := []byte("value")
-
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		_, err := metadata.CreateBucket(nestedBucket)
-		if err != nil {
-			return err
-		}
-		metadata.Put(key, value)
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Error setting up test-database: %s", err)
-	}
-
-	// Check for error when attempted to delete a bucket
-	err = pdb.Update(func(dbTx database.Tx) error {
-		cursor := dbTx.Metadata().Cursor()
-		found := false
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-			if bytes.Equal(cursor.Key(), nestedBucket) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Errorf("TestCursorDeleteErrors: Key '%s' not found", string(nestedBucket))
-		}
-
-		err := cursor.Delete()
-		if !database.IsErrorCode(err, database.ErrIncompatibleValue) {
-			t.Errorf("TestCursorDeleteErrors: Expected error of type ErrIncompatibleValue, "+
-				"when deleting bucket, but got %v", err)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Unexpected error from pdb.Update "+
-			"when attempting to delete bucket: %s", err)
-	}
-
-	// Check for error when transaction is not writable
-	err = pdb.View(func(dbTx database.Tx) error {
-		cursor := dbTx.Metadata().Cursor()
-		if !cursor.First() {
-			t.Fatal("TestCursorDeleteErrors: Nothing in cursor when testing for delete in " +
-				"non-writable transaction")
-		}
-
-		err := cursor.Delete()
-		if !database.IsErrorCode(err, database.ErrTxNotWritable) {
-			t.Errorf("TestCursorDeleteErrors: Expected error of type ErrTxNotWritable "+
-				"when calling .Delete() on non-writable transaction, but got '%v' instead", err)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Unexpected error from pdb.Update "+
-			"when attempting to delete on non-writable transaction: %s", err)
-	}
-
-	// Check for error when cursor was exhausted
-	err = pdb.Update(func(dbTx database.Tx) error {
-		cursor := dbTx.Metadata().Cursor()
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-		}
-
-		err := cursor.Delete()
-		if !database.IsErrorCode(err, database.ErrIncompatibleValue) {
-			t.Errorf("TestCursorDeleteErrors: Expected error of type ErrIncompatibleValue "+
-				"when calling .Delete() on exhausted cursor, but got '%v' instead", err)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Unexpected error from pdb.Update "+
-			"when attempting to delete on exhausted cursor: %s", err)
-	}
-
-	// Check for error when transaction is closed
-	tx, err := pdb.Begin(true)
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Error in pdb.Begin(): %s", err)
-	}
-	cursor := tx.Metadata().Cursor()
-	err = tx.Commit()
-	if err != nil {
-		t.Fatalf("TestCursorDeleteErrors: Error in tx.Commit(): %s", err)
-	}
-
-	err = cursor.Delete()
-	if !database.IsErrorCode(err, database.ErrTxClosed) {
-		t.Errorf("TestCursorDeleteErrors: Expected error of type ErrTxClosed "+
-			"when calling .Delete() on with closed transaction, but got '%s' instead", err)
-	}
-}
-
-func TestSkipPendingUpdates(t *testing.T) {
-	pdb := newTestDb("TestSkipPendingUpdates", t)
-	defer pdb.Close()
-
-	value := []byte("value")
-	// Add numbered prefixes to keys so that they are in expected order, and before any other keys
-	firstKey := []byte("1 - first")
-	toDeleteKey := []byte("2 - toDelete")
-	toUpdateKey := []byte("3 - toUpdate")
-	secondKey := []byte("4 - second")
-
-	// create initial metadata for test
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		if err := metadata.Put(firstKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toDeleteKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toUpdateKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(secondKey, value); err != nil {
-			return err
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestSkipPendingUpdates: Error adding to metadata: %s", err)
-	}
-
-	// test skips
-	err = pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		if err := metadata.Delete(toDeleteKey); err != nil {
-			return err
-		}
-		if err := metadata.Put(toUpdateKey, value); err != nil {
-			return err
-		}
-		cursor := metadata.Cursor().(*cursor)
-		dbIter := cursor.dbIter
-
-		// Check that first is ok
-		dbIter.First()
-		expectedKey := bucketizedKey(metadataBucketID, firstKey)
-		if !bytes.Equal(dbIter.Key(), expectedKey) {
-			t.Errorf("TestSkipPendingUpdates: 1: key expected to be %v but is %v", expectedKey, dbIter.Key())
-		}
-
-		// Go to the next key, which is toDelete
-		dbIter.Next()
-		expectedKey = bucketizedKey(metadataBucketID, toDeleteKey)
-		if !bytes.Equal(dbIter.Key(), expectedKey) {
-			t.Errorf("TestSkipPendingUpdates: 2: key expected to be %s but is %s", expectedKey, dbIter.Key())
-		}
-
-		// at this point toDeleteKey and toUpdateKey should be skipped
-		cursor.skipPendingUpdates(true)
-		expectedKey = bucketizedKey(metadataBucketID, secondKey)
-		if !bytes.Equal(dbIter.Key(), expectedKey) {
-			t.Errorf("TestSkipPendingUpdates: 3: key expected to be %s but is %s", expectedKey, dbIter.Key())
-		}
-
-		// now traverse backwards - should get toUpdate
-		dbIter.Prev()
-		expectedKey = bucketizedKey(metadataBucketID, toUpdateKey)
-		if !bytes.Equal(dbIter.Key(), expectedKey) {
-			t.Errorf("TestSkipPendingUpdates: 4: key expected to be %s but is %s", expectedKey, dbIter.Key())
-		}
-
-		// at this point toUpdateKey and toDeleteKey should be skipped
-		cursor.skipPendingUpdates(false)
-		expectedKey = bucketizedKey(metadataBucketID, firstKey)
-		if !bytes.Equal(dbIter.Key(), expectedKey) {
-			t.Errorf("TestSkipPendingUpdates: 5: key expected to be %s but is %s", expectedKey, dbIter.Key())
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestSkipPendingUpdates: Error running main part of test: %s", err)
-	}
-}
-
-// TestCursor tests various edge-cases in cursor that were not hit by the more general tests
-func TestCursor(t *testing.T) {
-	pdb := newTestDb("TestCursor", t)
-	defer pdb.Close()
-
-	value := []byte("value")
-	// Add numbered prefixes to keys so that they are in expected order, and before any other keys
-	firstKey := []byte("1 - first")
-	toDeleteKey := []byte("2 - toDelete")
-	toUpdateKey := []byte("3 - toUpdate")
-	secondKey := []byte("4 - second")
-
-	// create initial metadata for test
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		if err := metadata.Put(firstKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toDeleteKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toUpdateKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(secondKey, value); err != nil {
-			return err
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Error adding to metadata: %s", err)
-	}
-
-	// run the actual tests
-	err = pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		if err := metadata.Delete(toDeleteKey); err != nil {
-			return err
-		}
-		if err := metadata.Put(toUpdateKey, value); err != nil {
-			return err
-		}
-		cursor := metadata.Cursor().(*cursor)
-
-		// Check prev when currentIter == nil
-		if ok := cursor.Prev(); ok {
-			t.Error("1: .Prev() should have returned false, but have returned true")
-		}
-		// Same thing for .Next()
-		for ok := cursor.First(); ok; ok = cursor.Next() {
-		}
-		if ok := cursor.Next(); ok {
-			t.Error("2: .Next() should have returned false, but have returned true")
-		}
-
-		// Check that Key(), rawKey(), Value(), and rawValue() all return nil when currentIter == nil
-		if key := cursor.Key(); key != nil {
-			t.Errorf("3: .Key() should have returned nil, but have returned '%s' instead", key)
-		}
-		if key := cursor.rawKey(); key != nil {
-			t.Errorf("4: .rawKey() should have returned nil, but have returned '%s' instead", key)
-		}
-		if value := cursor.Value(); value != nil {
-			t.Errorf("5: .Value() should have returned nil, but have returned '%s' instead", value)
-		}
-		if value := cursor.rawValue(); value != nil {
-			t.Errorf("6: .rawValue() should have returned nil, but have returned '%s' instead", value)
-		}
-
-		// Check rawValue in normal operation
-		cursor.First()
-		if rawValue := cursor.rawValue(); !bytes.Equal(rawValue, value) {
-			t.Errorf("7: rawValue should have returned '%s' but have returned '%s' instead", value, rawValue)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Error running the actual tests: %s", err)
-	}
-}
-
-// TestCreateBucketErrors tests all error-cases in *bucket.CreateBucket().
-// The non-error-cases are tested in the more general tests.
-func TestCreateBucketErrors(t *testing.T) {
-	testKey := []byte("key")
-
-	tests := []struct {
-		name        string
-		key         []byte
-		isWritable  bool
-		isClosed    bool
-		expectedErr database.ErrorCode
-	}{
-		{"empty key", []byte{}, true, false, database.ErrBucketNameRequired},
-		{"transaction is closed", testKey, true, true, database.ErrTxClosed},
-		{"transaction is not writable", testKey, false, false, database.ErrTxNotWritable},
-		{"key already exists", blockIdxBucketName, true, false, database.ErrBucketExists},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestCreateBucketErrors", t)
-			defer pdb.Close()
-
-			tx, err := pdb.Begin(test.isWritable)
-			defer tx.Commit()
-			if err != nil {
-				t.Fatalf("TestCreateBucketErrors: %s: error from pdb.Begin: %s", test.name, err)
-			}
-			if test.isClosed {
-				err = tx.Commit()
-				if err != nil {
-					t.Fatalf("TestCreateBucketErrors: %s: error from tx.Commit: %s", test.name, err)
-				}
-			}
-
-			metadata := tx.Metadata()
-
-			_, err = metadata.CreateBucket(test.key)
-
-			if !database.IsErrorCode(err, test.expectedErr) {
-				t.Errorf("TestCreateBucketErrors: %s: Expected error of type %d "+
-					"but got '%v'", test.name, test.expectedErr, err)
-			}
-
-		}()
-	}
-}
-
-// TestPutErrors tests all error-cases in *bucket.Put().
-// The non-error-cases are tested in the more general tests.
-func TestPutErrors(t *testing.T) {
-	testKey := []byte("key")
-	testValue := []byte("value")
-
-	tests := []struct {
-		name        string
-		key         []byte
-		isWritable  bool
-		isClosed    bool
-		expectedErr database.ErrorCode
-	}{
-		{"empty key", []byte{}, true, false, database.ErrKeyRequired},
-		{"transaction is closed", testKey, true, true, database.ErrTxClosed},
-		{"transaction is not writable", testKey, false, false, database.ErrTxNotWritable},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestPutErrors", t)
-			defer pdb.Close()
-
-			tx, err := pdb.Begin(test.isWritable)
-			defer tx.Commit()
-			if err != nil {
-				t.Fatalf("TestPutErrors: %s: error from pdb.Begin: %s", test.name, err)
-			}
-			if test.isClosed {
-				err = tx.Commit()
-				if err != nil {
-					t.Fatalf("TestPutErrors: %s: error from tx.Commit: %s", test.name, err)
-				}
-			}
-
-			metadata := tx.Metadata()
-
-			err = metadata.Put(test.key, testValue)
-
-			if !database.IsErrorCode(err, test.expectedErr) {
-				t.Errorf("TestPutErrors: %s: Expected error of type %d "+
-					"but got '%v'", test.name, test.expectedErr, err)
-			}
-
-		}()
-	}
-}
-
-// TestGetErrors tests all error-cases in *bucket.Get().
-// The non-error-cases are tested in the more general tests.
-func TestGetErrors(t *testing.T) {
-	testKey := []byte("key")
-
-	tests := []struct {
-		name     string
-		key      []byte
-		isClosed bool
-	}{
-		{"empty key", []byte{}, false},
-		{"transaction is closed", testKey, true},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestGetErrors", t)
-			defer pdb.Close()
-
-			tx, err := pdb.Begin(false)
-			defer tx.Rollback()
-			if err != nil {
-				t.Fatalf("TestGetErrors: %s: error from pdb.Begin: %s", test.name, err)
-			}
-			if test.isClosed {
-				err = tx.Rollback()
-				if err != nil {
-					t.Fatalf("TestGetErrors: %s: error from tx.Commit: %s", test.name, err)
-				}
-			}
-
-			metadata := tx.Metadata()
-
-			if result := metadata.Get(test.key); result != nil {
-				t.Errorf("TestGetErrors: %s: Expected to return nil, but got %v", test.name, result)
-			}
-		}()
-	}
-}
-
-// TestDeleteErrors tests all error-cases in *bucket.Delete().
-// The non-error-cases are tested in the more general tests.
-func TestDeleteErrors(t *testing.T) {
-	testKey := []byte("key")
-
-	tests := []struct {
-		name        string
-		key         []byte
-		isWritable  bool
-		isClosed    bool
-		expectedErr database.ErrorCode
-	}{
-		{"empty key", []byte{}, true, false, database.ErrKeyRequired},
-		{"transaction is closed", testKey, true, true, database.ErrTxClosed},
-		{"transaction is not writable", testKey, false, false, database.ErrTxNotWritable},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestDeleteErrors", t)
-			defer pdb.Close()
-
-			tx, err := pdb.Begin(test.isWritable)
-			defer tx.Commit()
-			if err != nil {
-				t.Fatalf("TestDeleteErrors: %s: error from pdb.Begin: %s", test.name, err)
-			}
-			if test.isClosed {
-				err = tx.Commit()
-				if err != nil {
-					t.Fatalf("TestDeleteErrors: %s: error from tx.Commit: %s", test.name, err)
-				}
-			}
-
-			metadata := tx.Metadata()
-
-			err = metadata.Delete(test.key)
-
-			if !database.IsErrorCode(err, test.expectedErr) {
-				t.Errorf("TestDeleteErrors: %s: Expected error of type %d "+
-					"but got '%v'", test.name, test.expectedErr, err)
-			}
-		}()
-	}
-}
-
-func TestForEachBucket(t *testing.T) {
-	pdb := newTestDb("TestForEachBucket", t)
-
-	// set-up test
-	testKey := []byte("key")
-	testValue := []byte("value")
-	bucketKeys := [][]byte{{1}, {2}, {3}}
-
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		for _, bucketKey := range bucketKeys {
-			bucket, err := metadata.CreateBucket(bucketKey)
-			if err != nil {
-				return err
-			}
-
-			err = bucket.Put(testKey, testValue)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestForEachBucket: Error setting up test-database: %s", err)
-	}
-
-	// actual test
-	err = pdb.View(func(dbTx database.Tx) error {
-		i := 0
-		metadata := dbTx.Metadata()
-
-		err := metadata.ForEachBucket(func(bucketKey []byte) error {
-			if i >= len(bucketKeys) { // in case there are any other buckets in metadata
-				return nil
-			}
-
-			expectedBucketKey := bucketKeys[i]
-			if !bytes.Equal(expectedBucketKey, bucketKey) {
-				t.Errorf("TestForEachBucket: %d: Expected bucket key: %v, but got: %v",
-					i, expectedBucketKey, bucketKey)
-				return nil
-			}
-			bucket := metadata.Bucket(bucketKey)
-			if bucket == nil {
-				t.Errorf("TestForEachBucket: %d: Bucket is nil", i)
-				return nil
-			}
-
-			value := bucket.Get(testKey)
-			if !bytes.Equal(testValue, value) {
-				t.Errorf("TestForEachBucket: %d: Expected value: %s, but got: %s",
-					i, testValue, value)
-				return nil
-			}
-
-			i++
-			return nil
-		})
-
-		return err
-	})
-	if err != nil {
-		t.Fatalf("TestForEachBucket: Error running actual tests: %s", err)
-	}
-}
-
-// TestStoreBlockErrors tests all error-cases in *tx.StoreBlock().
-// The non-error-cases are tested in the more general tests.
-func TestStoreBlockErrors(t *testing.T) {
-	testBlock := util.NewBlock(wire.NewMsgBlock(wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
-
-	tests := []struct {
-		name        string
-		isWritable  bool
-		isClosed    bool
-		expectedErr database.ErrorCode
-	}{
-		{"transaction is closed", true, true, database.ErrTxClosed},
-		{"transaction is not writable", false, false, database.ErrTxNotWritable},
-	}
-
-	for _, test := range tests {
-		func() {
-			pdb := newTestDb("TestStoreBlockErrors", t)
-			defer pdb.Close()
-
-			tx, err := pdb.Begin(test.isWritable)
-			defer tx.Commit()
-			if err != nil {
-				t.Fatalf("TestStoreBlockErrors: %s: error from pdb.Begin: %s", test.name, err)
-			}
-			if test.isClosed {
-				err = tx.Commit()
-				if err != nil {
-					t.Fatalf("TestStoreBlockErrors: %s: error from tx.Commit: %s", test.name, err)
-				}
-			}
-
-			err = tx.StoreBlock(testBlock)
-			if !database.IsErrorCode(err, test.expectedErr) {
-				t.Errorf("TestStoreBlockErrors: %s: Expected error of type %d "+
-					"but got '%v'", test.name, test.expectedErr, err)
-			}
-
-		}()
-	}
-}
-
-// TestDeleteDoubleNestedBucket tests what happens when bucket.DeleteBucket()
-// is invoked on a bucket that contains a nested bucket.
-func TestDeleteDoubleNestedBucket(t *testing.T) {
-	pdb := newTestDb("TestDeleteDoubleNestedBucket", t)
-	defer pdb.Close()
-
-	firstKey := []byte("first")
-	secondKey := []byte("second")
-	key := []byte("key")
-	value := []byte("value")
-	var rawKey, rawSecondKey []byte
-
-	// Test setup
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		firstBucket, err := metadata.CreateBucket(firstKey)
-		if err != nil {
-			return errors.Errorf("Error creating first bucket: %s", err)
-		}
-		secondBucket, err := firstBucket.CreateBucket(secondKey)
-		if err != nil {
-			return errors.Errorf("Error creating second bucket: %s", err)
-		}
-		secondBucket.Put(key, value)
-
-		// extract rawKey from cursor and make sure it's in raw database
-		c := secondBucket.Cursor()
-		for ok := c.First(); ok && !bytes.Equal(c.Key(), key); ok = c.Next() {
-		}
-		if !bytes.Equal(c.Key(), key) {
-			return errors.Errorf("Couldn't find key to extract rawKey")
-		}
-		rawKey = c.(*cursor).rawKey()
-		if dbTx.(*transaction).fetchKey(rawKey) == nil {
-			return errors.Errorf("rawKey not found")
-		}
-
-		// extract rawSecondKey from cursor and make sure it's in raw database
-		c = firstBucket.Cursor()
-		for ok := c.First(); ok && !bytes.Equal(c.Key(), secondKey); ok = c.Next() {
-		}
-		if !bytes.Equal(c.Key(), secondKey) {
-			return errors.Errorf("Couldn't find secondKey to extract rawSecondKey")
-		}
-		rawSecondKey = c.(*cursor).rawKey()
-		if dbTx.(*transaction).fetchKey(rawSecondKey) == nil {
-			return errors.Errorf("rawSecondKey not found for some reason")
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestDeleteDoubleNestedBucket: Error in test setup pdb.Update: %s", err)
-	}
-
-	// Actual test
-	err = pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		err := metadata.DeleteBucket(firstKey)
-		if err != nil {
-			return err
-		}
-
-		if dbTx.(*transaction).fetchKey(rawSecondKey) != nil {
-			t.Error("TestDeleteDoubleNestedBucket: secondBucket was not deleted")
-		}
-
-		if dbTx.(*transaction).fetchKey(rawKey) != nil {
-			t.Error("TestDeleteDoubleNestedBucket: value inside secondBucket was not deleted")
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestDeleteDoubleNestedBucket: Error in actual test pdb.Update: %s", err)
-	}
-}

database/ffldb/dbcache.go

@@ -1,660 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package ffldb
-
-import (
-	"bytes"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/btcsuite/goleveldb/leveldb"
-	"github.com/btcsuite/goleveldb/leveldb/iterator"
-	"github.com/btcsuite/goleveldb/leveldb/util"
-	"github.com/kaspanet/kaspad/database/internal/treap"
-)
-
-const (
-	// defaultCacheSize is the default size for the database cache.
-	defaultCacheSize = 100 * 1024 * 1024 // 100 MB
-
-	// defaultFlushSecs is the default number of seconds to use as a
-	// threshold in between database cache flushes when the cache size has
-	// not been exceeded.
-	defaultFlushSecs = 300 // 5 minutes
-
-	// ldbBatchHeaderSize is the size of a leveldb batch header which
-	// includes the sequence header and record counter.
-	//
-	// ldbRecordIKeySize is the size of the ikey used internally by leveldb
-	// when appending a record to a batch.
-	//
-	// These are used to help preallocate space needed for a batch in one
-	// allocation instead of letting leveldb itself constantly grow it.
-	// This results in far less pressure on the GC and consequently helps
-	// prevent the GC from allocating a lot of extra unneeded space.
-	ldbBatchHeaderSize = 12
-	ldbRecordIKeySize  = 8
-)
-
-// ldbCacheIter wraps a treap iterator to provide the additional functionality
-// needed to satisfy the leveldb iterator.Iterator interface.
-type ldbCacheIter struct {
-	*treap.Iterator
-}
-
-// Enforce ldbCacheIterator implements the leveldb iterator.Iterator interface.
-var _ iterator.Iterator = (*ldbCacheIter)(nil)
-
-// Error is only provided to satisfy the iterator interface as there are no
-// errors for this memory-only structure.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *ldbCacheIter) Error() error {
-	return nil
-}
-
-// SetReleaser is only provided to satisfy the iterator interface as there is no
-// need to override it.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *ldbCacheIter) SetReleaser(releaser util.Releaser) {
-}
-
-// Release is only provided to satisfy the iterator interface.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *ldbCacheIter) Release() {
-}
-
-// newLdbCacheIter creates a new treap iterator for the given slice against the
-// pending keys for the passed cache snapshot and returns it wrapped in an
-// ldbCacheIter so it can be used as a leveldb iterator.
-func newLdbCacheIter(snap *dbCacheSnapshot, slice *util.Range) *ldbCacheIter {
-	iter := snap.pendingKeys.Iterator(slice.Start, slice.Limit)
-	return &ldbCacheIter{Iterator: iter}
-}
-
-// dbCacheIterator defines an iterator over the key/value pairs in the database
-// cache and underlying database.
-type dbCacheIterator struct {
-	cacheSnapshot *dbCacheSnapshot
-	dbIter        iterator.Iterator
-	cacheIter     iterator.Iterator
-	currentIter   iterator.Iterator
-	released      bool
-}
-
-// Enforce dbCacheIterator implements the leveldb iterator.Iterator interface.
-var _ iterator.Iterator = (*dbCacheIterator)(nil)
-
-// skipPendingUpdates skips any keys at the current database iterator position
-// that are being updated by the cache. The forwards flag indicates the
-// direction the iterator is moving.
-func (iter *dbCacheIterator) skipPendingUpdates(forwards bool) {
-	for iter.dbIter.Valid() {
-		var skip bool
-		key := iter.dbIter.Key()
-		if iter.cacheSnapshot.pendingRemove.Has(key) {
-			skip = true
-		} else if iter.cacheSnapshot.pendingKeys.Has(key) {
-			skip = true
-		}
-		if !skip {
-			break
-		}
-
-		if forwards {
-			iter.dbIter.Next()
-		} else {
-			iter.dbIter.Prev()
-		}
-	}
-}
-
-// chooseIterator first skips any entries in the database iterator that are
-// being updated by the cache and sets the current iterator to the appropriate
-// iterator depending on their validity and the order they compare in while taking
-// into account the direction flag. When the iterator is being moved forwards
-// and both iterators are valid, the iterator with the smaller key is chosen and
-// vice versa when the iterator is being moved backwards.
-func (iter *dbCacheIterator) chooseIterator(forwards bool) bool {
-	// Skip any keys at the current database iterator position that are
-	// being updated by the cache.
-	iter.skipPendingUpdates(forwards)
-
-	// When both iterators are exhausted, the iterator is exhausted too.
-	if !iter.dbIter.Valid() && !iter.cacheIter.Valid() {
-		iter.currentIter = nil
-		return false
-	}
-
-	// Choose the database iterator when the cache iterator is exhausted.
-	if !iter.cacheIter.Valid() {
-		iter.currentIter = iter.dbIter
-		return true
-	}
-
-	// Choose the cache iterator when the database iterator is exhausted.
-	if !iter.dbIter.Valid() {
-		iter.currentIter = iter.cacheIter
-		return true
-	}
-
-	// Both iterators are valid, so choose the iterator with either the
-	// smaller or larger key depending on the forwards flag.
-	compare := bytes.Compare(iter.dbIter.Key(), iter.cacheIter.Key())
-	if (forwards && compare > 0) || (!forwards && compare < 0) {
-		iter.currentIter = iter.cacheIter
-	} else {
-		iter.currentIter = iter.dbIter
-	}
-	return true
-}
-
-// First positions the iterator at the first key/value pair and returns whether
-// or not the pair exists.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) First() bool {
-	// Seek to the first key in both the database and cache iterators and
-	// choose the iterator that is both valid and has the smaller key.
-	iter.dbIter.First()
-	iter.cacheIter.First()
-	return iter.chooseIterator(true)
-}
-
-// Last positions the iterator at the last key/value pair and returns whether or
-// not the pair exists.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Last() bool {
-	// Seek to the last key in both the database and cache iterators and
-	// choose the iterator that is both valid and has the larger key.
-	iter.dbIter.Last()
-	iter.cacheIter.Last()
-	return iter.chooseIterator(false)
-}
-
-// Next moves the iterator one key/value pair forward and returns whether or not
-// the pair exists.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Next() bool {
-	// Nothing to return if cursor is exhausted.
-	if iter.currentIter == nil {
-		return false
-	}
-
-	// Move the current iterator to the next entry and choose the iterator
-	// that is both valid and has the smaller key.
-	iter.currentIter.Next()
-	return iter.chooseIterator(true)
-}
-
-// Prev moves the iterator one key/value pair backward and returns whether or
-// not the pair exists.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Prev() bool {
-	// Nothing to return if cursor is exhausted.
-	if iter.currentIter == nil {
-		return false
-	}
-
-	// Move the current iterator to the previous entry and choose the
-	// iterator that is both valid and has the larger key.
-	iter.currentIter.Prev()
-	return iter.chooseIterator(false)
-}
-
-// Seek positions the iterator at the first key/value pair that is greater than
-// or equal to the passed seek key. Returns false if no suitable key was found.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Seek(key []byte) bool {
-	// Seek to the provided key in both the database and cache iterators
-	// then choose the iterator that is both valid and has the larger key.
-	iter.dbIter.Seek(key)
-	iter.cacheIter.Seek(key)
-	return iter.chooseIterator(true)
-}
-
-// Valid indicates whether the iterator is positioned at a valid key/value pair.
-// It will be considered invalid when the iterator is newly created or exhausted.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Valid() bool {
-	return iter.currentIter != nil
-}
-
-// Key returns the current key the iterator is pointing to.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Key() []byte {
-	// Nothing to return if iterator is exhausted.
-	if iter.currentIter == nil {
-		return nil
-	}
-
-	return iter.currentIter.Key()
-}
-
-// Value returns the current value the iterator is pointing to.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Value() []byte {
-	// Nothing to return if iterator is exhausted.
-	if iter.currentIter == nil {
-		return nil
-	}
-
-	return iter.currentIter.Value()
-}
-
-// SetReleaser is only provided to satisfy the iterator interface as there is no
-// need to override it.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) SetReleaser(releaser util.Releaser) {
-}
-
-// Release releases the iterator by removing the underlying treap iterator from
-// the list of active iterators against the pending keys treap.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Release() {
-	if !iter.released {
-		iter.dbIter.Release()
-		iter.cacheIter.Release()
-		iter.currentIter = nil
-		iter.released = true
-	}
-}
-
-// Error is only provided to satisfy the iterator interface as there are no
-// errors for this memory-only structure.
-//
-// This is part of the leveldb iterator.Iterator interface implementation.
-func (iter *dbCacheIterator) Error() error {
-	return nil
-}
-
-// dbCacheSnapshot defines a snapshot of the database cache and underlying
-// database at a particular point in time.
-type dbCacheSnapshot struct {
-	dbSnapshot    *leveldb.Snapshot
-	pendingKeys   *treap.Immutable
-	pendingRemove *treap.Immutable
-}
-
-// Has returns whether or not the passed key exists.
-func (snap *dbCacheSnapshot) Has(key []byte) bool {
-	// Check the cached entries first.
-	if snap.pendingRemove.Has(key) {
-		return false
-	}
-	if snap.pendingKeys.Has(key) {
-		return true
-	}
-
-	// Consult the database.
-	hasKey, _ := snap.dbSnapshot.Has(key, nil)
-	return hasKey
-}
-
-// Get returns the value for the passed key. The function will return nil when
-// the key does not exist.
-func (snap *dbCacheSnapshot) Get(key []byte) []byte {
-	// Check the cached entries first.
-	if snap.pendingRemove.Has(key) {
-		return nil
-	}
-	if value := snap.pendingKeys.Get(key); value != nil {
-		return value
-	}
-
-	// Consult the database.
-	value, err := snap.dbSnapshot.Get(key, nil)
-	if err != nil {
-		return nil
-	}
-	return value
-}
-
-// Release releases the snapshot.
-func (snap *dbCacheSnapshot) Release() {
-	snap.dbSnapshot.Release()
-	snap.pendingKeys = nil
-	snap.pendingRemove = nil
-}
-
-// NewIterator returns a new iterator for the snapshot. The newly returned
-// iterator is not pointing to a valid item until a call to one of the methods
-// to position it is made.
-//
-// The slice parameter allows the iterator to be limited to a range of keys.
-// The start key is inclusive and the limit key is exclusive. Either or both
-// can be nil if the functionality is not desired.
-func (snap *dbCacheSnapshot) NewIterator(slice *util.Range) *dbCacheIterator {
-	return &dbCacheIterator{
-		dbIter:        snap.dbSnapshot.NewIterator(slice, nil),
-		cacheIter:     newLdbCacheIter(snap, slice),
-		cacheSnapshot: snap,
-	}
-}
-
-// dbCache provides a database cache layer backed by an underlying database. It
-// allows a maximum cache size and flush interval to be specified such that the
-// cache is flushed to the database when the cache size exceeds the maximum
-// configured value or it has been longer than the configured interval since the
-// last flush. This effectively provides transaction batching so that callers
-// can commit transactions at will without incurring large performance hits due
-// to frequent disk syncs.
-type dbCache struct {
-	// ldb is the underlying leveldb DB for metadata.
-	ldb *leveldb.DB
-
-	// store is used to sync blocks to flat files.
-	store *blockStore
-
-	// The following fields are related to flushing the cache to persistent
-	// storage. Note that all flushing is performed in an opportunistic
-	// fashion. This means that it is only flushed during a transaction or
-	// when the database cache is closed.
-	//
-	// maxSize is the maximum size threshold the cache can grow to before
-	// it is flushed.
-	//
-	// flushInterval is the threshold interval of time that is allowed to
-	// pass before the cache is flushed.
-	//
-	// lastFlush is the time the cache was last flushed. It is used in
-	// conjunction with the current time and the flush interval.
-	//
-	// NOTE: These flush related fields are protected by the database write
-	// lock.
-	maxSize       uint64
-	flushInterval time.Duration
-	lastFlush     time.Time
-
-	// The following fields hold the keys that need to be stored or deleted
-	// from the underlying database once the cache is full, enough time has
-	// passed, or when the database is shutting down. Note that these are
-	// stored using immutable treaps to support O(1) MVCC snapshots against
-	// the cached data. The cacheLock is used to protect concurrent access
-	// for cache updates and snapshots.
-	cacheLock    sync.RWMutex
-	cachedKeys   *treap.Immutable
-	cachedRemove *treap.Immutable
-}
-
-// Snapshot returns a snapshot of the database cache and underlying database at
-// a particular point in time.
-//
-// The snapshot must be released after use by calling Release.
-func (c *dbCache) Snapshot() (*dbCacheSnapshot, error) {
-	dbSnapshot, err := c.ldb.GetSnapshot()
-	if err != nil {
-		str := "failed to open transaction"
-		return nil, convertErr(str, err)
-	}
-
-	// Since the cached keys to be added and removed use an immutable treap,
-	// a snapshot is simply obtaining the root of the tree under the lock
-	// which is used to atomically swap the root.
-	c.cacheLock.RLock()
-	cacheSnapshot := &dbCacheSnapshot{
-		dbSnapshot:    dbSnapshot,
-		pendingKeys:   c.cachedKeys,
-		pendingRemove: c.cachedRemove,
-	}
-	c.cacheLock.RUnlock()
-	return cacheSnapshot, nil
-}
-
-// updateDB invokes the passed function in the context of a managed leveldb
-// transaction. Any errors returned from the user-supplied function will cause
-// the transaction to be rolled back and are returned from this function.
-// Otherwise, the transaction is committed when the user-supplied function
-// returns a nil error.
-func (c *dbCache) updateDB(fn func(ldbTx *leveldb.Transaction) error) error {
-	// Start a leveldb transaction.
-	ldbTx, err := c.ldb.OpenTransaction()
-	if err != nil {
-		return convertErr("failed to open ldb transaction", err)
-	}
-
-	if err := fn(ldbTx); err != nil {
-		ldbTx.Discard()
-		return err
-	}
-
-	// Commit the leveldb transaction and convert any errors as needed.
-	if err := ldbTx.Commit(); err != nil {
-		return convertErr("failed to commit leveldb transaction", err)
-	}
-	return nil
-}
-
-// TreapForEacher is an interface which allows iteration of a treap in ascending
-// order using a user-supplied callback for each key/value pair. It mainly
-// exists so both mutable and immutable treaps can be atomically committed to
-// the database with the same function.
-type TreapForEacher interface {
-	ForEach(func(k, v []byte) bool)
-}
-
-// commitTreaps atomically commits all of the passed pending add/update/remove
-// updates to the underlying database.
-func (c *dbCache) commitTreaps(pendingKeys, pendingRemove TreapForEacher) error {
-	// Perform all leveldb updates using an atomic transaction.
-	return c.updateDB(func(ldbTx *leveldb.Transaction) error {
-		var innerErr error
-		pendingKeys.ForEach(func(k, v []byte) bool {
-			if dbErr := ldbTx.Put(k, v, nil); dbErr != nil {
-				str := fmt.Sprintf("failed to put key %q to "+
-					"ldb transaction", k)
-				innerErr = convertErr(str, dbErr)
-				return false
-			}
-			return true
-		})
-		if innerErr != nil {
-			return innerErr
-		}
-
-		pendingRemove.ForEach(func(k, v []byte) bool {
-			if dbErr := ldbTx.Delete(k, nil); dbErr != nil {
-				str := fmt.Sprintf("failed to delete "+
-					"key %q from ldb transaction",
-					k)
-				innerErr = convertErr(str, dbErr)
-				return false
-			}
-			return true
-		})
-		return innerErr
-	})
-}
-
-// flush flushes the database cache to persistent storage. This involes syncing
-// the block store and replaying all transactions that have been applied to the
-// cache to the underlying database.
-//
-// This function MUST be called with the database write lock held.
-func (c *dbCache) flush() error {
-	c.lastFlush = time.Now()
-
-	// Sync the current write file associated with the block store. This is
-	// necessary before writing the metadata to prevent the case where the
-	// metadata contains information about a block which actually hasn't
-	// been written yet in unexpected shutdown scenarios.
-	if err := c.store.syncBlocks(); err != nil {
-		return err
-	}
-
-	// Since the cached keys to be added and removed use an immutable treap,
-	// a snapshot is simply obtaining the root of the tree under the lock
-	// which is used to atomically swap the root.
-	c.cacheLock.RLock()
-	cachedKeys := c.cachedKeys
-	cachedRemove := c.cachedRemove
-	c.cacheLock.RUnlock()
-
-	// Nothing to do if there is no data to flush.
-	if cachedKeys.Len() == 0 && cachedRemove.Len() == 0 {
-		return nil
-	}
-
-	// Perform all leveldb updates using an atomic transaction.
-	if err := c.commitTreaps(cachedKeys, cachedRemove); err != nil {
-		return err
-	}
-
-	// Clear the cache since it has been flushed.
-	c.cacheLock.Lock()
-	c.cachedKeys = treap.NewImmutable()
-	c.cachedRemove = treap.NewImmutable()
-	c.cacheLock.Unlock()
-
-	return nil
-}
-
-// needsFlush returns whether or not the database cache needs to be flushed to
-// persistent storage based on its current size, whether or not adding all of
-// the entries in the passed database transaction would cause it to exceed the
-// configured limit, and how much time has elapsed since the last time the cache
-// was flushed.
-//
-// This function MUST be called with the database write lock held.
-func (c *dbCache) needsFlush(tx *transaction) bool {
-	// A flush is needed when more time has elapsed than the configured
-	// flush interval.
-	if time.Since(c.lastFlush) >= c.flushInterval {
-		return true
-	}
-
-	// A flush is needed when the size of the database cache exceeds the
-	// specified max cache size. The total calculated size is multiplied by
-	// 1.5 here to account for additional memory consumption that will be
-	// needed during the flush as well as old nodes in the cache that are
-	// referenced by the snapshot used by the transaction.
-	snap := tx.snapshot
-	totalSize := snap.pendingKeys.Size() + snap.pendingRemove.Size()
-	totalSize = uint64(float64(totalSize) * 1.5)
-	return totalSize > c.maxSize
-}
-
-// commitTx atomically adds all of the pending keys to add and remove into the
-// database cache. When adding the pending keys would cause the size of the
-// cache to exceed the max cache size, or the time since the last flush exceeds
-// the configured flush interval, the cache will be flushed to the underlying
-// persistent database.
-//
-// This is an atomic operation with respect to the cache in that either all of
-// the pending keys to add and remove in the transaction will be applied or none
-// of them will.
-//
-// The database cache itself might be flushed to the underlying persistent
-// database even if the transaction fails to apply, but it will only be the
-// state of the cache without the transaction applied.
-//
-// This function MUST be called during a database write transaction which in
-// turn implies the database write lock will be held.
-func (c *dbCache) commitTx(tx *transaction) error {
-	// Flush the cache and write the current transaction directly to the
-	// database if a flush is needed.
-	if c.needsFlush(tx) {
-		if err := c.flush(); err != nil {
-			return err
-		}
-
-		// Perform all leveldb updates using an atomic transaction.
-		err := c.commitTreaps(tx.pendingKeys, tx.pendingRemove)
-		if err != nil {
-			return err
-		}
-
-		// Clear the transaction entries since they have been committed.
-		tx.pendingKeys = nil
-		tx.pendingRemove = nil
-		return nil
-	}
-
-	// At this point a database flush is not needed, so atomically commit
-	// the transaction to the cache.
-
-	// Since the cached keys to be added and removed use an immutable treap,
-	// a snapshot is simply obtaining the root of the tree under the lock
-	// which is used to atomically swap the root.
-	c.cacheLock.RLock()
-	newCachedKeys := c.cachedKeys
-	newCachedRemove := c.cachedRemove
-	c.cacheLock.RUnlock()
-
-	// Apply every key to add in the database transaction to the cache.
-	tx.pendingKeys.ForEach(func(k, v []byte) bool {
-		newCachedRemove = newCachedRemove.Delete(k)
-		newCachedKeys = newCachedKeys.Put(k, v)
-		return true
-	})
-	tx.pendingKeys = nil
-
-	// Apply every key to remove in the database transaction to the cache.
-	tx.pendingRemove.ForEach(func(k, v []byte) bool {
-		newCachedKeys = newCachedKeys.Delete(k)
-		newCachedRemove = newCachedRemove.Put(k, nil)
-		return true
-	})
-	tx.pendingRemove = nil
-
-	// Atomically replace the immutable treaps which hold the cached keys to
-	// add and delete.
-	c.cacheLock.Lock()
-	c.cachedKeys = newCachedKeys
-	c.cachedRemove = newCachedRemove
-	c.cacheLock.Unlock()
-	return nil
-}
-
-// Close cleanly shuts down the database cache by syncing all data and closing
-// the underlying leveldb database.
-//
-// This function MUST be called with the database write lock held.
-func (c *dbCache) Close() error {
-	// Flush any outstanding cached entries to disk.
-	if err := c.flush(); err != nil {
-		// Even if there is an error while flushing, attempt to close
-		// the underlying database. The error is ignored since it would
-		// mask the flush error.
-		_ = c.ldb.Close()
-		return err
-	}
-
-	// Close the underlying leveldb database.
-	if err := c.ldb.Close(); err != nil {
-		str := "failed to close underlying leveldb database"
-		return convertErr(str, err)
-	}
-
-	return nil
-}
-
-// newDbCache returns a new database cache instance backed by the provided
-// leveldb instance. The cache will be flushed to leveldb when the max size
-// exceeds the provided value or it has been longer than the provided interval
-// since the last flush.
-func newDbCache(ldb *leveldb.DB, store *blockStore, maxSize uint64, flushIntervalSecs uint32) *dbCache {
-	return &dbCache{
-		ldb:           ldb,
-		store:         store,
-		maxSize:       maxSize,
-		flushInterval: time.Second * time.Duration(flushIntervalSecs),
-		lastFlush:     time.Now(),
-		cachedKeys:    treap.NewImmutable(),
-		cachedRemove:  treap.NewImmutable(),
-	}
-}

database/ffldb/dbcache_test.go

@@ -1,136 +0,0 @@
-package ffldb
-
-import (
-	"bytes"
-	"testing"
-
-	ldbutil "github.com/btcsuite/goleveldb/leveldb/util"
-	"github.com/kaspanet/kaspad/database"
-)
-
-func TestExhaustedDbCacheIterator(t *testing.T) {
-	db := newTestDb("TestExhaustedDbCacheIterator", t)
-	defer db.Close()
-
-	snapshot, err := db.cache.Snapshot()
-	if err != nil {
-		t.Fatalf("TestExhaustedDbCacheIterator: Error creating cache snapshot: %s", err)
-	}
-	iterator := snapshot.NewIterator(&ldbutil.Range{})
-
-	if next := iterator.Next(); next != false {
-		t.Errorf("TestExhaustedDbCacheIterator: Expected .Next() = false, but got %v", next)
-	}
-
-	if prev := iterator.Prev(); prev != false {
-		t.Errorf("TestExhaustedDbCacheIterator: Expected .Prev() = false, but got %v", prev)
-	}
-
-	if key := iterator.Key(); key != nil {
-		t.Errorf("TestExhaustedDbCacheIterator: Expected .Key() = nil, but got %v", key)
-	}
-
-	if value := iterator.Value(); value != nil {
-		t.Errorf("TestExhaustedDbCacheIterator: Expected .Value() = nil, but got %v", value)
-	}
-}
-
-// TestLDBIteratorImplPlaceholders hits functions that are there to implement leveldb iterator.Iterator interface,
-// but surve no other purpose.
-func TestLDBIteratorImplPlaceholders(t *testing.T) {
-	db := newTestDb("TestIteratorImplPlaceholders", t)
-	defer db.Close()
-
-	snapshot, err := db.cache.Snapshot()
-	if err != nil {
-		t.Fatalf("TestLDBIteratorImplPlaceholders: Error creating cache snapshot: %s", err)
-	}
-	iterator := newLdbCacheIter(snapshot, &ldbutil.Range{})
-
-	if err = iterator.Error(); err != nil {
-		t.Errorf("TestLDBIteratorImplPlaceholders: Expected .Error() = nil, but got %v", err)
-	}
-
-	// Call SetReleaser to achieve coverage of it. Actually does nothing
-	iterator.SetReleaser(nil)
-}
-
-func TestSkipPendingUpdatesCache(t *testing.T) {
-	pdb := newTestDb("TestSkipPendingUpdatesCache", t)
-	defer pdb.Close()
-
-	value := []byte("value")
-	// Add numbered prefixes to keys so that they are in expected order, and before any other keys
-	firstKey := []byte("1 - first")
-	toDeleteKey := []byte("2 - toDelete")
-	toUpdateKey := []byte("3 - toUpdate")
-	secondKey := []byte("4 - second")
-
-	// create initial metadata for test
-	err := pdb.Update(func(dbTx database.Tx) error {
-		metadata := dbTx.Metadata()
-		if err := metadata.Put(firstKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toDeleteKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(toUpdateKey, value); err != nil {
-			return err
-		}
-		if err := metadata.Put(secondKey, value); err != nil {
-			return err
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Error adding to metadata: %s", err)
-	}
-
-	err = pdb.cache.flush()
-	if err != nil {
-		t.Fatalf("Error flushing cache: %s", err)
-	}
-
-	// test skips
-	err = pdb.Update(func(dbTx database.Tx) error {
-		snapshot, err := pdb.cache.Snapshot()
-		if err != nil {
-			t.Fatalf("TestSkipPendingUpdatesCache: Error getting snapshot: %s", err)
-		}
-
-		iterator := snapshot.NewIterator(&ldbutil.Range{})
-		snapshot.pendingRemove = snapshot.pendingRemove.Put(bucketizedKey(metadataBucketID, toDeleteKey), value)
-		snapshot.pendingKeys = snapshot.pendingKeys.Put(bucketizedKey(metadataBucketID, toUpdateKey), value)
-
-		// Check that first is ok
-		iterator.First()
-		expectedKey := bucketizedKey(metadataBucketID, firstKey)
-		actualKey := iterator.Key()
-		if !bytes.Equal(actualKey, expectedKey) {
-			t.Errorf("TestSkipPendingUpdatesCache: 1: key expected to be %v but is %v", expectedKey, actualKey)
-		}
-
-		// Go to the next key, which is second, toDelete and toUpdate will be skipped
-		iterator.Next()
-		expectedKey = bucketizedKey(metadataBucketID, secondKey)
-		actualKey = iterator.Key()
-		if !bytes.Equal(actualKey, expectedKey) {
-			t.Errorf("TestSkipPendingUpdatesCache: 2: key expected to be %s but is %s", expectedKey, actualKey)
-		}
-
-		// now traverse backwards - should get first, toUpdate and toDelete will be skipped
-		iterator.Prev()
-		expectedKey = bucketizedKey(metadataBucketID, firstKey)
-		actualKey = iterator.Key()
-		if !bytes.Equal(actualKey, expectedKey) {
-			t.Errorf("TestSkipPendingUpdatesCache: 4: key expected to be %s but is %s", expectedKey, actualKey)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("TestSkipPendingUpdatesCache: Error running main part of test: %s", err)
-	}
-}

database/ffldb/doc.go

@@ -1,25 +0,0 @@
-/*
-Package ffldb implements a driver for the database package that uses leveldb
-for the backing metadata and flat files for block storage.
-
-This driver is the recommended driver for use with kaspad. It makes use leveldb
-for the metadata, flat files for block storage, and checksums in key areas to
-ensure data integrity.
-
-Usage
-
-This package is a driver to the database package and provides the database type
-of "ffldb". The parameters the Open and Create functions take are the
-database path as a string and the block network:
-
-	db, err := database.Open("ffldb", "path/to/database", wire.Mainnet)
-	if err != nil {
-		// Handle error
-	}
-
-	db, err := database.Create("ffldb", "path/to/database", wire.Mainnet)
-	if err != nil {
-		// Handle error
-	}
-*/
-package ffldb

database/ffldb/driver.go

@@ -1,60 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package ffldb
-
-import (
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-const (
-	dbType = "ffldb"
-)
-
-// parseArgs parses the arguments from the database Open/Create methods.
-func parseArgs(funcName string, args ...interface{}) (string, wire.KaspaNet, error) {
-	if len(args) != 2 {
-		return "", 0, errors.Errorf("invalid arguments to %s.%s -- "+
-			"expected database path and block network", dbType,
-			funcName)
-	}
-
-	dbPath, ok := args[0].(string)
-	if !ok {
-		return "", 0, errors.Errorf("first argument to %s.%s is invalid -- "+
-			"expected database path string", dbType, funcName)
-	}
-
-	network, ok := args[1].(wire.KaspaNet)
-	if !ok {
-		return "", 0, errors.Errorf("second argument to %s.%s is invalid -- "+
-			"expected block network", dbType, funcName)
-	}
-
-	return dbPath, network, nil
-}
-
-// openDBDriver is the callback provided during driver registration that opens
-// an existing database for use.
-func openDBDriver(args ...interface{}) (database.DB, error) {
-	dbPath, network, err := parseArgs("Open", args...)
-	if err != nil {
-		return nil, err
-	}
-
-	return openDB(dbPath, network, false)
-}
-
-// createDBDriver is the callback provided during driver registration that
-// creates, initializes, and opens a database for use.
-func createDBDriver(args ...interface{}) (database.DB, error) {
-	dbPath, network, err := parseArgs("Create", args...)
-	if err != nil {
-		return nil, err
-	}
-
-	return openDB(dbPath, network, true)
-}

database/ffldb/driver_test.go

@@ -1,290 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package ffldb_test
-
-import (
-	"github.com/pkg/errors"
-	"os"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"testing"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/kaspanet/kaspad/util"
-)
-
-// dbType is the database type name for this driver.
-const dbType = "ffldb"
-
-// TestCreateOpenFail ensures that errors related to creating and opening a
-// database are handled properly.
-func TestCreateOpenFail(t *testing.T) {
-	t.Parallel()
-
-	// Ensure that attempting to open a database that doesn't exist returns
-	// the expected error.
-	wantErrCode := database.ErrDbDoesNotExist
-	_, err := database.Open(dbType, "noexist", blockDataNet)
-	if !checkDbError(t, "Open", err, wantErrCode) {
-		return
-	}
-
-	// Ensure that attempting to open a database with the wrong number of
-	// parameters returns the expected error.
-	wantErr := errors.Errorf("invalid arguments to %s.Open -- expected "+
-		"database path and block network", dbType)
-	_, err = database.Open(dbType, 1, 2, 3)
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Open: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure that attempting to open a database with an invalid type for
-	// the first parameter returns the expected error.
-	wantErr = errors.Errorf("first argument to %s.Open is invalid -- "+
-		"expected database path string", dbType)
-	_, err = database.Open(dbType, 1, blockDataNet)
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Open: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure that attempting to open a database with an invalid type for
-	// the second parameter returns the expected error.
-	wantErr = errors.Errorf("second argument to %s.Open is invalid -- "+
-		"expected block network", dbType)
-	_, err = database.Open(dbType, "noexist", "invalid")
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Open: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure that attempting to create a database with the wrong number of
-	// parameters returns the expected error.
-	wantErr = errors.Errorf("invalid arguments to %s.Create -- expected "+
-		"database path and block network", dbType)
-	_, err = database.Create(dbType, 1, 2, 3)
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Create: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure that attempting to create a database with an invalid type for
-	// the first parameter returns the expected error.
-	wantErr = errors.Errorf("first argument to %s.Create is invalid -- "+
-		"expected database path string", dbType)
-	_, err = database.Create(dbType, 1, blockDataNet)
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Create: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure that attempting to create a database with an invalid type for
-	// the second parameter returns the expected error.
-	wantErr = errors.Errorf("second argument to %s.Create is invalid -- "+
-		"expected block network", dbType)
-	_, err = database.Create(dbType, "noexist", "invalid")
-	if err.Error() != wantErr.Error() {
-		t.Errorf("Create: did not receive expected error - got %v, "+
-			"want %v", err, wantErr)
-		return
-	}
-
-	// Ensure operations against a closed database return the expected
-	// error.
-	dbPath := filepath.Join(os.TempDir(), "ffldb-createfail")
-	_ = os.RemoveAll(dbPath)
-	db, err := database.Create(dbType, dbPath, blockDataNet)
-	if err != nil {
-		t.Errorf("Create: unexpected error: %v", err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	db.Close()
-
-	wantErrCode = database.ErrDbNotOpen
-	err = db.View(func(dbTx database.Tx) error {
-		return nil
-	})
-	if !checkDbError(t, "View", err, wantErrCode) {
-		return
-	}
-
-	wantErrCode = database.ErrDbNotOpen
-	err = db.Update(func(dbTx database.Tx) error {
-		return nil
-	})
-	if !checkDbError(t, "Update", err, wantErrCode) {
-		return
-	}
-
-	wantErrCode = database.ErrDbNotOpen
-	_, err = db.Begin(false)
-	if !checkDbError(t, "Begin(false)", err, wantErrCode) {
-		return
-	}
-
-	wantErrCode = database.ErrDbNotOpen
-	_, err = db.Begin(true)
-	if !checkDbError(t, "Begin(true)", err, wantErrCode) {
-		return
-	}
-
-	wantErrCode = database.ErrDbNotOpen
-	err = db.Close()
-	if !checkDbError(t, "Close", err, wantErrCode) {
-		return
-	}
-}
-
-// TestPersistence ensures that values stored are still valid after closing and
-// reopening the database.
-func TestPersistence(t *testing.T) {
-	t.Parallel()
-
-	// Create a new database to run tests against.
-	dbPath := filepath.Join(os.TempDir(), "ffldb-persistencetest")
-	_ = os.RemoveAll(dbPath)
-	db, err := database.Create(dbType, dbPath, blockDataNet)
-	if err != nil {
-		t.Errorf("Failed to create test database (%s) %v", dbType, err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-
-	// Create a bucket, put some values into it, and store a block so they
-	// can be tested for existence on re-open.
-	bucket1Key := []byte("bucket1")
-	storeValues := map[string]string{
-		"b1key1": "foo1",
-		"b1key2": "foo2",
-		"b1key3": "foo3",
-	}
-	genesisBlock := util.NewBlock(dagconfig.MainnetParams.GenesisBlock)
-	genesisHash := dagconfig.MainnetParams.GenesisHash
-	err = db.Update(func(dbTx database.Tx) error {
-		metadataBucket := dbTx.Metadata()
-		if metadataBucket == nil {
-			return errors.Errorf("Metadata: unexpected nil bucket")
-		}
-
-		bucket1, err := metadataBucket.CreateBucket(bucket1Key)
-		if err != nil {
-			return errors.Errorf("CreateBucket: unexpected error: %v",
-				err)
-		}
-
-		for k, v := range storeValues {
-			err := bucket1.Put([]byte(k), []byte(v))
-			if err != nil {
-				return errors.Errorf("Put: unexpected error: %v",
-					err)
-			}
-		}
-
-		if err := dbTx.StoreBlock(genesisBlock); err != nil {
-			return errors.Errorf("StoreBlock: unexpected error: %v",
-				err)
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Errorf("Update: unexpected error: %v", err)
-		return
-	}
-
-	// Close and reopen the database to ensure the values persist.
-	db.Close()
-	db, err = database.Open(dbType, dbPath, blockDataNet)
-	if err != nil {
-		t.Errorf("Failed to open test database (%s) %v", dbType, err)
-		return
-	}
-	defer db.Close()
-
-	// Ensure the values previously stored in the 3rd namespace still exist
-	// and are correct.
-	err = db.View(func(dbTx database.Tx) error {
-		metadataBucket := dbTx.Metadata()
-		if metadataBucket == nil {
-			return errors.Errorf("Metadata: unexpected nil bucket")
-		}
-
-		bucket1 := metadataBucket.Bucket(bucket1Key)
-		if bucket1 == nil {
-			return errors.Errorf("Bucket1: unexpected nil bucket")
-		}
-
-		for k, v := range storeValues {
-			gotVal := bucket1.Get([]byte(k))
-			if !reflect.DeepEqual(gotVal, []byte(v)) {
-				return errors.Errorf("Get: key '%s' does not "+
-					"match expected value - got %s, want %s",
-					k, gotVal, v)
-			}
-		}
-
-		genesisBlockBytes, _ := genesisBlock.Bytes()
-		gotBytes, err := dbTx.FetchBlock(genesisHash)
-		if err != nil {
-			return errors.Errorf("FetchBlock: unexpected error: %v",
-				err)
-		}
-		if !reflect.DeepEqual(gotBytes, genesisBlockBytes) {
-			return errors.Errorf("FetchBlock: stored block mismatch")
-		}
-
-		return nil
-	})
-	if err != nil {
-		t.Errorf("View: unexpected error: %v", err)
-		return
-	}
-}
-
-// TestInterface performs all interfaces tests for this database driver.
-func TestInterface(t *testing.T) {
-	t.Parallel()
-
-	// Create a new database to run tests against.
-	dbPath := filepath.Join(os.TempDir(), "ffldb-interfacetest")
-	_ = os.RemoveAll(dbPath)
-	db, err := database.Create(dbType, dbPath, blockDataNet)
-	if err != nil {
-		t.Errorf("Failed to create test database (%s) %v", dbType, err)
-		return
-	}
-	defer os.RemoveAll(dbPath)
-	defer db.Close()
-
-	// Ensure the driver type is the expected value.
-	gotDbType := db.Type()
-	if gotDbType != dbType {
-		t.Errorf("Type: unepxected driver type - got %v, want %v",
-			gotDbType, dbType)
-		return
-	}
-
-	// Run all of the interface tests against the database.
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	// Change the maximum file size to a small value to force multiple flat
-	// files with the test data set.
-	// Change maximum open files to small value to force shifts in the LRU
-	// mechanism
-	ffldb.TstRunWithMaxBlockFileSizeAndMaxOpenFiles(db, 2048, 10, func() {
-		testInterface(t, db)
-	})
-}

database/ffldb/export_test.go

@@ -1,29 +0,0 @@
-// Copyright (c) 2015-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-/*
-This test file is part of the ffldb package rather than than the ffldb_test
-package so it can bridge access to the internals to properly test cases which
-are either not possible or can't reliably be tested via the public interface.
-The functions are only exported while the tests are being run.
-*/
-
-package ffldb
-
-import "github.com/kaspanet/kaspad/database"
-
-// TstRunWithMaxBlockFileSize runs the passed function with the maximum allowed
-// file size for the database set to the provided value. The value will be set
-// back to the original value upon completion.
-func TstRunWithMaxBlockFileSizeAndMaxOpenFiles(idb database.DB, size uint32, maxOpenFiles int, fn func()) {
-	ffldb := idb.(*db)
-	origSize := ffldb.store.maxBlockFileSize
-	origMaxOpenFiles := ffldb.store.maxOpenFiles
-
-	ffldb.store.maxBlockFileSize = size
-	ffldb.store.maxOpenFiles = maxOpenFiles
-	fn()
-	ffldb.store.maxBlockFileSize = origSize
-	ffldb.store.maxOpenFiles = origMaxOpenFiles
-}