[NOD-1208] Labels should be lower case

* [NOD-1226] Consider ErrIsClosed as protocol error during handshake

* Revert "[NOD-1226] Consider ErrIsClosed as protocol error during handshake"

This reverts commit 74bb07b6cd.

* [NOD-1226] handle errors separately for handshake

* [NOD-1226] Wrap ErrRouteClosed as protocol error in handshake

* [NOD-1226] return if ErrRouteClosed

* [NOD-1226] Use atomic

* [NOD-1226] Don't wrap with protocol error

* [NOD-1226] Fix comment

* [NOD-1226] Fix comment

addressmanager/addressmanager_test.go

@@ -2,18 +2,21 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr
+package addressmanager
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"io/ioutil"
 	"net"
 	"reflect"
 	"testing"
 	"time"
 
+	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/wire"
@@ -23,7 +26,7 @@ import (
 // method.
 type naTest struct {
 	in   wire.NetAddress
-	want string
+	want AddressKey
 }
 
 // naTests houses all of the tests to be performed against the NetAddressKey
@@ -94,36 +97,57 @@ func addNaTests() {
 	addNaTest("fef3::4:4", 8336, "[fef3::4:4]:8336")
 }
 
-func addNaTest(ip string, port uint16, want string) {
+func addNaTest(ip string, port uint16, want AddressKey) {
 	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) {
+func lookupFuncForTest(host string) ([]net.IP, error) {
 	return nil, errors.New("not implemented")
 }
 
+func newAddrManagerForTest(t *testing.T, testName string,
+	localSubnetworkID *subnetworkid.SubnetworkID) (addressManager *AddressManager, teardown func()) {
+
+	cfg := config.DefaultConfig()
+	cfg.SubnetworkID = localSubnetworkID
+
+	dbPath, err := ioutil.TempDir("", testName)
+	if err != nil {
+		t.Fatalf("Error creating temporary directory: %s", err)
+	}
+
+	databaseContext, err := dbaccess.New(dbPath)
+	if err != nil {
+		t.Fatalf("error creating db: %s", err)
+	}
+
+	addressManager = New(cfg, databaseContext)
+
+	return addressManager, func() {
+		err := databaseContext.Close()
+		if err != nil {
+			t.Fatalf("error closing the database: %s", err)
+		}
+	}
+}
+
 func TestStartStop(t *testing.T) {
-	n := New("teststartstop", lookupFunc, nil)
-	n.Start()
-	err := n.Stop()
+	amgr, teardown := newAddrManagerForTest(t, "TestStartStop", nil)
+	defer teardown()
+	err := amgr.Start()
+	if err != nil {
+		t.Fatalf("Address Manager failed to start: %v", err)
+	}
+	err = amgr.Stop()
 	if err != nil {
 		t.Fatalf("Address Manager failed to stop: %v", err)
 	}
 }
 
 func TestAddAddressByIP(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
 	fmtErr := errors.Errorf("")
 	addrErr := &net.AddrError{}
 	var tests = []struct {
@@ -148,7 +172,8 @@ func TestAddAddressByIP(t *testing.T) {
 		},
 	}
 
-	amgr := New("testaddressbyip", nil, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
+	defer teardown()
 	for i, test := range tests {
 		err := amgr.AddAddressByIP(test.addrIP, nil)
 		if test.err != nil && err == nil {
@@ -168,15 +193,6 @@ func TestAddAddressByIP(t *testing.T) {
 }
 
 func TestAddLocalAddress(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
 	var tests = []struct {
 		address  wire.NetAddress
 		priority AddressPriority
@@ -213,7 +229,8 @@ func TestAddLocalAddress(t *testing.T) {
 			true,
 		},
 	}
-	amgr := New("testaddlocaladdress", nil, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestAddLocalAddress", nil)
+	defer teardown()
 	for x, test := range tests {
 		result := amgr.AddLocalAddress(&test.address, test.priority)
 		if result == nil && !test.valid {
@@ -230,30 +247,22 @@ func TestAddLocalAddress(t *testing.T) {
 }
 
 func TestAttempt(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
-	n := New("testattempt", lookupFunc, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestAttempt", nil)
+	defer teardown()
 
 	// Add a new address and get it
-	err := n.AddAddressByIP(someIP+":8333", nil)
+	err := amgr.AddAddressByIP(someIP+":8333", nil)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
-	ka := n.GetAddress()
+	ka := amgr.GetAddress()
 
 	if !ka.LastAttempt().IsZero() {
 		t.Errorf("Address should not have attempts, but does")
 	}
 
 	na := ka.NetAddress()
-	n.Attempt(na)
+	amgr.Attempt(na)
 
 	if ka.LastAttempt().IsZero() {
 		t.Errorf("Address should have an attempt, but does not")
@@ -261,28 +270,20 @@ func TestAttempt(t *testing.T) {
 }
 
 func TestConnected(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
-	n := New("testconnected", lookupFunc, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestConnected", nil)
+	defer teardown()
 
 	// Add a new address and get it
-	err := n.AddAddressByIP(someIP+":8333", nil)
+	err := amgr.AddAddressByIP(someIP+":8333", nil)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
-	ka := n.GetAddress()
+	ka := amgr.GetAddress()
 	na := ka.NetAddress()
 	// make it an hour ago
-	na.Timestamp = time.Unix(time.Now().Add(time.Hour*-1).Unix(), 0)
+	na.Timestamp = mstime.Now().Add(time.Hour * -1)
 
-	n.Connected(na)
+	amgr.Connected(na)
 
 	if !ka.NetAddress().Timestamp.After(na.Timestamp) {
 		t.Errorf("Address should have a new timestamp, but does not")
@@ -290,18 +291,10 @@ func TestConnected(t *testing.T) {
 }
 
 func TestNeedMoreAddresses(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
-	n := New("testneedmoreaddresses", lookupFunc, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestNeedMoreAddresses", nil)
+	defer teardown()
 	addrsToAdd := 1500
-	b := n.NeedMoreAddresses()
+	b := amgr.NeedMoreAddresses()
 	if !b {
 		t.Errorf("Expected that we need more addresses")
 	}
@@ -309,8 +302,8 @@ func TestNeedMoreAddresses(t *testing.T) {
 
 	var err error
 	for i := 0; i < addrsToAdd; i++ {
-		s := fmt.Sprintf("%d.%d.173.147:8333", i/128+60, i%128+60)
-		addrs[i], err = n.DeserializeNetAddress(s)
+		s := AddressKey(fmt.Sprintf("%d.%d.173.147:8333", i/128+60, i%128+60))
+		addrs[i], err = amgr.DeserializeNetAddress(s)
 		if err != nil {
 			t.Errorf("Failed to turn %s into an address: %v", s, err)
 		}
@@ -318,29 +311,21 @@ func TestNeedMoreAddresses(t *testing.T) {
 
 	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
-	n.AddAddresses(addrs, srcAddr, nil)
-	numAddrs := n.TotalNumAddresses()
+	amgr.AddAddresses(addrs, srcAddr, nil)
+	numAddrs := amgr.TotalNumAddresses()
 	if numAddrs > addrsToAdd {
 		t.Errorf("Number of addresses is too many %d vs %d", numAddrs, addrsToAdd)
 	}
 
-	b = n.NeedMoreAddresses()
+	b = amgr.NeedMoreAddresses()
 	if b {
 		t.Errorf("Expected that we don't need more addresses")
 	}
 }
 
 func TestGood(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
-	n := New("testgood", lookupFunc, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestGood", nil)
+	defer teardown()
 	addrsToAdd := 64 * 64
 	addrs := make([]*wire.NetAddress, addrsToAdd)
 	subnetworkCount := 32
@@ -348,8 +333,8 @@ func TestGood(t *testing.T) {
 
 	var err error
 	for i := 0; i < addrsToAdd; i++ {
-		s := fmt.Sprintf("%d.173.147.%d:8333", i/64+60, i%64+60)
-		addrs[i], err = n.DeserializeNetAddress(s)
+		s := AddressKey(fmt.Sprintf("%d.173.147.%d:8333", i/64+60, i%64+60))
+		addrs[i], err = amgr.DeserializeNetAddress(s)
 		if err != nil {
 			t.Errorf("Failed to turn %s into an address: %v", s, err)
 		}
@@ -361,24 +346,24 @@ func TestGood(t *testing.T) {
 
 	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
-	n.AddAddresses(addrs, srcAddr, nil)
+	amgr.AddAddresses(addrs, srcAddr, nil)
 	for i, addr := range addrs {
-		n.Good(addr, subnetworkIDs[i%subnetworkCount])
+		amgr.Good(addr, subnetworkIDs[i%subnetworkCount])
 	}
 
-	numAddrs := n.TotalNumAddresses()
+	numAddrs := amgr.TotalNumAddresses()
 	if numAddrs >= addrsToAdd {
 		t.Errorf("Number of addresses is too many: %d vs %d", numAddrs, addrsToAdd)
 	}
 
-	numCache := len(n.AddressCache(true, nil))
+	numCache := len(amgr.AddressCache(true, nil))
 	if numCache == 0 || numCache >= numAddrs/4 {
 		t.Errorf("Number of addresses in cache: got %d, want positive and less than %d",
 			numCache, numAddrs/4)
 	}
 
 	for i := 0; i < subnetworkCount; i++ {
-		numCache = len(n.AddressCache(false, subnetworkIDs[i]))
+		numCache = len(amgr.AddressCache(false, subnetworkIDs[i]))
 		if numCache == 0 || numCache >= numAddrs/subnetworkCount {
 			t.Errorf("Number of addresses in subnetwork cache: got %d, want positive and less than %d",
 				numCache, numAddrs/4/subnetworkCount)
@@ -387,26 +372,18 @@ func TestGood(t *testing.T) {
 }
 
 func TestGoodChangeSubnetworkID(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
-	n := New("test_good_change_subnetwork_id", lookupFunc, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestGoodChangeSubnetworkID", nil)
+	defer teardown()
 	addr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 	addrKey := NetAddressKey(addr)
 	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
 	oldSubnetwork := subnetworkid.SubnetworkIDNative
-	n.AddAddress(addr, srcAddr, oldSubnetwork)
-	n.Good(addr, oldSubnetwork)
+	amgr.AddAddress(addr, srcAddr, oldSubnetwork)
+	amgr.Good(addr, oldSubnetwork)
 
-	// make sure address was saved to addrIndex under oldSubnetwork
-	ka := n.find(addr)
+	// make sure address was saved to addressIndex under oldSubnetwork
+	ka := amgr.knownAddress(addr)
 	if ka == nil {
 		t.Fatalf("Address was not found after first time .Good called")
 	}
@@ -415,10 +392,10 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	}
 
 	// make sure address was added to correct bucket under oldSubnetwork
-	bucket := n.addrTried[*oldSubnetwork][n.getTriedBucket(addr)]
+	bucket := amgr.subnetworkTriedAddresBucketArrays[*oldSubnetwork][amgr.triedAddressBucketIndex(addr)]
 	wasFound := false
-	for e := bucket.Front(); e != nil; e = e.Next() {
-		if NetAddressKey(e.Value.(*KnownAddress).NetAddress()) == addrKey {
+	for _, ka := range bucket {
+		if NetAddressKey(ka.NetAddress()) == addrKey {
 			wasFound = true
 		}
 	}
@@ -428,10 +405,10 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 
 	// now call .Good again with a different subnetwork
 	newSubnetwork := subnetworkid.SubnetworkIDRegistry
-	n.Good(addr, newSubnetwork)
+	amgr.Good(addr, newSubnetwork)
 
-	// make sure address was updated in addrIndex under newSubnetwork
-	ka = n.find(addr)
+	// make sure address was updated in addressIndex under newSubnetwork
+	ka = amgr.knownAddress(addr)
 	if ka == nil {
 		t.Fatalf("Address was not found after second time .Good called")
 	}
@@ -440,10 +417,10 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	}
 
 	// make sure address was removed from bucket under oldSubnetwork
-	bucket = n.addrTried[*oldSubnetwork][n.getTriedBucket(addr)]
+	bucket = amgr.subnetworkTriedAddresBucketArrays[*oldSubnetwork][amgr.triedAddressBucketIndex(addr)]
 	wasFound = false
-	for e := bucket.Front(); e != nil; e = e.Next() {
-		if NetAddressKey(e.Value.(*KnownAddress).NetAddress()) == addrKey {
+	for _, ka := range bucket {
+		if NetAddressKey(ka.NetAddress()) == addrKey {
 			wasFound = true
 		}
 	}
@@ -452,10 +429,10 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	}
 
 	// make sure address was added to correct bucket under newSubnetwork
-	bucket = n.addrTried[*newSubnetwork][n.getTriedBucket(addr)]
+	bucket = amgr.subnetworkTriedAddresBucketArrays[*newSubnetwork][amgr.triedAddressBucketIndex(addr)]
 	wasFound = false
-	for e := bucket.Front(); e != nil; e = e.Next() {
-		if NetAddressKey(e.Value.(*KnownAddress).NetAddress()) == addrKey {
+	for _, ka := range bucket {
+		if NetAddressKey(ka.NetAddress()) == addrKey {
 			wasFound = true
 		}
 	}
@@ -465,44 +442,36 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 }
 
 func TestGetAddress(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
 	localSubnetworkID := &subnetworkid.SubnetworkID{0xff}
-	n := New("testgetaddress", lookupFunc, localSubnetworkID)
+	amgr, teardown := newAddrManagerForTest(t, "TestGetAddress", localSubnetworkID)
+	defer teardown()
 
 	// Get an address from an empty set (should error)
-	if rv := n.GetAddress(); rv != nil {
+	if rv := amgr.GetAddress(); rv != nil {
 		t.Errorf("GetAddress failed: got: %v want: %v\n", rv, nil)
 	}
 
 	// Add a new address and get it
-	err := n.AddAddressByIP(someIP+":8332", localSubnetworkID)
+	err := amgr.AddAddressByIP(someIP+":8332", localSubnetworkID)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
-	ka := n.GetAddress()
+	ka := amgr.GetAddress()
 	if ka == nil {
 		t.Fatalf("Did not get an address where there is one in the pool")
 	}
-	n.Attempt(ka.NetAddress())
+	amgr.Attempt(ka.NetAddress())
 
 	// Checks that we don't get it if we find that it has other subnetwork ID than expected.
 	actualSubnetworkID := &subnetworkid.SubnetworkID{0xfe}
-	n.Good(ka.NetAddress(), actualSubnetworkID)
-	ka = n.GetAddress()
+	amgr.Good(ka.NetAddress(), actualSubnetworkID)
+	ka = amgr.GetAddress()
 	if ka != nil {
 		t.Errorf("Didn't expect to get an address because there shouldn't be any address from subnetwork ID %s or nil", localSubnetworkID)
 	}
 
 	// Checks that the total number of addresses incremented although the new address is not full node or a partial node of the same subnetwork as the local node.
-	numAddrs := n.TotalNumAddresses()
+	numAddrs := amgr.TotalNumAddresses()
 	if numAddrs != 1 {
 		t.Errorf("Wrong number of addresses: got %d, want %d", numAddrs, 1)
 	}
@@ -510,11 +479,11 @@ func TestGetAddress(t *testing.T) {
 	// Now we repeat the same process, but now the address has the expected subnetwork ID.
 
 	// Add a new address and get it
-	err = n.AddAddressByIP(someIP+":8333", localSubnetworkID)
+	err = amgr.AddAddressByIP(someIP+":8333", localSubnetworkID)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
-	ka = n.GetAddress()
+	ka = amgr.GetAddress()
 	if ka == nil {
 		t.Fatalf("Did not get an address where there is one in the pool")
 	}
@@ -524,11 +493,11 @@ func TestGetAddress(t *testing.T) {
 	if !ka.SubnetworkID().IsEqual(localSubnetworkID) {
 		t.Errorf("Wrong Subnetwork ID: got %v, want %v", *ka.SubnetworkID(), localSubnetworkID)
 	}
-	n.Attempt(ka.NetAddress())
+	amgr.Attempt(ka.NetAddress())
 
 	// Mark this as a good address and get it
-	n.Good(ka.NetAddress(), localSubnetworkID)
-	ka = n.GetAddress()
+	amgr.Good(ka.NetAddress(), localSubnetworkID)
+	ka = amgr.GetAddress()
 	if ka == nil {
 		t.Fatalf("Did not get an address where there is one in the pool")
 	}
@@ -539,22 +508,13 @@ func TestGetAddress(t *testing.T) {
 		t.Errorf("Wrong Subnetwork ID: got %v, want %v", ka.SubnetworkID(), localSubnetworkID)
 	}
 
-	numAddrs = n.TotalNumAddresses()
+	numAddrs = amgr.TotalNumAddresses()
 	if numAddrs != 2 {
 		t.Errorf("Wrong number of addresses: got %d, want %d", numAddrs, 1)
 	}
 }
 
 func TestGetBestLocalAddress(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
 	localAddrs := []wire.NetAddress{
 		{IP: net.ParseIP("192.168.0.100")},
 		{IP: net.ParseIP("::1")},
@@ -604,7 +564,8 @@ func TestGetBestLocalAddress(t *testing.T) {
 		*/
 	}
 
-	amgr := New("testgetbestlocaladdress", nil, nil)
+	amgr, teardown := newAddrManagerForTest(t, "TestGetBestLocalAddress", nil)
+	defer teardown()
 
 	// Test against default when there's no address
 	for x, test := range tests {

addressmanager/doc.go

@@ -1,5 +1,5 @@
 /*
-Package addrmgr implements concurrency safe Kaspa address manager.
+Package addressmanager implements concurrency safe Kaspa address manager.
 
 Address Manager Overview
 
@@ -31,4 +31,4 @@ peers which no longer appear to be good peers as well as bias the selection
 toward known good peers. The general idea is to make a best effort at only
 providing usable addresses.
 */
-package addrmgr
+package addressmanager

addressmanager/internal_test.go

@@ -2,11 +2,10 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr
+package addressmanager
 
 import (
-	"time"
-
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/kaspanet/kaspad/wire"
 )
 
@@ -19,7 +18,7 @@ func TstKnownAddressChance(ka *KnownAddress) float64 {
 }
 
 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}
+	lastattempt, lastsuccess mstime.Time, tried bool, refs int) *KnownAddress {
+	return &KnownAddress{netAddress: na, attempts: attempts, lastAttempt: lastattempt,
+		lastSuccess: lastsuccess, tried: tried, referenceCount: refs}
 }

addressmanager/knownaddress.go

@@ -2,9 +2,10 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr
+package addressmanager
 
 import (
+	"github.com/kaspanet/kaspad/util/mstime"
 	"time"
 
 	"github.com/kaspanet/kaspad/util/subnetworkid"
@@ -15,20 +16,22 @@ import (
 // KnownAddress tracks information about a known network address that is used
 // to determine how viable an address is.
 type KnownAddress struct {
-	na           *wire.NetAddress
-	srcAddr      *wire.NetAddress
-	attempts     int
-	lastattempt  time.Time
-	lastsuccess  time.Time
-	tried        bool
-	refs         int // reference count of new buckets
-	subnetworkID *subnetworkid.SubnetworkID
+	netAddress     *wire.NetAddress
+	sourceAddress  *wire.NetAddress
+	attempts       int
+	lastAttempt    mstime.Time
+	lastSuccess    mstime.Time
+	tried          bool
+	referenceCount int // reference count of new buckets
+	subnetworkID   *subnetworkid.SubnetworkID
+	isBanned       bool
+	bannedTime     mstime.Time
 }
 
 // NetAddress returns the underlying wire.NetAddress associated with the
 // known address.
 func (ka *KnownAddress) NetAddress() *wire.NetAddress {
-	return ka.na
+	return ka.netAddress
 }
 
 // SubnetworkID returns the subnetwork ID of the known address.
@@ -37,16 +40,16 @@ func (ka *KnownAddress) SubnetworkID() *subnetworkid.SubnetworkID {
 }
 
 // LastAttempt returns the last time the known address was attempted.
-func (ka *KnownAddress) LastAttempt() time.Time {
-	return ka.lastattempt
+func (ka *KnownAddress) LastAttempt() mstime.Time {
+	return ka.lastAttempt
 }
 
 // chance returns the selection probability for a known address. The priority
 // depends upon how recently the address has been seen, how recently it was last
 // attempted and how often attempts to connect to it have failed.
 func (ka *KnownAddress) chance() float64 {
-	now := time.Now()
-	lastAttempt := now.Sub(ka.lastattempt)
+	now := mstime.Now()
+	lastAttempt := now.Sub(ka.lastAttempt)
 
 	if lastAttempt < 0 {
 		lastAttempt = 0
@@ -76,27 +79,27 @@ func (ka *KnownAddress) chance() float64 {
 // All addresses that meet these criteria are assumed to be worthless and not
 // worth keeping hold of.
 func (ka *KnownAddress) isBad() bool {
-	if ka.lastattempt.After(time.Now().Add(-1 * time.Minute)) {
+	if ka.lastAttempt.After(mstime.Now().Add(-1 * time.Minute)) {
 		return false
 	}
 
 	// From the future?
-	if ka.na.Timestamp.After(time.Now().Add(10 * time.Minute)) {
+	if ka.netAddress.Timestamp.After(mstime.Now().Add(10 * time.Minute)) {
 		return true
 	}
 
 	// Over a month old?
-	if ka.na.Timestamp.Before(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
+	if ka.netAddress.Timestamp.Before(mstime.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
 		return true
 	}
 
 	// Never succeeded?
-	if ka.lastsuccess.IsZero() && ka.attempts >= numRetries {
+	if ka.lastSuccess.IsZero() && ka.attempts >= numRetries {
 		return true
 	}
 
 	// Hasn't succeeded in too long?
-	if !ka.lastsuccess.After(time.Now().Add(-1*minBadDays*time.Hour*24)) &&
+	if !ka.lastSuccess.After(mstime.Now().Add(-1*minBadDays*time.Hour*24)) &&
 		ka.attempts >= maxFailures {
 		return true
 	}

addressmanager/knownaddress_test.go

@@ -0,0 +1,115 @@
+// 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 addressmanager_test
+
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"math"
+	"testing"
+	"time"
+
+	"github.com/kaspanet/kaspad/addressmanager"
+	"github.com/kaspanet/kaspad/wire"
+)
+
+func TestChance(t *testing.T) {
+	now := mstime.Now()
+	var tests = []struct {
+		addr     *addressmanager.KnownAddress
+		expected float64
+	}{
+		{
+			//Test normal case
+			addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+				0, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
+			1.0,
+		}, {
+			//Test case in which lastseen < 0
+			addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(20 * time.Second)},
+				0, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
+			1.0,
+		}, {
+			//Test case in which lastAttempt < 0
+			addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+				0, mstime.Now().Add(30*time.Minute), mstime.Now(), false, 0),
+			1.0 * .01,
+		}, {
+			//Test case in which lastAttempt < ten minutes
+			addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+				0, mstime.Now().Add(-5*time.Minute), mstime.Now(), false, 0),
+			1.0 * .01,
+		}, {
+			//Test case with several failed attempts.
+			addressmanager.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+				2, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
+			1 / 1.5 / 1.5,
+		},
+	}
+
+	err := .0001
+	for i, test := range tests {
+		chance := addressmanager.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 := mstime.Now()
+	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 := mstime.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 addressmanager.TstKnownAddressIsBad(addressmanager.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 addressmanager.TstKnownAddressIsBad(addressmanager.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 addressmanager.TstKnownAddressIsBad(addressmanager.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 addressmanager.TstKnownAddressIsBad(addressmanager.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 addressmanager.TstKnownAddressIsBad(addressmanager.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 !addressmanager.TstKnownAddressIsBad(addressmanager.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 !addressmanager.TstKnownAddressIsBad(addressmanager.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 !addressmanager.TstKnownAddressIsBad(addressmanager.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 !addressmanager.TstKnownAddressIsBad(addressmanager.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 addressmanager.TstKnownAddressIsBad(addressmanager.TstNewKnownAddress(minutesOldNa, 2, minutesOld, hoursOld, true, 0)) {
+		t.Errorf("test case 10: This should be a valid address.")
+	}
+}

addressmanager/log.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr
+package addressmanager
 
 import (
 	"github.com/kaspanet/kaspad/logger"

addressmanager/network.go

@@ -2,13 +2,11 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr
+package addressmanager
 
 import (
 	"net"
 
-	"github.com/kaspanet/kaspad/config"
-
 	"github.com/kaspanet/kaspad/wire"
 )
 
@@ -202,8 +200,8 @@ func IsValid(na *wire.NetAddress) bool {
 // IsRoutable returns whether or not the passed address is routable over
 // the public internet. This is true as long as the address is valid and is not
 // in any reserved ranges.
-func IsRoutable(na *wire.NetAddress) bool {
-	if config.ActiveConfig().NetParams().AcceptUnroutable {
+func (am *AddressManager) IsRoutable(na *wire.NetAddress) bool {
+	if am.cfg.NetParams().AcceptUnroutable {
 		return !IsLocal(na)
 	}
 
@@ -217,11 +215,11 @@ func IsRoutable(na *wire.NetAddress) bool {
 // of. This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
 // "local" for a local address, and the string "unroutable" for an unroutable
 // address.
-func GroupKey(na *wire.NetAddress) string {
+func (am *AddressManager) GroupKey(na *wire.NetAddress) string {
 	if IsLocal(na) {
 		return "local"
 	}
-	if !IsRoutable(na) {
+	if !am.IsRoutable(na) {
 		return "unroutable"
 	}
 	if IsIPv4(na) {

addressmanager/network_test.go

@@ -2,30 +2,20 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addrmgr_test
+package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/dagconfig"
 	"net"
 	"testing"
 
-	"github.com/kaspanet/kaspad/addrmgr"
 	"github.com/kaspanet/kaspad/wire"
 )
 
 // TestIPTypes ensures the various functions which determine the type of an IP
 // address based on RFCs work as intended.
 func TestIPTypes(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
-
+	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
+	defer teardown()
 	type ipTest struct {
 		in       wire.NetAddress
 		rfc1918  bool
@@ -99,55 +89,55 @@ func TestIPTypes(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for _, test := range tests {
-		if rv := addrmgr.IsRFC1918(&test.in); rv != test.rfc1918 {
+		if rv := IsRFC1918(&test.in); rv != test.rfc1918 {
 			t.Errorf("IsRFC1918 %s\n got: %v want: %v", test.in.IP, rv, test.rfc1918)
 		}
 
-		if rv := addrmgr.IsRFC3849(&test.in); rv != test.rfc3849 {
+		if rv := IsRFC3849(&test.in); rv != test.rfc3849 {
 			t.Errorf("IsRFC3849 %s\n got: %v want: %v", test.in.IP, rv, test.rfc3849)
 		}
 
-		if rv := addrmgr.IsRFC3927(&test.in); rv != test.rfc3927 {
+		if rv := IsRFC3927(&test.in); rv != test.rfc3927 {
 			t.Errorf("IsRFC3927 %s\n got: %v want: %v", test.in.IP, rv, test.rfc3927)
 		}
 
-		if rv := addrmgr.IsRFC3964(&test.in); rv != test.rfc3964 {
+		if rv := IsRFC3964(&test.in); rv != test.rfc3964 {
 			t.Errorf("IsRFC3964 %s\n got: %v want: %v", test.in.IP, rv, test.rfc3964)
 		}
 
-		if rv := addrmgr.IsRFC4193(&test.in); rv != test.rfc4193 {
+		if rv := IsRFC4193(&test.in); rv != test.rfc4193 {
 			t.Errorf("IsRFC4193 %s\n got: %v want: %v", test.in.IP, rv, test.rfc4193)
 		}
 
-		if rv := addrmgr.IsRFC4380(&test.in); rv != test.rfc4380 {
+		if rv := IsRFC4380(&test.in); rv != test.rfc4380 {
 			t.Errorf("IsRFC4380 %s\n got: %v want: %v", test.in.IP, rv, test.rfc4380)
 		}
 
-		if rv := addrmgr.IsRFC4843(&test.in); rv != test.rfc4843 {
+		if rv := IsRFC4843(&test.in); rv != test.rfc4843 {
 			t.Errorf("IsRFC4843 %s\n got: %v want: %v", test.in.IP, rv, test.rfc4843)
 		}
 
-		if rv := addrmgr.IsRFC4862(&test.in); rv != test.rfc4862 {
+		if rv := IsRFC4862(&test.in); rv != test.rfc4862 {
 			t.Errorf("IsRFC4862 %s\n got: %v want: %v", test.in.IP, rv, test.rfc4862)
 		}
 
-		if rv := addrmgr.IsRFC6052(&test.in); rv != test.rfc6052 {
+		if rv := IsRFC6052(&test.in); rv != test.rfc6052 {
 			t.Errorf("isRFC6052 %s\n got: %v want: %v", test.in.IP, rv, test.rfc6052)
 		}
 
-		if rv := addrmgr.IsRFC6145(&test.in); rv != test.rfc6145 {
+		if rv := IsRFC6145(&test.in); rv != test.rfc6145 {
 			t.Errorf("IsRFC1918 %s\n got: %v want: %v", test.in.IP, rv, test.rfc6145)
 		}
 
-		if rv := addrmgr.IsLocal(&test.in); rv != test.local {
+		if rv := IsLocal(&test.in); rv != test.local {
 			t.Errorf("IsLocal %s\n got: %v want: %v", test.in.IP, rv, test.local)
 		}
 
-		if rv := addrmgr.IsValid(&test.in); rv != test.valid {
+		if rv := IsValid(&test.in); rv != test.valid {
 			t.Errorf("IsValid %s\n got: %v want: %v", test.in.IP, rv, test.valid)
 		}
 
-		if rv := addrmgr.IsRoutable(&test.in); rv != test.routable {
+		if rv := amgr.IsRoutable(&test.in); rv != test.routable {
 			t.Errorf("IsRoutable %s\n got: %v want: %v", test.in.IP, rv, test.routable)
 		}
 	}
@@ -156,14 +146,8 @@ func TestIPTypes(t *testing.T) {
 // TestGroupKey tests the GroupKey function to ensure it properly groups various
 // IP addresses.
 func TestGroupKey(t *testing.T) {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	defer config.SetActiveConfig(originalActiveCfg)
+	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
+	defer teardown()
 
 	tests := []struct {
 		name     string
@@ -213,7 +197,7 @@ func TestGroupKey(t *testing.T) {
 	for i, test := range tests {
 		nip := net.ParseIP(test.ip)
 		na := *wire.NewNetAddressIPPort(nip, 8333, wire.SFNodeNetwork)
-		if key := addrmgr.GroupKey(&na); key != test.expected {
+		if key := amgr.GroupKey(&na); key != test.expected {
 			t.Errorf("TestGroupKey #%d (%s): unexpected group key "+
 				"- got '%s', want '%s'", i, test.name,
 				key, test.expected)

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,248 @@
+package app
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/addressmanager"
+
+	"github.com/kaspanet/kaspad/netadapter/id"
+
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/blockdag/indexers"
+	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/connmanager"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/dnsseed"
+	"github.com/kaspanet/kaspad/mempool"
+	"github.com/kaspanet/kaspad/mining"
+	"github.com/kaspanet/kaspad/netadapter"
+	"github.com/kaspanet/kaspad/protocol"
+	"github.com/kaspanet/kaspad/rpc"
+	"github.com/kaspanet/kaspad/signal"
+	"github.com/kaspanet/kaspad/txscript"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/panics"
+	"github.com/kaspanet/kaspad/wire"
+)
+
+// 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() error {
+	// 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 nil
+	}
+
+	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)
+		}
+	}
+
+	return nil
+}
+
+// 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, wire.SFNodeNetwork, false, nil,
+			a.cfg.Lookup, func(addresses []*wire.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")
+		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, true)
+		},
+		IsDeploymentActive: dag.IsDeploymentActive,
+		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
+}
+
+// WaitForShutdown blocks until the main listener and peer handlers are stopped.
+func (a *App) WaitForShutdown() {
+	// TODO(libp2p)
+	// a.p2pServer.WaitForShutdown()
+}

app/log.go

@@ -1,13 +1,14 @@
-// Copyright (c) 2017 The btcsuite developers
+// 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 netsync
+package app
 
 import (
 	"github.com/kaspanet/kaspad/logger"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
-var log, _ = logger.Get(logger.SubsystemTags.SYNC)
+var log, _ = logger.Get(logger.SubsystemTags.KASD)
 var spawn = panics.GoroutineWrapperFunc(log)

blockdag/accept.go

@@ -6,6 +6,7 @@ package blockdag
 
 import (
 	"fmt"
+
 	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
@@ -17,7 +18,7 @@ func (dag *BlockDAG) addNodeToIndexWithInvalidAncestor(block *util.Block) error
 	newNode.status = statusInvalidAncestor
 	dag.index.AddNode(newNode)
 
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := dag.databaseContext.NewTx()
 	if err != nil {
 		return err
 	}
@@ -72,7 +73,7 @@ func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) er
 	// 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.
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := dag.databaseContext.NewTx()
 	if err != nil {
 		return err
 	}
@@ -105,8 +106,6 @@ func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) er
 		}
 	}
 
-	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)
@@ -133,17 +132,17 @@ func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) er
 	return nil
 }
 
-func lookupParentNodes(block *util.Block, blockDAG *BlockDAG) (blockSet, error) {
+func lookupParentNodes(block *util.Block, dag *BlockDAG) (blockSet, error) {
 	header := block.MsgBlock().Header
 	parentHashes := header.ParentHashes
 
 	nodes := newBlockSet()
 	for _, parentHash := range parentHashes {
-		node := blockDAG.index.LookupNode(parentHash)
-		if node == nil {
+		node, ok := dag.index.LookupNode(parentHash)
+		if !ok {
 			str := fmt.Sprintf("parent block %s is unknown", parentHash)
 			return nil, ruleError(ErrParentBlockUnknown, str)
-		} else if blockDAG.index.NodeStatus(node).KnownInvalid() {
+		} else if dag.index.NodeStatus(node).KnownInvalid() {
 			str := fmt.Sprintf("parent block %s is known to be invalid", parentHash)
 			return nil, ruleError(ErrInvalidAncestorBlock, str)
 		}

blockdag/accept_test.go

@@ -63,7 +63,10 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
 	if isOrphan {
 		t.Fatalf("TestMaybeAcceptBlockErrors: incorrectly returned block 1 is an orphan")
 	}
-	blockNode1 := dag.index.LookupNode(block1.Hash())
+	blockNode1, ok := dag.index.LookupNode(block1.Hash())
+	if !ok {
+		t.Fatalf("block %s does not exist in the DAG", block1.Hash())
+	}
 	dag.index.SetStatusFlags(blockNode1, statusValidateFailed)
 
 	block2 := blocks[2]

blockdag/blockheap_test.go

@@ -11,14 +11,14 @@ import (
 func TestBlockHeap(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("TestBlockHeap", true, Config{
-		DAGParams: &dagconfig.MainnetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("TestBlockHeap: Failed to setup DAG instance: %s", err)
 	}
 	defer teardownFunc()
 
-	block0Header := dagconfig.MainnetParams.GenesisBlock.Header
+	block0Header := dagconfig.SimnetParams.GenesisBlock.Header
 	block0, _ := dag.newBlockNode(&block0Header, newBlockSet())
 
 	block100000Header := Block100000.Header

blockdag/blockindex.go

@@ -50,11 +50,11 @@ func (bi *blockIndex) HaveBlock(hash *daghash.Hash) bool {
 // return nil if there is no entry for the hash.
 //
 // This function is safe for concurrent access.
-func (bi *blockIndex) LookupNode(hash *daghash.Hash) *blockNode {
+func (bi *blockIndex) LookupNode(hash *daghash.Hash) (*blockNode, bool) {
 	bi.RLock()
 	defer bi.RUnlock()
-	node := bi.index[*hash]
-	return node
+	node, ok := bi.index[*hash]
+	return node, ok
 }
 
 // AddNode adds the provided node to the block index and marks it as dirty.

blockdag/blockindex_test.go

@@ -1,10 +1,9 @@
 package blockdag
 
 import (
-	"testing"
-	"time"
-
 	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"testing"
 )
 
 func TestAncestorErrors(t *testing.T) {
@@ -18,7 +17,7 @@ func TestAncestorErrors(t *testing.T) {
 	}
 	defer teardownFunc()
 
-	node := newTestNode(dag, newBlockSet(), int32(0x10000000), 0, time.Unix(0, 0))
+	node := newTestNode(dag, newBlockSet(), int32(0x10000000), 0, mstime.Now())
 	node.blueScore = 2
 	ancestor := node.SelectedAncestor(3)
 	if ancestor != nil {

blockdag/blocklocator.go

@@ -29,8 +29,15 @@ func (dag *BlockDAG) BlockLocatorFromHashes(highHash, lowHash *daghash.Hash) (Bl
 	dag.dagLock.RLock()
 	defer dag.dagLock.RUnlock()
 
-	highNode := dag.index.LookupNode(highHash)
-	lowNode := dag.index.LookupNode(lowHash)
+	highNode, ok := dag.index.LookupNode(highHash)
+	if !ok {
+		return nil, errors.Errorf("block %s is unknown", highHash)
+	}
+
+	lowNode, ok := dag.index.LookupNode(lowHash)
+	if !ok {
+		return nil, errors.Errorf("block %s is unknown", lowHash)
+	}
 
 	return dag.blockLocator(highNode, lowNode)
 }
@@ -88,8 +95,8 @@ func (dag *BlockDAG) FindNextLocatorBoundaries(locator BlockLocator) (highHash,
 	lowNode := dag.genesis
 	nextBlockLocatorIndex := int64(len(locator) - 1)
 	for i, hash := range locator {
-		node := dag.index.LookupNode(hash)
-		if node != nil {
+		node, ok := dag.index.LookupNode(hash)
+		if ok {
 			lowNode = node
 			nextBlockLocatorIndex = int64(i) - 1
 			break

blockdag/blocknode.go

@@ -6,10 +6,11 @@ package blockdag
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/pkg/errors"
 	"math"
-	"time"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/wire"
@@ -110,7 +111,7 @@ func (dag *BlockDAG) newBlockNode(blockHeader *wire.BlockHeader, parents blockSe
 		parents:            parents,
 		children:           make(blockSet),
 		blueScore:          math.MaxUint64, // Initialized to the max value to avoid collisions with the genesis block
-		timestamp:          dag.Now().Unix(),
+		timestamp:          dag.Now().UnixMilliseconds(),
 		bluesAnticoneSizes: make(map[*blockNode]dagconfig.KType),
 	}
 
@@ -120,7 +121,7 @@ func (dag *BlockDAG) newBlockNode(blockHeader *wire.BlockHeader, parents blockSe
 		node.version = blockHeader.Version
 		node.bits = blockHeader.Bits
 		node.nonce = blockHeader.Nonce
-		node.timestamp = blockHeader.Timestamp.Unix()
+		node.timestamp = blockHeader.Timestamp.UnixMilliseconds()
 		node.hashMerkleRoot = blockHeader.HashMerkleRoot
 		node.acceptedIDMerkleRoot = blockHeader.AcceptedIDMerkleRoot
 		node.utxoCommitment = blockHeader.UTXOCommitment
@@ -167,7 +168,7 @@ func (node *blockNode) Header() *wire.BlockHeader {
 		HashMerkleRoot:       node.hashMerkleRoot,
 		AcceptedIDMerkleRoot: node.acceptedIDMerkleRoot,
 		UTXOCommitment:       node.utxoCommitment,
-		Timestamp:            time.Unix(node.timestamp, 0),
+		Timestamp:            node.time(),
 		Bits:                 node.bits,
 		Nonce:                node.nonce,
 	}
@@ -204,13 +205,13 @@ func (node *blockNode) RelativeAncestor(distance uint64) *blockNode {
 // prior to, and including, the block node.
 //
 // This function is safe for concurrent access.
-func (node *blockNode) PastMedianTime(dag *BlockDAG) time.Time {
+func (node *blockNode) PastMedianTime(dag *BlockDAG) mstime.Time {
 	window := blueBlockWindow(node, 2*dag.TimestampDeviationTolerance-1)
 	medianTimestamp, err := window.medianTimestamp()
 	if err != nil {
 		panic(fmt.Sprintf("blueBlockWindow: %s", err))
 	}
-	return time.Unix(medianTimestamp, 0)
+	return mstime.UnixMilliseconds(medianTimestamp)
 }
 
 func (node *blockNode) ParentHashes() []*daghash.Hash {
@@ -223,10 +224,14 @@ func (node *blockNode) isGenesis() bool {
 }
 
 func (node *blockNode) finalityScore(dag *BlockDAG) uint64 {
-	return node.blueScore / uint64(dag.dagParams.FinalityInterval)
+	return node.blueScore / uint64(dag.FinalityInterval())
 }
 
 // String returns a string that contains the block hash.
 func (node blockNode) String() string {
 	return node.hash.String()
 }
+
+func (node *blockNode) time() mstime.Time {
+	return mstime.UnixMilliseconds(node.timestamp)
+}

blockdag/blockwindow_test.go

@@ -51,12 +51,12 @@ func TestBlueBlockWindow(t *testing.T) {
 			expectedWindowWithGenesisPadding: []string{"B", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
-			parents:                          []string{"C", "D"},
+			parents:                          []string{"D", "C"},
 			id:                               "E",
 			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
-			parents:                          []string{"C", "D"},
+			parents:                          []string{"D", "C"},
 			id:                               "F",
 			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
@@ -133,7 +133,10 @@ func TestBlueBlockWindow(t *testing.T) {
 			t.Fatalf("block %v was unexpectedly orphan", blockData.id)
 		}
 
-		node := dag.index.LookupNode(utilBlock.Hash())
+		node, ok := dag.index.LookupNode(utilBlock.Hash())
+		if !ok {
+			t.Fatalf("block %s does not exist in the DAG", utilBlock.Hash())
+		}
 
 		blockByIDMap[blockData.id] = node
 		idByBlockMap[node] = blockData.id

blockdag/coinbase.go

@@ -4,16 +4,16 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/binary"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-	"github.com/pkg/errors"
 	"io"
-	"math"
 
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/coinbasepayload"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
 	"github.com/kaspanet/kaspad/util/txsort"
 	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
 )
 
 // compactFeeData is a specialized data type to store a compact list of fees
@@ -76,11 +76,11 @@ func (cfr *compactFeeIterator) next() (uint64, error) {
 
 // getBluesFeeData returns the compactFeeData for all nodes's blues,
 // used to calculate the fees this blockNode needs to pay
-func (node *blockNode) getBluesFeeData(dag *BlockDAG) (map[daghash.Hash]compactFeeData, error) {
+func (dag *BlockDAG) getBluesFeeData(node *blockNode) (map[daghash.Hash]compactFeeData, error) {
 	bluesFeeData := make(map[daghash.Hash]compactFeeData)
 
 	for _, blueBlock := range node.blues {
-		feeData, err := dbaccess.FetchFeeData(dbaccess.NoTx(), blueBlock.hash)
+		feeData, err := dbaccess.FetchFeeData(dag.databaseContext, blueBlock.hash)
 		if err != nil {
 			return nil, err
 		}
@@ -98,7 +98,10 @@ func (node *blockNode) validateCoinbaseTransaction(dag *BlockDAG, block *util.Bl
 		return nil
 	}
 	blockCoinbaseTx := block.CoinbaseTransaction().MsgTx()
-	scriptPubKey, extraData, err := DeserializeCoinbasePayload(blockCoinbaseTx)
+	_, scriptPubKey, extraData, err := coinbasepayload.DeserializeCoinbasePayload(blockCoinbaseTx)
+	if errors.Is(err, coinbasepayload.ErrIncorrectScriptPubKeyLen) {
+		return ruleError(ErrBadCoinbaseTransaction, err.Error())
+	}
 	if err != nil {
 		return err
 	}
@@ -116,7 +119,7 @@ func (node *blockNode) validateCoinbaseTransaction(dag *BlockDAG, block *util.Bl
 
 // expectedCoinbaseTransaction returns the coinbase transaction for the current block
 func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceData MultiBlockTxsAcceptanceData, scriptPubKey []byte, extraData []byte) (*util.Tx, error) {
-	bluesFeeData, err := node.getBluesFeeData(dag)
+	bluesFeeData, err := dag.getBluesFeeData(node)
 	if err != nil {
 		return nil, err
 	}
@@ -125,16 +128,15 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
 	txOuts := []*wire.TxOut{}
 
 	for _, blue := range node.blues {
-		txIn, txOut, err := coinbaseInputAndOutputForBlueBlock(dag, blue, txsAcceptanceData, bluesFeeData)
+		txOut, err := coinbaseOutputForBlueBlock(dag, blue, txsAcceptanceData, bluesFeeData)
 		if err != nil {
 			return nil, err
 		}
-		txIns = append(txIns, txIn)
 		if txOut != nil {
 			txOuts = append(txOuts, txOut)
 		}
 	}
-	payload, err := SerializeCoinbasePayload(scriptPubKey, extraData)
+	payload, err := coinbasepayload.SerializeCoinbasePayload(node.blueScore, scriptPubKey, extraData)
 	if err != nil {
 		return nil, err
 	}
@@ -143,99 +145,49 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
 	return util.NewTx(sortedCoinbaseTx), nil
 }
 
-// SerializeCoinbasePayload builds the coinbase payload based on the provided scriptPubKey and extra data.
-func SerializeCoinbasePayload(scriptPubKey []byte, extraData []byte) ([]byte, error) {
-	w := &bytes.Buffer{}
-	err := wire.WriteVarInt(w, uint64(len(scriptPubKey)))
-	if err != nil {
-		return nil, err
-	}
-	_, err = w.Write(scriptPubKey)
-	if err != nil {
-		return nil, err
-	}
-	_, err = w.Write(extraData)
-	if err != nil {
-		return nil, err
-	}
-	return w.Bytes(), nil
-}
-
-// DeserializeCoinbasePayload deserialize the coinbase payload to its component (scriptPubKey and extra data).
-func DeserializeCoinbasePayload(tx *wire.MsgTx) (scriptPubKey []byte, extraData []byte, err error) {
-	r := bytes.NewReader(tx.Payload)
-	scriptPubKeyLen, err := wire.ReadVarInt(r)
-	if err != nil {
-		return nil, nil, err
-	}
-	scriptPubKey = make([]byte, scriptPubKeyLen)
-	_, err = r.Read(scriptPubKey)
-	if err != nil {
-		return nil, nil, err
-	}
-	extraData = make([]byte, r.Len())
-	if r.Len() != 0 {
-		_, err = r.Read(extraData)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-	return scriptPubKey, extraData, nil
-}
-
-// feeInputAndOutputForBlueBlock calculates the input and output that should go into the coinbase transaction of blueBlock
-// If blueBlock gets no fee - returns only txIn and nil for txOut
-func coinbaseInputAndOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
-	txsAcceptanceData MultiBlockTxsAcceptanceData, feeData map[daghash.Hash]compactFeeData) (
-	*wire.TxIn, *wire.TxOut, error) {
+// coinbaseOutputForBlueBlock calculates the output that should go into the coinbase transaction of blueBlock
+// If blueBlock gets no fee - returns nil for txOut
+func coinbaseOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
+	txsAcceptanceData MultiBlockTxsAcceptanceData, feeData map[daghash.Hash]compactFeeData) (*wire.TxOut, error) {
 
 	blockTxsAcceptanceData, ok := txsAcceptanceData.FindAcceptanceData(blueBlock.hash)
 	if !ok {
-		return nil, nil, errors.Errorf("No txsAcceptanceData for block %s", blueBlock.hash)
+		return nil, errors.Errorf("No txsAcceptanceData for block %s", blueBlock.hash)
 	}
 	blockFeeData, ok := feeData[*blueBlock.hash]
 	if !ok {
-		return nil, nil, errors.Errorf("No feeData for block %s", blueBlock.hash)
+		return nil, errors.Errorf("No feeData for block %s", blueBlock.hash)
 	}
 
 	if len(blockTxsAcceptanceData.TxAcceptanceData) != blockFeeData.Len() {
-		return nil, nil, errors.Errorf(
+		return nil, errors.Errorf(
 			"length of accepted transaction data(%d) and fee data(%d) is not equal for block %s",
 			len(blockTxsAcceptanceData.TxAcceptanceData), blockFeeData.Len(), blueBlock.hash)
 	}
 
-	txIn := &wire.TxIn{
-		SignatureScript: []byte{},
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID(*blueBlock.hash),
-			Index: math.MaxUint32,
-		},
-		Sequence: wire.MaxTxInSequenceNum,
-	}
-
 	totalFees := uint64(0)
 	feeIterator := blockFeeData.iterator()
 
 	for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
 		fee, err := feeIterator.next()
 		if err != nil {
-			return nil, nil, errors.Errorf("Error retrieving fee from compactFeeData iterator: %s", err)
+			return nil, errors.Errorf("Error retrieving fee from compactFeeData iterator: %s", err)
 		}
 		if txAcceptanceData.IsAccepted {
 			totalFees += fee
 		}
 	}
 
-	totalReward := CalcBlockSubsidy(blueBlock.blueScore, dag.dagParams) + totalFees
+	totalReward := CalcBlockSubsidy(blueBlock.blueScore, dag.Params) + totalFees
 
 	if totalReward == 0 {
-		return txIn, nil, nil
+		return nil, nil
 	}
 
 	// the ScriptPubKey for the coinbase is parsed from the coinbase payload
-	scriptPubKey, _, err := DeserializeCoinbasePayload(blockTxsAcceptanceData.TxAcceptanceData[0].Tx.MsgTx())
+	_, scriptPubKey, _, err := coinbasepayload.DeserializeCoinbasePayload(blockTxsAcceptanceData.TxAcceptanceData[0].Tx.MsgTx())
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	txOut := &wire.TxOut{
@@ -243,5 +195,5 @@ func coinbaseInputAndOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
 		ScriptPubKey: scriptPubKey,
 	}
 
-	return txIn, txOut, nil
+	return txOut, nil
 }

blockdag/common_test.go

@@ -12,7 +12,8 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
+
+	"github.com/kaspanet/kaspad/util/mstime"
 
 	"github.com/pkg/errors"
 
@@ -86,7 +87,7 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
 // TestSetCoinbaseMaturity makes the ability to set the coinbase maturity
 // available when running tests.
 func (dag *BlockDAG) TestSetCoinbaseMaturity(maturity uint64) {
-	dag.dagParams.BlockCoinbaseMaturity = maturity
+	dag.Params.BlockCoinbaseMaturity = maturity
 }
 
 // newTestDAG returns a DAG that is usable for syntetic tests. It is
@@ -95,11 +96,9 @@ func (dag *BlockDAG) TestSetCoinbaseMaturity(maturity uint64) {
 // use of it.
 func newTestDAG(params *dagconfig.Params) *BlockDAG {
 	index := newBlockIndex(params)
-	targetTimePerBlock := int64(params.TargetTimePerBlock / time.Second)
 	dag := &BlockDAG{
-		dagParams:                      params,
+		Params:                         params,
 		timeSource:                     NewTimeSource(),
-		targetTimePerBlock:             targetTimePerBlock,
 		difficultyAdjustmentWindowSize: params.DifficultyAdjustmentWindowSize,
 		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
 		powMaxBits:                     util.BigToCompact(params.PowMax),
@@ -119,7 +118,7 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG {
 
 // newTestNode creates a block node connected to the passed parent with the
 // provided fields populated and fake values for the other fields.
-func newTestNode(dag *BlockDAG, parents blockSet, blockVersion int32, bits uint32, timestamp time.Time) *blockNode {
+func newTestNode(dag *BlockDAG, parents blockSet, blockVersion int32, bits uint32, timestamp mstime.Time) *blockNode {
 	// Make up a header and create a block node from it.
 	header := &wire.BlockHeader{
 		Version:              blockVersion,
@@ -178,21 +177,21 @@ func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parent
 }
 
 func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *wire.MsgBlock) *blockNode {
-	node := dag.index.LookupNode(block.BlockHash())
-	if node == nil {
+	node, ok := dag.index.LookupNode(block.BlockHash())
+	if !ok {
 		t.Fatalf("couldn't find block node with hash %s", block.BlockHash())
 	}
 	return node
 }
 
 type fakeTimeSource struct {
-	time time.Time
+	time mstime.Time
 }
 
-func (fts *fakeTimeSource) Now() time.Time {
-	return time.Unix(fts.time.Unix(), 0)
+func (fts *fakeTimeSource) Now() mstime.Time {
+	return fts.time
 }
 
-func newFakeTimeSource(fakeTime time.Time) TimeSource {
+func newFakeTimeSource(fakeTime mstime.Time) TimeSource {
 	return &fakeTimeSource{time: fakeTime}
 }

blockdag/dag.go

@@ -11,6 +11,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/kaspanet/kaspad/util/mstime"
+
 	"github.com/kaspanet/kaspad/dbaccess"
 
 	"github.com/pkg/errors"
@@ -30,7 +32,9 @@ const (
 	// queued.
 	maxOrphanBlocks = 100
 
-	isDAGCurrentMaxDiff = 12 * time.Hour
+	// isDAGCurrentMaxDiff is the number of blocks from the network tips (estimated by timestamps) for the current
+	// to be considered not synced
+	isDAGCurrentMaxDiff = 40_000
 )
 
 // orphanBlock represents a block that we don't yet have the parent for. It
@@ -38,13 +42,13 @@ const (
 // forever.
 type orphanBlock struct {
 	block      *util.Block
-	expiration time.Time
+	expiration mstime.Time
 }
 
 // delayedBlock represents a block which has a delayed timestamp and will be processed at processTime
 type delayedBlock struct {
 	block       *util.Block
-	processTime time.Time
+	processTime mstime.Time
 }
 
 // chainUpdates represents the updates made to the selected parent chain after
@@ -61,17 +65,17 @@ type BlockDAG 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.
-	dagParams    *dagconfig.Params
-	timeSource   TimeSource
-	sigCache     *txscript.SigCache
-	indexManager IndexManager
-	genesis      *blockNode
+	Params          *dagconfig.Params
+	databaseContext *dbaccess.DatabaseContext
+	timeSource      TimeSource
+	sigCache        *txscript.SigCache
+	indexManager    IndexManager
+	genesis         *blockNode
 
 	// The following fields are calculated based upon the provided DAG
 	// parameters. They are also set when the instance is created and
 	// can't be changed afterwards, so there is no need to protect them with
 	// a separate mutex.
-	targetTimePerBlock             int64 // The target delay between blocks (in seconds)
 	difficultyAdjustmentWindowSize uint64
 	TimestampDeviationTolerance    uint64
 
@@ -151,12 +155,111 @@ type BlockDAG struct {
 
 	lastFinalityPoint *blockNode
 
-	utxoDiffStore     *utxoDiffStore
-	reachabilityStore *reachabilityStore
-	multisetStore     *multisetStore
+	utxoDiffStore *utxoDiffStore
+	multisetStore *multisetStore
 
-	recentBlockProcessingTimestamps []time.Time
-	startTime                       time.Time
+	reachabilityTree *reachabilityTree
+
+	recentBlockProcessingTimestamps []mstime.Time
+	startTime                       mstime.Time
+}
+
+// New returns a BlockDAG instance using the provided configuration details.
+func New(config *Config) (*BlockDAG, error) {
+	// Enforce required config fields.
+	if config.DAGParams == nil {
+		return nil, errors.New("BlockDAG.New DAG parameters nil")
+	}
+	if config.TimeSource == nil {
+		return nil, errors.New("BlockDAG.New timesource is nil")
+	}
+	if config.DatabaseContext == nil {
+		return nil, errors.New("BlockDAG.DatabaseContext timesource is nil")
+	}
+
+	params := config.DAGParams
+
+	index := newBlockIndex(params)
+	dag := &BlockDAG{
+		Params:                         params,
+		databaseContext:                config.DatabaseContext,
+		timeSource:                     config.TimeSource,
+		sigCache:                       config.SigCache,
+		indexManager:                   config.IndexManager,
+		difficultyAdjustmentWindowSize: params.DifficultyAdjustmentWindowSize,
+		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
+		powMaxBits:                     util.BigToCompact(params.PowMax),
+		index:                          index,
+		orphans:                        make(map[daghash.Hash]*orphanBlock),
+		prevOrphans:                    make(map[daghash.Hash][]*orphanBlock),
+		delayedBlocks:                  make(map[daghash.Hash]*delayedBlock),
+		delayedBlocksQueue:             newDelayedBlocksHeap(),
+		warningCaches:                  newThresholdCaches(vbNumBits),
+		deploymentCaches:               newThresholdCaches(dagconfig.DefinedDeployments),
+		blockCount:                     0,
+		subnetworkID:                   config.SubnetworkID,
+		startTime:                      mstime.Now(),
+	}
+
+	dag.virtual = newVirtualBlock(dag, nil)
+	dag.utxoDiffStore = newUTXODiffStore(dag)
+	dag.multisetStore = newMultisetStore(dag)
+	dag.reachabilityTree = newReachabilityTree(dag)
+
+	// Initialize the DAG state from the passed database. When the db
+	// does not yet contain any DAG state, both it and the DAG state
+	// will be initialized to contain only the genesis block.
+	err := dag.initDAGState()
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize and catch up all of the currently active optional indexes
+	// as needed.
+	if config.IndexManager != nil {
+		err = config.IndexManager.Init(dag, dag.databaseContext)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	genesis, ok := index.LookupNode(params.GenesisHash)
+
+	if !ok {
+		genesisBlock := util.NewBlock(dag.Params.GenesisBlock)
+		// To prevent the creation of a new err variable unintentionally so the
+		// defered function above could read err - declare isOrphan and isDelayed explicitly.
+		var isOrphan, isDelayed bool
+		isOrphan, isDelayed, err = dag.ProcessBlock(genesisBlock, BFNone)
+		if err != nil {
+			return nil, err
+		}
+		if isDelayed {
+			return nil, errors.New("genesis block shouldn't be in the future")
+		}
+		if isOrphan {
+			return nil, errors.New("genesis block is unexpectedly orphan")
+		}
+		genesis, ok = index.LookupNode(params.GenesisHash)
+		if !ok {
+			return nil, errors.New("genesis is not found in the DAG after it was proccessed")
+		}
+	}
+
+	// Save a reference to the genesis block.
+	dag.genesis = genesis
+
+	// Initialize rule change threshold state caches.
+	err = dag.initThresholdCaches()
+	if err != nil {
+		return nil, err
+	}
+
+	selectedTip := dag.selectedTip()
+	log.Infof("DAG state (blue score %d, hash %s)",
+		selectedTip.blueScore, selectedTip.hash)
+
+	return dag, nil
 }
 
 // IsKnownBlock returns whether or not the DAG instance has the block represented
@@ -165,7 +268,7 @@ type BlockDAG struct {
 //
 // This function is safe for concurrent access.
 func (dag *BlockDAG) IsKnownBlock(hash *daghash.Hash) bool {
-	return dag.IsInDAG(hash) || dag.IsKnownOrphan(hash) || dag.isKnownDelayedBlock(hash)
+	return dag.IsInDAG(hash) || dag.IsKnownOrphan(hash) || dag.isKnownDelayedBlock(hash) || dag.IsKnownInvalid(hash)
 }
 
 // AreKnownBlocks returns whether or not the DAG instances has all blocks represented
@@ -209,8 +312,8 @@ func (dag *BlockDAG) IsKnownOrphan(hash *daghash.Hash) bool {
 //
 // This function is safe for concurrent access.
 func (dag *BlockDAG) IsKnownInvalid(hash *daghash.Hash) bool {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		return false
 	}
 	return dag.index.NodeStatus(node).KnownInvalid()
@@ -219,7 +322,7 @@ func (dag *BlockDAG) IsKnownInvalid(hash *daghash.Hash) bool {
 // GetOrphanMissingAncestorHashes returns all of the missing parents in the orphan's sub-DAG
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) GetOrphanMissingAncestorHashes(orphanHash *daghash.Hash) ([]*daghash.Hash, error) {
+func (dag *BlockDAG) GetOrphanMissingAncestorHashes(orphanHash *daghash.Hash) []*daghash.Hash {
 	// Protect concurrent access. Using a read lock only so multiple
 	// readers can query without blocking each other.
 	dag.orphanLock.RLock()
@@ -244,7 +347,7 @@ func (dag *BlockDAG) GetOrphanMissingAncestorHashes(orphanHash *daghash.Hash) ([
 			}
 		}
 	}
-	return missingAncestorsHashes, nil
+	return missingAncestorsHashes
 }
 
 // removeOrphanBlock removes the passed orphan block from the orphan pool and
@@ -292,7 +395,7 @@ func (dag *BlockDAG) removeOrphanBlock(orphan *orphanBlock) {
 func (dag *BlockDAG) addOrphanBlock(block *util.Block) {
 	// Remove expired orphan blocks.
 	for _, oBlock := range dag.orphans {
-		if time.Now().After(oBlock.expiration) {
+		if mstime.Now().After(oBlock.expiration) {
 			dag.removeOrphanBlock(oBlock)
 			continue
 		}
@@ -324,7 +427,7 @@ func (dag *BlockDAG) addOrphanBlock(block *util.Block) {
 
 	// Insert the block into the orphan map with an expiration time
 	// 1 hour from now.
-	expiration := time.Now().Add(time.Hour)
+	expiration := mstime.Now().Add(time.Hour)
 	oBlock := &orphanBlock{
 		block:      block,
 		expiration: expiration,
@@ -344,7 +447,7 @@ func (dag *BlockDAG) addOrphanBlock(block *util.Block) {
 // block either after 'seconds' (according to past median time), or once the
 // 'BlockBlueScore' has been reached.
 type SequenceLock struct {
-	Seconds        int64
+	Milliseconds   int64
 	BlockBlueScore int64
 }
 
@@ -378,7 +481,7 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
 	// A value of -1 for each relative lock type represents a relative time
 	// lock value that will allow a transaction to be included in a block
 	// at any given height or time.
-	sequenceLock := &SequenceLock{Seconds: -1, BlockBlueScore: -1}
+	sequenceLock := &SequenceLock{Milliseconds: -1, BlockBlueScore: -1}
 
 	// Sequence locks don't apply to coinbase transactions Therefore, we
 	// return sequence lock values of -1 indicating that this transaction
@@ -430,16 +533,15 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
 			}
 			medianTime := blockNode.PastMedianTime(dag)
 
-			// Time based relative time-locks as defined by BIP 68
-			// have a time granularity of RelativeLockSeconds, so
-			// we shift left by this amount to convert to the
-			// proper relative time-lock. We also subtract one from
-			// the relative lock to maintain the original lockTime
-			// semantics.
-			timeLockSeconds := (relativeLock << wire.SequenceLockTimeGranularity) - 1
-			timeLock := medianTime.Unix() + timeLockSeconds
-			if timeLock > sequenceLock.Seconds {
-				sequenceLock.Seconds = timeLock
+			// Time based relative time-locks have a time granularity of
+			// wire.SequenceLockTimeGranularity, so we shift left by this
+			// amount to convert to the proper relative time-lock. We also
+			// subtract one from the relative lock to maintain the original
+			// lockTime semantics.
+			timeLockMilliseconds := (relativeLock << wire.SequenceLockTimeGranularity) - 1
+			timeLock := medianTime.UnixMilliseconds() + timeLockMilliseconds
+			if timeLock > sequenceLock.Milliseconds {
+				sequenceLock.Milliseconds = timeLock
 			}
 		default:
 			// The relative lock-time for this input is expressed
@@ -458,18 +560,18 @@ func (dag *BlockDAG) calcSequenceLock(node *blockNode, utxoSet UTXOSet, tx *util
 }
 
 // LockTimeToSequence converts the passed relative locktime to a sequence
-// number in accordance to BIP-68.
-func LockTimeToSequence(isSeconds bool, locktime uint64) uint64 {
+// number.
+func LockTimeToSequence(isMilliseconds bool, locktime uint64) uint64 {
 	// If we're expressing the relative lock time in blocks, then the
 	// corresponding sequence number is simply the desired input age.
-	if !isSeconds {
+	if !isMilliseconds {
 		return locktime
 	}
 
-	// Set the 22nd bit which indicates the lock time is in seconds, then
-	// shift the locktime over by 9 since the time granularity is in
-	// 512-second intervals (2^9). This results in a max lock-time of
-	// 33,553,920 seconds, or 1.1 years.
+	// Set the 22nd bit which indicates the lock time is in milliseconds, then
+	// shift the locktime over by 19 since the time granularity is in
+	// 524288-millisecond intervals (2^19). This results in a max lock-time of
+	// 34,359,214,080 seconds, or 1.1 years.
 	return wire.SequenceLockTimeIsSeconds |
 		locktime>>wire.SequenceLockTimeGranularity
 }
@@ -491,7 +593,7 @@ func (dag *BlockDAG) addBlock(node *blockNode,
 		if errors.As(err, &RuleError{}) {
 			dag.index.SetStatusFlags(node, statusValidateFailed)
 
-			dbTx, err := dbaccess.NewTx()
+			dbTx, err := dag.databaseContext.NewTx()
 			if err != nil {
 				return nil, err
 			}
@@ -551,8 +653,8 @@ func (node *blockNode) validateAcceptedIDMerkleRoot(dag *BlockDAG, txsAcceptance
 func (dag *BlockDAG) connectBlock(node *blockNode,
 	block *util.Block, selectedParentAnticone []*blockNode, fastAdd bool) (*chainUpdates, error) {
 	// No warnings about unknown rules or versions until the DAG is
-	// current.
-	if dag.isCurrent() {
+	// synced.
+	if dag.isSynced() {
 		// Warn if any unknown new rules are either about to activate or
 		// have already been activated.
 		if err := dag.warnUnknownRuleActivations(node); err != nil {
@@ -566,7 +668,7 @@ func (dag *BlockDAG) connectBlock(node *blockNode,
 		}
 	}
 
-	if err := dag.checkFinalityRules(node); err != nil {
+	if err := dag.checkFinalityViolation(node); err != nil {
 		return nil, err
 	}
 
@@ -577,10 +679,6 @@ func (dag *BlockDAG) connectBlock(node *blockNode,
 	newBlockPastUTXO, txsAcceptanceData, newBlockFeeData, newBlockMultiSet, err :=
 		node.verifyAndBuildUTXO(dag, block.Transactions(), fastAdd)
 	if err != nil {
-		var ruleErr RuleError
-		if ok := errors.As(err, &ruleErr); ok {
-			return nil, ruleError(ruleErr.ErrorCode, fmt.Sprintf("error verifying UTXO for %s: %s", node, err))
-		}
 		return nil, errors.Wrapf(err, "error verifying UTXO for %s", node)
 	}
 
@@ -658,22 +756,20 @@ func (node *blockNode) selectedParentMultiset(dag *BlockDAG) (*secp256k1.MultiSe
 }
 
 func addTxToMultiset(ms *secp256k1.MultiSet, tx *wire.MsgTx, pastUTXO UTXOSet, blockBlueScore uint64) (*secp256k1.MultiSet, error) {
-	isCoinbase := tx.IsCoinBase()
-	if !isCoinbase {
-		for _, txIn := range tx.TxIn {
-			entry, ok := pastUTXO.Get(txIn.PreviousOutpoint)
-			if !ok {
-				return nil, errors.Errorf("Couldn't find entry for outpoint %s", txIn.PreviousOutpoint)
-			}
+	for _, txIn := range tx.TxIn {
+		entry, ok := pastUTXO.Get(txIn.PreviousOutpoint)
+		if !ok {
+			return nil, errors.Errorf("Couldn't find entry for outpoint %s", txIn.PreviousOutpoint)
+		}
 
-			var err error
-			ms, err = removeUTXOFromMultiset(ms, entry, &txIn.PreviousOutpoint)
-			if err != nil {
-				return nil, err
-			}
+		var err error
+		ms, err = removeUTXOFromMultiset(ms, entry, &txIn.PreviousOutpoint)
+		if err != nil {
+			return nil, err
 		}
 	}
 
+	isCoinbase := tx.IsCoinBase()
 	for i, txOut := range tx.TxOut {
 		outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
 		entry := NewUTXOEntry(txOut, isCoinbase, blockBlueScore)
@@ -690,7 +786,7 @@ func addTxToMultiset(ms *secp256k1.MultiSet, tx *wire.MsgTx, pastUTXO UTXOSet, b
 func (dag *BlockDAG) saveChangesFromBlock(block *util.Block, virtualUTXODiff *UTXODiff,
 	txsAcceptanceData MultiBlockTxsAcceptanceData, feeData compactFeeData) error {
 
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := dag.databaseContext.NewTx()
 	if err != nil {
 		return err
 	}
@@ -706,7 +802,7 @@ func (dag *BlockDAG) saveChangesFromBlock(block *util.Block, virtualUTXODiff *UT
 		return err
 	}
 
-	err = dag.reachabilityStore.flushToDB(dbTx)
+	err = dag.reachabilityTree.storeState(dbTx)
 	if err != nil {
 		return err
 	}
@@ -766,7 +862,7 @@ func (dag *BlockDAG) saveChangesFromBlock(block *util.Block, virtualUTXODiff *UT
 	dag.index.clearDirtyEntries()
 	dag.utxoDiffStore.clearDirtyEntries()
 	dag.utxoDiffStore.clearOldEntries()
-	dag.reachabilityStore.clearDirtyEntries()
+	dag.reachabilityTree.store.clearDirtyEntries()
 	dag.multisetStore.clearNewEntries()
 
 	return nil
@@ -792,7 +888,7 @@ func (dag *BlockDAG) validateGasLimit(block *util.Block) error {
 		if !msgTx.SubnetworkID.IsEqual(currentSubnetworkID) {
 			currentSubnetworkID = &msgTx.SubnetworkID
 			currentGasUsage = 0
-			currentSubnetworkGasLimit, err = GasLimit(currentSubnetworkID)
+			currentSubnetworkGasLimit, err = dag.GasLimit(currentSubnetworkID)
 			if err != nil {
 				return errors.Errorf("Error getting gas limit for subnetworkID '%s': %s", currentSubnetworkID, err)
 			}
@@ -822,20 +918,45 @@ func (dag *BlockDAG) LastFinalityPointHash() *daghash.Hash {
 	return dag.lastFinalityPoint.hash
 }
 
-// checkFinalityRules checks the new block does not violate the finality rules
-// specifically - the new block selectedParent chain should contain the old finality point
-func (dag *BlockDAG) checkFinalityRules(newNode *blockNode) error {
+// isInSelectedParentChainOf returns whether `node` is in the selected parent chain of `other`.
+func (dag *BlockDAG) isInSelectedParentChainOf(node *blockNode, other *blockNode) (bool, error) {
+	// By definition, a node is not in the selected parent chain of itself.
+	if node == other {
+		return false, nil
+	}
+
+	return dag.reachabilityTree.isReachabilityTreeAncestorOf(node, other)
+}
+
+// FinalityInterval is the interval that determines the finality window of the DAG.
+func (dag *BlockDAG) FinalityInterval() uint64 {
+	return uint64(dag.Params.FinalityDuration / dag.Params.TargetTimePerBlock)
+}
+
+// checkFinalityViolation checks the new block does not violate the finality rules
+// specifically - the new block selectedParent chain should contain the old finality point.
+func (dag *BlockDAG) checkFinalityViolation(newNode *blockNode) error {
 	// the genesis block can not violate finality rules
 	if newNode.isGenesis() {
 		return nil
 	}
 
-	for currentNode := newNode; currentNode != dag.lastFinalityPoint; currentNode = currentNode.selectedParent {
-		// If we went past dag's last finality point without encountering it -
-		// the new block has violated finality.
-		if currentNode.blueScore <= dag.lastFinalityPoint.blueScore {
-			return ruleError(ErrFinality, "The last finality point is not in the selected chain of this block")
-		}
+	// Because newNode doesn't have reachability data we
+	// need to check if the last finality point is in the
+	// selected parent chain of newNode.selectedParent, so
+	// we explicitly check if newNode.selectedParent is
+	// the finality point.
+	if dag.lastFinalityPoint == newNode.selectedParent {
+		return nil
+	}
+
+	isInSelectedChain, err := dag.isInSelectedParentChainOf(dag.lastFinalityPoint, newNode.selectedParent)
+	if err != nil {
+		return err
+	}
+
+	if !isInSelectedChain {
+		return ruleError(ErrFinality, "the last finality point is not in the selected parent chain of this block")
 	}
 	return nil
 }
@@ -862,7 +983,7 @@ func (dag *BlockDAG) updateFinalityPoint() {
 		}
 	}
 	dag.lastFinalityPoint = currentNode
-	spawn(func() {
+	spawn("dag.finalizeNodesBelowFinalityPoint", func() {
 		dag.finalizeNodesBelowFinalityPoint(true)
 	})
 }
@@ -874,7 +995,7 @@ func (dag *BlockDAG) finalizeNodesBelowFinalityPoint(deleteDiffData bool) {
 	}
 	var nodesToDelete []*blockNode
 	if deleteDiffData {
-		nodesToDelete = make([]*blockNode, 0, dag.dagParams.FinalityInterval)
+		nodesToDelete = make([]*blockNode, 0, dag.FinalityInterval())
 	}
 	for len(queue) > 0 {
 		var current *blockNode
@@ -890,7 +1011,7 @@ func (dag *BlockDAG) finalizeNodesBelowFinalityPoint(deleteDiffData bool) {
 		}
 	}
 	if deleteDiffData {
-		err := dag.utxoDiffStore.removeBlocksDiffData(dbaccess.NoTx(), nodesToDelete)
+		err := dag.utxoDiffStore.removeBlocksDiffData(dag.databaseContext, nodesToDelete)
 		if err != nil {
 			panic(fmt.Sprintf("Error removing diff data from utxoDiffStore: %s", err))
 		}
@@ -900,10 +1021,10 @@ func (dag *BlockDAG) finalizeNodesBelowFinalityPoint(deleteDiffData bool) {
 // IsKnownFinalizedBlock returns whether the block is below the finality point.
 // IsKnownFinalizedBlock might be false-negative because node finality status is
 // updated in a separate goroutine. To get a definite answer if a block
-// is finalized or not, use dag.checkFinalityRules.
+// is finalized or not, use dag.checkFinalityViolation.
 func (dag *BlockDAG) IsKnownFinalizedBlock(blockHash *daghash.Hash) bool {
-	node := dag.index.LookupNode(blockHash)
-	return node != nil && node.isFinalized
+	node, ok := dag.index.LookupNode(blockHash)
+	return ok && node.isFinalized
 }
 
 // NextBlockCoinbaseTransaction prepares the coinbase transaction for the next mined block
@@ -951,8 +1072,8 @@ func (dag *BlockDAG) TxsAcceptedByVirtual() (MultiBlockTxsAcceptanceData, error)
 //
 // This function MUST be called with the DAG read-lock held
 func (dag *BlockDAG) TxsAcceptedByBlockHash(blockHash *daghash.Hash) (MultiBlockTxsAcceptanceData, error) {
-	node := dag.index.LookupNode(blockHash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(blockHash)
+	if !ok {
 		return nil, errors.Errorf("Couldn't find block %s", blockHash)
 	}
 	_, _, txsAcceptanceData, err := dag.pastUTXO(node)
@@ -976,10 +1097,10 @@ func (dag *BlockDAG) applyDAGChanges(node *blockNode, newBlockPastUTXO UTXOSet,
 	newBlockMultiset *secp256k1.MultiSet, selectedParentAnticone []*blockNode) (
 	virtualUTXODiff *UTXODiff, chainUpdates *chainUpdates, err error) {
 
-	// Add the block to the reachability structures
-	err = dag.updateReachability(node, selectedParentAnticone)
+	// Add the block to the reachability tree
+	err = dag.reachabilityTree.addBlock(node, selectedParentAnticone)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "failed updating reachability")
+		return nil, nil, errors.Wrap(err, "failed adding block to the reachability tree")
 	}
 
 	dag.multisetStore.setMultiset(node, newBlockMultiset)
@@ -1121,10 +1242,10 @@ func genesisPastUTXO(virtual *virtualBlock) UTXOSet {
 	return genesisPastUTXO
 }
 
-func (node *blockNode) fetchBlueBlocks() ([]*util.Block, error) {
+func (dag *BlockDAG) fetchBlueBlocks(node *blockNode) ([]*util.Block, error) {
 	blueBlocks := make([]*util.Block, len(node.blues))
 	for i, blueBlockNode := range node.blues {
-		blueBlock, err := fetchBlockByHash(dbaccess.NoTx(), blueBlockNode.hash)
+		blueBlock, err := dag.fetchBlockByHash(blueBlockNode.hash)
 		if err != nil {
 			return nil, err
 		}
@@ -1238,7 +1359,7 @@ func (dag *BlockDAG) pastUTXO(node *blockNode) (
 		return nil, nil, nil, err
 	}
 
-	blueBlocks, err := node.fetchBlueBlocks()
+	blueBlocks, err := dag.fetchBlueBlocks(node)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -1310,48 +1431,48 @@ func updateTipsUTXO(dag *BlockDAG, virtualUTXO UTXOSet) error {
 	return nil
 }
 
-// isCurrent returns whether or not the DAG believes it is current. Several
+// isSynced returns whether or not the DAG believes it is synced. Several
 // factors are used to guess, but the key factors that allow the DAG to
-// believe it is current are:
+// believe it is synced are:
 //  - Latest block has a timestamp newer than 24 hours ago
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) isCurrent() bool {
-	// Not current if the virtual's selected parent has a timestamp
+func (dag *BlockDAG) isSynced() bool {
+	// Not synced if the virtual's selected parent has a timestamp
 	// before 24 hours ago. If the DAG is empty, we take the genesis
 	// block timestamp.
 	//
-	// The DAG appears to be current if none of the checks reported
+	// The DAG appears to be syncned if none of the checks reported
 	// otherwise.
 	var dagTimestamp int64
 	selectedTip := dag.selectedTip()
 	if selectedTip == nil {
-		dagTimestamp = dag.dagParams.GenesisBlock.Header.Timestamp.Unix()
+		dagTimestamp = dag.Params.GenesisBlock.Header.Timestamp.UnixMilliseconds()
 	} else {
 		dagTimestamp = selectedTip.timestamp
 	}
-	dagTime := time.Unix(dagTimestamp, 0)
-	return dag.Now().Sub(dagTime) <= isDAGCurrentMaxDiff
+	dagTime := mstime.UnixMilliseconds(dagTimestamp)
+	return dag.Now().Sub(dagTime) <= isDAGCurrentMaxDiff*dag.Params.TargetTimePerBlock
 }
 
 // Now returns the adjusted time according to
 // dag.timeSource. See TimeSource.Now for
 // more details.
-func (dag *BlockDAG) Now() time.Time {
+func (dag *BlockDAG) Now() mstime.Time {
 	return dag.timeSource.Now()
 }
 
-// IsCurrent returns whether or not the DAG believes it is current. Several
+// IsSynced returns whether or not the DAG believes it is synced. Several
 // factors are used to guess, but the key factors that allow the DAG to
-// believe it is current are:
+// believe it is synced are:
 //  - Latest block has a timestamp newer than 24 hours ago
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) IsCurrent() bool {
+func (dag *BlockDAG) IsSynced() bool {
 	dag.dagLock.RLock()
 	defer dag.dagLock.RUnlock()
 
-	return dag.isCurrent()
+	return dag.isSynced()
 }
 
 // selectedTip returns the current selected tip for the DAG.
@@ -1392,7 +1513,7 @@ func (dag *BlockDAG) UTXOSet() *FullUTXOSet {
 }
 
 // CalcPastMedianTime returns the past median time of the DAG.
-func (dag *BlockDAG) CalcPastMedianTime() time.Time {
+func (dag *BlockDAG) CalcPastMedianTime() mstime.Time {
 	return dag.virtual.tips().bluest().PastMedianTime(dag)
 }
 
@@ -1407,8 +1528,8 @@ func (dag *BlockDAG) GetUTXOEntry(outpoint wire.Outpoint) (*UTXOEntry, bool) {
 
 // BlueScoreByBlockHash returns the blue score of a block with the given hash.
 func (dag *BlockDAG) BlueScoreByBlockHash(hash *daghash.Hash) (uint64, error) {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		return 0, errors.Errorf("block %s is unknown", hash)
 	}
 
@@ -1417,8 +1538,8 @@ func (dag *BlockDAG) BlueScoreByBlockHash(hash *daghash.Hash) (uint64, error) {
 
 // BluesByBlockHash returns the blues of the block for the given hash.
 func (dag *BlockDAG) BluesByBlockHash(hash *daghash.Hash) ([]*daghash.Hash, error) {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		return nil, errors.Errorf("block %s is unknown", hash)
 	}
 
@@ -1449,8 +1570,8 @@ func (dag *BlockDAG) BlockConfirmationsByHashNoLock(hash *daghash.Hash) (uint64,
 		return 0, nil
 	}
 
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		return 0, errors.Errorf("block %s is unknown", hash)
 	}
 
@@ -1565,10 +1686,10 @@ func (dag *BlockDAG) oldestChainBlockWithBlueScoreGreaterThan(blueScore uint64)
 //
 // This method MUST be called with the DAG lock held
 func (dag *BlockDAG) IsInSelectedParentChain(blockHash *daghash.Hash) (bool, error) {
-	blockNode := dag.index.LookupNode(blockHash)
-	if blockNode == nil {
+	blockNode, ok := dag.index.LookupNode(blockHash)
+	if !ok {
 		str := fmt.Sprintf("block %s is not in the DAG", blockHash)
-		return false, errNotInDAG(str)
+		return false, ErrNotInDAG(str)
 	}
 	return dag.virtual.selectedParentChainSet.contains(blockNode), nil
 }
@@ -1598,7 +1719,10 @@ func (dag *BlockDAG) SelectedParentChain(blockHash *daghash.Hash) ([]*daghash.Ha
 	for !isBlockInSelectedParentChain {
 		removedChainHashes = append(removedChainHashes, blockHash)
 
-		node := dag.index.LookupNode(blockHash)
+		node, ok := dag.index.LookupNode(blockHash)
+		if !ok {
+			return nil, nil, errors.Errorf("block %s does not exist in the DAG", blockHash)
+		}
 		blockHash = node.selectedParent.hash
 
 		isBlockInSelectedParentChain, err = dag.IsInSelectedParentChain(blockHash)
@@ -1661,8 +1785,8 @@ func (dag *BlockDAG) CurrentBits() uint32 {
 // HeaderByHash returns the block header identified by the given hash or an
 // error if it doesn't exist.
 func (dag *BlockDAG) HeaderByHash(hash *daghash.Hash) (*wire.BlockHeader, error) {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		err := errors.Errorf("block %s is not known", hash)
 		return &wire.BlockHeader{}, err
 	}
@@ -1675,10 +1799,10 @@ func (dag *BlockDAG) HeaderByHash(hash *daghash.Hash) (*wire.BlockHeader, error)
 //
 // This function is safe for concurrent access.
 func (dag *BlockDAG) ChildHashesByHash(hash *daghash.Hash) ([]*daghash.Hash, error) {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		str := fmt.Sprintf("block %s is not in the DAG", hash)
-		return nil, errNotInDAG(str)
+		return nil, ErrNotInDAG(str)
 
 	}
 
@@ -1690,10 +1814,10 @@ func (dag *BlockDAG) ChildHashesByHash(hash *daghash.Hash) ([]*daghash.Hash, err
 //
 // This function is safe for concurrent access.
 func (dag *BlockDAG) SelectedParentHash(blockHash *daghash.Hash) (*daghash.Hash, error) {
-	node := dag.index.LookupNode(blockHash)
-	if node == nil {
+	node, ok := dag.index.LookupNode(blockHash)
+	if !ok {
 		str := fmt.Sprintf("block %s is not in the DAG", blockHash)
-		return nil, errNotInDAG(str)
+		return nil, ErrNotInDAG(str)
 
 	}
 
@@ -1725,12 +1849,12 @@ func (dag *BlockDAG) antiPastHashesBetween(lowHash, highHash *daghash.Hash, maxH
 //
 // This function MUST be called with the DAG state lock held (for reads).
 func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries uint64) ([]*blockNode, error) {
-	lowNode := dag.index.LookupNode(lowHash)
-	if lowNode == nil {
+	lowNode, ok := dag.index.LookupNode(lowHash)
+	if !ok {
 		return nil, errors.Errorf("Couldn't find low hash %s", lowHash)
 	}
-	highNode := dag.index.LookupNode(highHash)
-	if highNode == nil {
+	highNode, ok := dag.index.LookupNode(highHash)
+	if !ok {
 		return nil, errors.Errorf("Couldn't find high hash %s", highHash)
 	}
 	if lowNode.blueScore >= highNode.blueScore {
@@ -1763,7 +1887,7 @@ func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries
 			continue
 		}
 		visited.add(current)
-		isCurrentAncestorOfLowNode, err := dag.isAncestorOf(current, lowNode)
+		isCurrentAncestorOfLowNode, err := dag.isInPast(current, lowNode)
 		if err != nil {
 			return nil, err
 		}
@@ -1789,6 +1913,10 @@ func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries
 	return nodes, nil
 }
 
+func (dag *BlockDAG) isInPast(this *blockNode, other *blockNode) (bool, error) {
+	return dag.reachabilityTree.isInPast(this, other)
+}
+
 // AntiPastHashesBetween returns the hashes of the blocks between the
 // lowHash's antiPast and highHash's antiPast, or up to the provided
 // max number of block hashes.
@@ -1825,8 +1953,9 @@ func (dag *BlockDAG) antiPastHeadersBetween(lowHash, highHash *daghash.Hash, max
 func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
 	highNode := &dag.virtual.blockNode
 	if highHash != nil {
-		highNode = dag.index.LookupNode(highHash)
-		if highNode == nil {
+		var ok bool
+		highNode, ok = dag.index.LookupNode(highHash)
+		if !ok {
 			return nil, errors.Errorf("Couldn't find the high hash %s in the dag", highHash)
 		}
 	}
@@ -1955,7 +2084,7 @@ func (dag *BlockDAG) peekDelayedBlock() *delayedBlock {
 type IndexManager interface {
 	// Init is invoked during DAG initialize in order to allow the index
 	// manager to initialize itself and any indexes it is managing.
-	Init(*BlockDAG) error
+	Init(*BlockDAG, *dbaccess.DatabaseContext) error
 
 	// ConnectBlock is invoked when a new block has been connected to the
 	// DAG.
@@ -2002,99 +2131,10 @@ type Config struct {
 	//
 	// This field is required.
 	SubnetworkID *subnetworkid.SubnetworkID
-}
 
-// New returns a BlockDAG instance using the provided configuration details.
-func New(config *Config) (*BlockDAG, error) {
-	// Enforce required config fields.
-	if config.DAGParams == nil {
-		return nil, errors.New("BlockDAG.New DAG parameters nil")
-	}
-	if config.TimeSource == nil {
-		return nil, errors.New("BlockDAG.New timesource is nil")
-	}
-
-	params := config.DAGParams
-	targetTimePerBlock := int64(params.TargetTimePerBlock / time.Second)
-
-	index := newBlockIndex(params)
-	dag := &BlockDAG{
-		dagParams:                      params,
-		timeSource:                     config.TimeSource,
-		sigCache:                       config.SigCache,
-		indexManager:                   config.IndexManager,
-		targetTimePerBlock:             targetTimePerBlock,
-		difficultyAdjustmentWindowSize: params.DifficultyAdjustmentWindowSize,
-		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
-		powMaxBits:                     util.BigToCompact(params.PowMax),
-		index:                          index,
-		orphans:                        make(map[daghash.Hash]*orphanBlock),
-		prevOrphans:                    make(map[daghash.Hash][]*orphanBlock),
-		delayedBlocks:                  make(map[daghash.Hash]*delayedBlock),
-		delayedBlocksQueue:             newDelayedBlocksHeap(),
-		warningCaches:                  newThresholdCaches(vbNumBits),
-		deploymentCaches:               newThresholdCaches(dagconfig.DefinedDeployments),
-		blockCount:                     0,
-		subnetworkID:                   config.SubnetworkID,
-		startTime:                      time.Now(),
-	}
-
-	dag.virtual = newVirtualBlock(dag, nil)
-	dag.utxoDiffStore = newUTXODiffStore(dag)
-	dag.reachabilityStore = newReachabilityStore(dag)
-	dag.multisetStore = newMultisetStore(dag)
-
-	// Initialize the DAG state from the passed database. When the db
-	// does not yet contain any DAG state, both it and the DAG state
-	// will be initialized to contain only the genesis block.
-	err := dag.initDAGState()
-	if err != nil {
-		return nil, err
-	}
-
-	// Initialize and catch up all of the currently active optional indexes
-	// as needed.
-	if config.IndexManager != nil {
-		err = config.IndexManager.Init(dag)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	genesis := index.LookupNode(params.GenesisHash)
-
-	if genesis == nil {
-		genesisBlock := util.NewBlock(dag.dagParams.GenesisBlock)
-		// To prevent the creation of a new err variable unintentionally so the
-		// defered function above could read err - declare isOrphan and isDelayed explicitly.
-		var isOrphan, isDelayed bool
-		isOrphan, isDelayed, err = dag.ProcessBlock(genesisBlock, BFNone)
-		if err != nil {
-			return nil, err
-		}
-		if isDelayed {
-			return nil, errors.New("Genesis block shouldn't be in the future")
-		}
-		if isOrphan {
-			return nil, errors.New("Genesis block is unexpectedly orphan")
-		}
-		genesis = index.LookupNode(params.GenesisHash)
-	}
-
-	// Save a reference to the genesis block.
-	dag.genesis = genesis
-
-	// Initialize rule change threshold state caches.
-	err = dag.initThresholdCaches()
-	if err != nil {
-		return nil, err
-	}
-
-	selectedTip := dag.selectedTip()
-	log.Infof("DAG state (blue score %d, hash %s)",
-		selectedTip.blueScore, selectedTip.hash)
-
-	return dag, nil
+	// DatabaseContext is the context in which all database queries related to
+	// this DAG are going to run.
+	DatabaseContext *dbaccess.DatabaseContext
 }
 
 func (dag *BlockDAG) isKnownDelayedBlock(hash *daghash.Hash) bool {

blockdag/dag_test.go

@@ -6,9 +6,6 @@ package blockdag
 
 import (
 	"fmt"
-	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/pkg/errors"
 	"math"
 	"os"
 	"path/filepath"
@@ -16,6 +13,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/kaspanet/go-secp256k1"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
@@ -207,10 +208,10 @@ func TestIsKnownBlock(t *testing.T) {
 		{hash: dagconfig.SimnetParams.GenesisHash.String(), want: true},
 
 		// Block 3b should be present (as a second child of Block 2).
-		{hash: "48a752afbe36ad66357f751f8dee4f75665d24e18f644d83a3409b398405b46b", want: true},
+		{hash: "46314ca17e117b31b467fe1b26fd36c98ee83e750aa5e3b3c1c32870afbe5984", want: true},
 
 		// Block 100000 should be present (as an orphan).
-		{hash: "65b20b048a074793ebfd1196e49341c8d194dabfc6b44a4fd0c607406e122baf", want: true},
+		{hash: "732c891529619d43b5aeb3df42ba25dea483a8c0aded1cf585751ebabea28f29", want: true},
 
 		// Random hashes should not be available.
 		{hash: "123", want: false},
@@ -278,13 +279,13 @@ func TestCalcSequenceLock(t *testing.T) {
 	// Obtain the past median time from the PoV of the input created above.
 	// The past median time for the input is the past median time from the PoV
 	// of the block *prior* to the one that included it.
-	medianTime := node.RelativeAncestor(5).PastMedianTime(dag).Unix()
+	medianTime := node.RelativeAncestor(5).PastMedianTime(dag).UnixMilliseconds()
 
 	// The median time calculated from the PoV of the best block in the
 	// test DAG. For unconfirmed inputs, this value will be used since
 	// the MTP will be calculated from the PoV of the yet-to-be-mined
 	// block.
-	nextMedianTime := node.PastMedianTime(dag).Unix()
+	nextMedianTime := node.PastMedianTime(dag).UnixMilliseconds()
 	nextBlockBlueScore := int32(numBlocksToGenerate) + 1
 
 	// Add an additional transaction which will serve as our unconfirmed
@@ -315,35 +316,34 @@ func TestCalcSequenceLock(t *testing.T) {
 			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: wire.MaxTxInSequenceNum}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        -1,
+				Milliseconds:   -1,
 				BlockBlueScore: -1,
 			},
 		},
 		// A transaction with a single input whose lock time is
 		// expressed in seconds. However, the specified lock time is
 		// below the required floor for time based lock times since
-		// they have time granularity of 512 seconds. As a result, the
-		// seconds lock-time should be just before the median time of
+		// they have time granularity of 524288 milliseconds. As a result, the
+		// milliseconds lock-time should be just before the median time of
 		// the targeted block.
 		{
-			name:    "single input, seconds lock time below time granularity",
+			name:    "single input, milliseconds lock time below time granularity",
 			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 2)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        medianTime - 1,
+				Milliseconds:   medianTime - 1,
 				BlockBlueScore: -1,
 			},
 		},
 		// A transaction with a single input whose lock time is
-		// expressed in seconds. The number of seconds should be 1023
-		// seconds after the median past time of the last block in the
-		// chain.
+		// expressed in seconds. The number of seconds should be 1048575
+		// milliseconds after the median past time of the DAG.
 		{
-			name:    "single input, 1023 seconds after median time",
-			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1024)}}, nil),
+			name:    "single input, 1048575 milliseconds after median time",
+			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        medianTime + 1023,
+				Milliseconds:   medianTime + 1048575,
 				BlockBlueScore: -1,
 			},
 		},
@@ -358,7 +358,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			tx: wire.NewNativeMsgTx(1,
 				[]*wire.TxIn{{
 					PreviousOutpoint: utxo,
-					Sequence:         LockTimeToSequence(true, 2560),
+					Sequence:         LockTimeToSequence(true, 2621440),
 				}, {
 					PreviousOutpoint: utxo,
 					Sequence:         LockTimeToSequence(false, 4),
@@ -370,7 +370,7 @@ func TestCalcSequenceLock(t *testing.T) {
 				nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        medianTime + (5 << wire.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (5 << wire.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 3,
 			},
 		},
@@ -383,7 +383,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(false, 3)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        -1,
+				Milliseconds:   -1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 2,
 			},
 		},
@@ -394,14 +394,14 @@ func TestCalcSequenceLock(t *testing.T) {
 			name: "two inputs, lock-times in seconds",
 			tx: wire.NewNativeMsgTx(1, []*wire.TxIn{{
 				PreviousOutpoint: utxo,
-				Sequence:         LockTimeToSequence(true, 5120),
+				Sequence:         LockTimeToSequence(true, 5242880),
 			}, {
 				PreviousOutpoint: utxo,
-				Sequence:         LockTimeToSequence(true, 2560),
+				Sequence:         LockTimeToSequence(true, 2621440),
 			}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        medianTime + (10 << wire.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (10 << wire.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: -1,
 			},
 		},
@@ -422,7 +422,7 @@ func TestCalcSequenceLock(t *testing.T) {
 				nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        -1,
+				Milliseconds:   -1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 10,
 			},
 		},
@@ -434,10 +434,10 @@ func TestCalcSequenceLock(t *testing.T) {
 			tx: wire.NewNativeMsgTx(1,
 				[]*wire.TxIn{{
 					PreviousOutpoint: utxo,
-					Sequence:         LockTimeToSequence(true, 2560),
+					Sequence:         LockTimeToSequence(true, 2621440),
 				}, {
 					PreviousOutpoint: utxo,
-					Sequence:         LockTimeToSequence(true, 6656),
+					Sequence:         LockTimeToSequence(true, 6815744),
 				}, {
 					PreviousOutpoint: utxo,
 					Sequence:         LockTimeToSequence(false, 3),
@@ -448,7 +448,7 @@ func TestCalcSequenceLock(t *testing.T) {
 				nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Seconds:        medianTime + (13 << wire.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (13 << wire.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 8,
 			},
 		},
@@ -464,7 +464,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			utxoSet: utxoSet,
 			mempool: true,
 			want: &SequenceLock{
-				Seconds:        -1,
+				Milliseconds:   -1,
 				BlockBlueScore: int64(nextBlockBlueScore) + 1,
 			},
 		},
@@ -472,12 +472,12 @@ func TestCalcSequenceLock(t *testing.T) {
 		// a time based lock, so the lock time should be based off the
 		// MTP of the *next* block.
 		{
-			name:    "single input, unconfirmed, lock-time in seoncds",
-			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1024)}}, nil),
+			name:    "single input, unconfirmed, lock-time in milliseoncds",
+			tx:      wire.NewNativeMsgTx(1, []*wire.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
 			utxoSet: utxoSet,
 			mempool: true,
 			want: &SequenceLock{
-				Seconds:        nextMedianTime + 1023,
+				Milliseconds:   nextMedianTime + 1048575,
 				BlockBlueScore: -1,
 			},
 		},
@@ -491,9 +491,9 @@ func TestCalcSequenceLock(t *testing.T) {
 			t.Fatalf("test '%s', unable to calc sequence lock: %v", test.name, err)
 		}
 
-		if seqLock.Seconds != test.want.Seconds {
-			t.Fatalf("test '%s' got %v seconds want %v seconds",
-				test.name, seqLock.Seconds, test.want.Seconds)
+		if seqLock.Milliseconds != test.want.Milliseconds {
+			t.Fatalf("test '%s' got %v milliseconds want %v milliseconds",
+				test.name, seqLock.Milliseconds, test.want.Milliseconds)
 		}
 		if seqLock.BlockBlueScore != test.want.BlockBlueScore {
 			t.Fatalf("test '%s' got blue score of %v want blue score of %v ",
@@ -519,31 +519,35 @@ func TestCalcPastMedianTime(t *testing.T) {
 	}
 
 	tests := []struct {
-		blockNumber                 uint32
-		expectedSecondsSinceGenesis int64
+		blockNumber                      uint32
+		expectedMillisecondsSinceGenesis int64
 	}{
 		{
-			blockNumber:                 262,
-			expectedSecondsSinceGenesis: 130,
+			blockNumber:                      262,
+			expectedMillisecondsSinceGenesis: 130000,
 		},
 		{
-			blockNumber:                 270,
-			expectedSecondsSinceGenesis: 138,
+			blockNumber:                      270,
+			expectedMillisecondsSinceGenesis: 138000,
 		},
 		{
-			blockNumber:                 240,
-			expectedSecondsSinceGenesis: 108,
+			blockNumber:                      240,
+			expectedMillisecondsSinceGenesis: 108000,
 		},
 		{
-			blockNumber:                 5,
-			expectedSecondsSinceGenesis: 0,
+			blockNumber:                      5,
+			expectedMillisecondsSinceGenesis: 0,
 		},
 	}
 
 	for _, test := range tests {
-		secondsSinceGenesis := nodes[test.blockNumber].PastMedianTime(dag).Unix() - dag.genesis.Header().Timestamp.Unix()
-		if secondsSinceGenesis != test.expectedSecondsSinceGenesis {
-			t.Errorf("TestCalcPastMedianTime: expected past median time of block %v to be %v seconds from genesis but got %v", test.blockNumber, test.expectedSecondsSinceGenesis, secondsSinceGenesis)
+		millisecondsSinceGenesis := nodes[test.blockNumber].PastMedianTime(dag).UnixMilliseconds() -
+			dag.genesis.Header().Timestamp.UnixMilliseconds()
+
+		if millisecondsSinceGenesis != test.expectedMillisecondsSinceGenesis {
+			t.Errorf("TestCalcPastMedianTime: expected past median time of block %v to be %v milliseconds "+
+				"from genesis but got %v",
+				test.blockNumber, test.expectedMillisecondsSinceGenesis, millisecondsSinceGenesis)
 		}
 	}
 }
@@ -553,18 +557,19 @@ func TestNew(t *testing.T) {
 
 	dbPath := filepath.Join(tempDir, "TestNew")
 	_ = os.RemoveAll(dbPath)
-	err := dbaccess.Open(dbPath)
+	databaseContext, err := dbaccess.New(dbPath)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
 	defer func() {
-		dbaccess.Close()
+		databaseContext.Close()
 		os.RemoveAll(dbPath)
 	}()
 	config := &Config{
-		DAGParams:  &dagconfig.SimnetParams,
-		TimeSource: NewTimeSource(),
-		SigCache:   txscript.NewSigCache(1000),
+		DatabaseContext: databaseContext,
+		DAGParams:       &dagconfig.SimnetParams,
+		TimeSource:      NewTimeSource(),
+		SigCache:        txscript.NewSigCache(1000),
 	}
 	_, err = New(config)
 	if err != nil {
@@ -592,20 +597,21 @@ func TestAcceptingInInit(t *testing.T) {
 	// Create a test database
 	dbPath := filepath.Join(tempDir, "TestAcceptingInInit")
 	_ = os.RemoveAll(dbPath)
-	err := dbaccess.Open(dbPath)
+	databaseContext, err := dbaccess.New(dbPath)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
 	defer func() {
-		dbaccess.Close()
+		databaseContext.Close()
 		os.RemoveAll(dbPath)
 	}()
 
 	// Create a DAG to add the test block into
 	config := &Config{
-		DAGParams:  &dagconfig.SimnetParams,
-		TimeSource: NewTimeSource(),
-		SigCache:   txscript.NewSigCache(1000),
+		DatabaseContext: databaseContext,
+		DAGParams:       &dagconfig.SimnetParams,
+		TimeSource:      NewTimeSource(),
+		SigCache:        txscript.NewSigCache(1000),
 	}
 	dag, err := New(config)
 	if err != nil {
@@ -621,12 +627,15 @@ func TestAcceptingInInit(t *testing.T) {
 	testBlock := blocks[1]
 
 	// Create a test blockNode with an unvalidated status
-	genesisNode := dag.index.LookupNode(genesisBlock.Hash())
+	genesisNode, ok := dag.index.LookupNode(genesisBlock.Hash())
+	if !ok {
+		t.Fatalf("genesis block does not exist in the DAG")
+	}
 	testNode, _ := dag.newBlockNode(&testBlock.MsgBlock().Header, blockSetFromSlice(genesisNode))
 	testNode.status = statusDataStored
 
 	// Manually add the test block to the database
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := databaseContext.NewTx()
 	if err != nil {
 		t.Fatalf("Failed to open database "+
 			"transaction: %s", err)
@@ -659,7 +668,11 @@ func TestAcceptingInInit(t *testing.T) {
 	}
 
 	// Make sure that the test node's status is valid
-	testNode = dag.index.LookupNode(testBlock.Hash())
+	testNode, ok = dag.index.LookupNode(testBlock.Hash())
+	if !ok {
+		t.Fatalf("block %s does not exist in the DAG", testBlock.Hash())
+	}
+
 	if testNode.status&statusValid == 0 {
 		t.Fatalf("testNode is unexpectedly invalid")
 	}
@@ -689,7 +702,7 @@ func TestConfirmations(t *testing.T) {
 
 	// Add a chain of blocks
 	chainBlocks := make([]*wire.MsgBlock, 5)
-	chainBlocks[0] = dag.dagParams.GenesisBlock
+	chainBlocks[0] = dag.Params.GenesisBlock
 	for i := uint32(1); i < 5; i++ {
 		chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
 	}
@@ -798,7 +811,7 @@ func TestAcceptingBlock(t *testing.T) {
 
 	numChainBlocks := uint32(10)
 	chainBlocks := make([]*wire.MsgBlock, numChainBlocks)
-	chainBlocks[0] = dag.dagParams.GenesisBlock
+	chainBlocks[0] = dag.Params.GenesisBlock
 	for i := uint32(1); i <= numChainBlocks-1; i++ {
 		chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
 	}
@@ -914,7 +927,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {
 	blockTime := dag.genesis.Header().Timestamp
 
 	flushUTXODiffStore := func() {
-		dbTx, err := dbaccess.NewTx()
+		dbTx, err := dag.databaseContext.NewTx()
 		if err != nil {
 			t.Fatalf("Failed to open database transaction: %s", err)
 		}
@@ -944,7 +957,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {
 		flushUTXODiffStore()
 		return node
 	}
-	finalityInterval := dag.dagParams.FinalityInterval
+	finalityInterval := dag.FinalityInterval()
 	nodes := make([]*blockNode, 0, finalityInterval)
 	currentNode := dag.genesis
 	nodes = append(nodes, currentNode)
@@ -1045,8 +1058,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 			"is an orphan\n")
 	}
 
-	invalidBlockNode := dag.index.LookupNode(invalidBlock.Hash())
-	if invalidBlockNode == nil {
+	invalidBlockNode, ok := dag.index.LookupNode(invalidBlock.Hash())
+	if !ok {
 		t.Fatalf("invalidBlockNode wasn't added to the block index as expected")
 	}
 	if invalidBlockNode.status&statusValidateFailed != statusValidateFailed {
@@ -1074,8 +1087,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 		t.Fatalf("ProcessBlock incorrectly returned invalidBlockChild " +
 			"is an orphan\n")
 	}
-	invalidBlockChildNode := dag.index.LookupNode(invalidBlockChild.Hash())
-	if invalidBlockChildNode == nil {
+	invalidBlockChildNode, ok := dag.index.LookupNode(invalidBlockChild.Hash())
+	if !ok {
 		t.Fatalf("invalidBlockChild wasn't added to the block index as expected")
 	}
 	if invalidBlockChildNode.status&statusInvalidAncestor != statusInvalidAncestor {
@@ -1102,8 +1115,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 		t.Fatalf("ProcessBlock incorrectly returned invalidBlockGrandChild " +
 			"is an orphan\n")
 	}
-	invalidBlockGrandChildNode := dag.index.LookupNode(invalidBlockGrandChild.Hash())
-	if invalidBlockGrandChildNode == nil {
+	invalidBlockGrandChildNode, ok := dag.index.LookupNode(invalidBlockGrandChild.Hash())
+	if !ok {
 		t.Fatalf("invalidBlockGrandChild wasn't added to the block index as expected")
 	}
 	if invalidBlockGrandChildNode.status&statusInvalidAncestor != statusInvalidAncestor {
@@ -1120,7 +1133,7 @@ func TestIsDAGCurrentMaxDiff(t *testing.T) {
 		&dagconfig.SimnetParams,
 	}
 	for _, params := range netParams {
-		if params.TargetTimePerBlock*time.Duration(params.FinalityInterval) < isDAGCurrentMaxDiff {
+		if params.FinalityDuration < isDAGCurrentMaxDiff*params.TargetTimePerBlock {
 			t.Errorf("in %s, a DAG can be considered current even if it's below the finality point", params.Name)
 		}
 	}
@@ -1257,7 +1270,7 @@ func TestDoubleSpends(t *testing.T) {
 
 func TestUTXOCommitment(t *testing.T) {
 	// Create a new database and dag instance to run tests against.
-	params := dagconfig.DevnetParams
+	params := dagconfig.SimnetParams
 	params.BlockCoinbaseMaturity = 0
 	dag, teardownFunc, err := DAGSetup("TestUTXOCommitment", true, Config{
 		DAGParams: &params,
@@ -1312,8 +1325,8 @@ func TestUTXOCommitment(t *testing.T) {
 	blockD := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockB.BlockHash(), blockC.BlockHash()}, blockDTxs)
 
 	// Get the pastUTXO of blockD
-	blockNodeD := dag.index.LookupNode(blockD.BlockHash())
-	if blockNodeD == nil {
+	blockNodeD, ok := dag.index.LookupNode(blockD.BlockHash())
+	if !ok {
 		t.Fatalf("TestUTXOCommitment: blockNode for block D not found")
 	}
 	blockDPastUTXO, _, _, _ := dag.pastUTXO(blockNodeD)
@@ -1372,8 +1385,8 @@ func TestPastUTXOMultiSet(t *testing.T) {
 	blockC := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockB.BlockHash()}, nil)
 
 	// Take blockC's selectedParentMultiset
-	blockNodeC := dag.index.LookupNode(blockC.BlockHash())
-	if blockNodeC == nil {
+	blockNodeC, ok := dag.index.LookupNode(blockC.BlockHash())
+	if !ok {
 		t.Fatalf("TestPastUTXOMultiSet: blockNode for blockC not found")
 	}
 	blockCSelectedParentMultiset, err := blockNodeC.selectedParentMultiset(dag)

blockdag/dagio.go

@@ -28,19 +28,19 @@ var (
 	byteOrder = binary.LittleEndian
 )
 
-// errNotInDAG signifies that a block hash or height that is not in the
+// ErrNotInDAG signifies that a block hash that is not in the
 // DAG was requested.
-type errNotInDAG string
+type ErrNotInDAG string
 
 // Error implements the error interface.
-func (e errNotInDAG) Error() string {
+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 {
-	var notInDAGErr errNotInDAG
+// IsNotInDAGErr returns whether or not the passed error is an
+// ErrNotInDAG error.
+func IsNotInDAGErr(err error) bool {
+	var notInDAGErr ErrNotInDAG
 	return errors.As(err, &notInDAGErr)
 }
 
@@ -164,9 +164,9 @@ func saveDAGState(dbContext dbaccess.Context, state *dagState) error {
 // createDAGState initializes the DAG state to the
 // genesis block and the node's local subnetwork id.
 func (dag *BlockDAG) createDAGState(localSubnetworkID *subnetworkid.SubnetworkID) error {
-	return saveDAGState(dbaccess.NoTx(), &dagState{
-		TipHashes:         []*daghash.Hash{dag.dagParams.GenesisHash},
-		LastFinalityPoint: dag.dagParams.GenesisHash,
+	return saveDAGState(dag.databaseContext, &dagState{
+		TipHashes:         []*daghash.Hash{dag.Params.GenesisHash},
+		LastFinalityPoint: dag.Params.GenesisHash,
 		LocalSubnetworkID: localSubnetworkID,
 	})
 }
@@ -177,7 +177,7 @@ func (dag *BlockDAG) createDAGState(localSubnetworkID *subnetworkid.SubnetworkID
 func (dag *BlockDAG) initDAGState() error {
 	// Fetch the stored DAG state from the database. If it doesn't exist,
 	// it means that kaspad is running for the first time.
-	serializedDAGState, err := dbaccess.FetchDAGState(dbaccess.NoTx())
+	serializedDAGState, err := dbaccess.FetchDAGState(dag.databaseContext)
 	if dbaccess.IsNotFoundError(err) {
 		// Initialize the database and the DAG state to the genesis block.
 		return dag.createDAGState(dag.subnetworkID)
@@ -209,13 +209,13 @@ func (dag *BlockDAG) initDAGState() error {
 	}
 
 	log.Debugf("Loading reachability data...")
-	err = dag.reachabilityStore.init(dbaccess.NoTx())
+	err = dag.reachabilityTree.init(dag.databaseContext)
 	if err != nil {
 		return err
 	}
 
 	log.Debugf("Loading multiset data...")
-	err = dag.multisetStore.init(dbaccess.NoTx())
+	err = dag.multisetStore.init(dag.databaseContext)
 	if err != nil {
 		return err
 	}
@@ -233,7 +233,12 @@ func (dag *BlockDAG) initDAGState() error {
 	}
 
 	log.Debugf("Setting the last finality point...")
-	dag.lastFinalityPoint = dag.index.LookupNode(dagState.LastFinalityPoint)
+	var ok bool
+	dag.lastFinalityPoint, ok = dag.index.LookupNode(dagState.LastFinalityPoint)
+	if !ok {
+		return errors.Errorf("finality point block %s "+
+			"does not exist in the DAG", dagState.LastFinalityPoint)
+	}
 	dag.finalizeNodesBelowFinalityPoint(false)
 
 	log.Debugf("Processing unprocessed blockNodes...")
@@ -258,7 +263,7 @@ func (dag *BlockDAG) validateLocalSubnetworkID(state *dagState) error {
 }
 
 func (dag *BlockDAG) initBlockIndex() (unprocessedBlockNodes []*blockNode, err error) {
-	blockIndexCursor, err := dbaccess.BlockIndexCursor(dbaccess.NoTx())
+	blockIndexCursor, err := dbaccess.BlockIndexCursor(dag.databaseContext)
 	if err != nil {
 		return nil, err
 	}
@@ -288,7 +293,7 @@ func (dag *BlockDAG) initBlockIndex() (unprocessedBlockNodes []*blockNode, err e
 		}
 
 		if dag.blockCount == 0 {
-			if !node.hash.IsEqual(dag.dagParams.GenesisHash) {
+			if !node.hash.IsEqual(dag.Params.GenesisHash) {
 				return nil, errors.Errorf("Expected "+
 					"first entry in block index to be genesis block, "+
 					"found %s", node.hash)
@@ -312,7 +317,7 @@ func (dag *BlockDAG) initBlockIndex() (unprocessedBlockNodes []*blockNode, err e
 
 func (dag *BlockDAG) initUTXOSet() (fullUTXOCollection utxoCollection, err error) {
 	fullUTXOCollection = make(utxoCollection)
-	cursor, err := dbaccess.UTXOSetCursor(dbaccess.NoTx())
+	cursor, err := dbaccess.UTXOSetCursor(dag.databaseContext)
 	if err != nil {
 		return nil, err
 	}
@@ -348,8 +353,8 @@ func (dag *BlockDAG) initUTXOSet() (fullUTXOCollection utxoCollection, err error
 func (dag *BlockDAG) initVirtualBlockTips(state *dagState) error {
 	tips := newBlockSet()
 	for _, tipHash := range state.TipHashes {
-		tip := dag.index.LookupNode(tipHash)
-		if tip == nil {
+		tip, ok := dag.index.LookupNode(tipHash)
+		if !ok {
 			return errors.Errorf("cannot find "+
 				"DAG tip %s in block index", state.TipHashes)
 		}
@@ -363,7 +368,7 @@ func (dag *BlockDAG) processUnprocessedBlockNodes(unprocessedBlockNodes []*block
 	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 := dbaccess.HasBlock(dbaccess.NoTx(), node.hash)
+		blockExists, err := dbaccess.HasBlock(dag.databaseContext, node.hash)
 		if err != nil {
 			return errors.Wrapf(err, "HasBlock "+
 				"for block %s failed: %s", node.hash, err)
@@ -374,7 +379,7 @@ func (dag *BlockDAG) processUnprocessedBlockNodes(unprocessedBlockNodes []*block
 		}
 
 		// Attempt to accept the block.
-		block, err := fetchBlockByHash(dbaccess.NoTx(), node.hash)
+		block, err := dag.fetchBlockByHash(node.hash)
 		if err != nil {
 			return err
 		}
@@ -416,7 +421,7 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		version:              header.Version,
 		bits:                 header.Bits,
 		nonce:                header.Nonce,
-		timestamp:            header.Timestamp.Unix(),
+		timestamp:            header.Timestamp.UnixMilliseconds(),
 		hashMerkleRoot:       header.HashMerkleRoot,
 		acceptedIDMerkleRoot: header.AcceptedIDMerkleRoot,
 		utxoCommitment:       header.UTXOCommitment,
@@ -426,8 +431,8 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 	node.parents = newBlockSet()
 
 	for _, hash := range header.ParentHashes {
-		parent := dag.index.LookupNode(hash)
-		if parent == nil {
+		parent, ok := dag.index.LookupNode(hash)
+		if !ok {
 			return nil, errors.Errorf("deserializeBlockNode: Could "+
 				"not find parent %s for block %s", hash, header.BlockHash())
 		}
@@ -447,7 +452,11 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 
 	// Because genesis doesn't have selected parent, it's serialized as zero hash
 	if !selectedParentHash.IsEqual(&daghash.ZeroHash) {
-		node.selectedParent = dag.index.LookupNode(selectedParentHash)
+		var ok bool
+		node.selectedParent, ok = dag.index.LookupNode(selectedParentHash)
+		if !ok {
+			return nil, errors.Errorf("block %s does not exist in the DAG", selectedParentHash)
+		}
 	}
 
 	node.blueScore, err = binaryserializer.Uint64(buffer, byteOrder)
@@ -466,7 +475,12 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		if _, err := io.ReadFull(buffer, hash[:]); err != nil {
 			return nil, err
 		}
-		node.blues[i] = dag.index.LookupNode(hash)
+
+		var ok bool
+		node.blues[i], ok = dag.index.LookupNode(hash)
+		if !ok {
+			return nil, errors.Errorf("block %s does not exist in the DAG", selectedParentHash)
+		}
 	}
 
 	bluesAnticoneSizesLen, err := wire.ReadVarInt(buffer)
@@ -484,8 +498,8 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		if err != nil {
 			return nil, err
 		}
-		blue := dag.index.LookupNode(hash)
-		if blue == nil {
+		blue, ok := dag.index.LookupNode(hash)
+		if !ok {
 			return nil, errors.Errorf("couldn't find block with hash %s", hash)
 		}
 		node.bluesAnticoneSizes[blue] = dagconfig.KType(bluesAnticoneSize)
@@ -496,8 +510,8 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 
 // fetchBlockByHash retrieves the raw block for the provided hash,
 // deserializes it, and returns a util.Block of it.
-func fetchBlockByHash(dbContext dbaccess.Context, hash *daghash.Hash) (*util.Block, error) {
-	blockBytes, err := dbaccess.FetchBlock(dbContext, hash)
+func (dag *BlockDAG) fetchBlockByHash(hash *daghash.Hash) (*util.Block, error) {
+	blockBytes, err := dbaccess.FetchBlock(dag.databaseContext, hash)
 	if err != nil {
 		return nil, err
 	}
@@ -590,13 +604,13 @@ func blockHashFromBlockIndexKey(BlockIndexKey []byte) (*daghash.Hash, error) {
 // 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 {
+	node, ok := dag.index.LookupNode(hash)
+	if !ok {
 		str := fmt.Sprintf("block %s is not in the DAG", hash)
-		return nil, errNotInDAG(str)
+		return nil, ErrNotInDAG(str)
 	}
 
-	block, err := fetchBlockByHash(dbaccess.NoTx(), node.hash)
+	block, err := dag.fetchBlockByHash(node.hash)
 	if err != nil {
 		return nil, err
 	}
@@ -625,7 +639,7 @@ func (dag *BlockDAG) BlockHashesFrom(lowHash *daghash.Hash, limit int) ([]*dagha
 	}
 
 	key := blockIndexKey(lowHash, blueScore)
-	cursor, err := dbaccess.BlockIndexCursorFrom(dbaccess.NoTx(), key)
+	cursor, err := dbaccess.BlockIndexCursorFrom(dag.databaseContext, key)
 	if dbaccess.IsNotFoundError(err) {
 		return nil, errors.Wrapf(err, "block %s not in block index", lowHash)
 	}

blockdag/dagio_test.go

@@ -14,25 +14,25 @@ import (
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
-// TestErrNotInDAG ensures the functions related to errNotInDAG work
+// TestErrNotInDAG ensures the functions related to ErrNotInDAG work
 // as expected.
 func TestErrNotInDAG(t *testing.T) {
 	errStr := "no block at height 1 exists"
-	err := error(errNotInDAG(errStr))
+	err := error(ErrNotInDAG(errStr))
 
 	// Ensure the stringized output for the error is as expected.
 	if err.Error() != errStr {
-		t.Fatalf("errNotInDAG retuned unexpected error string - "+
+		t.Fatalf("ErrNotInDAG retuned unexpected error string - "+
 			"got %q, want %q", err.Error(), errStr)
 	}
 
 	// Ensure error is detected as the correct type.
-	if !isNotInDAGErr(err) {
-		t.Fatalf("isNotInDAGErr did not detect as expected type")
+	if !IsNotInDAGErr(err) {
+		t.Fatalf("IsNotInDAGErr did not detect as expected type")
 	}
 	err = errors.New("something else")
-	if isNotInDAGErr(err) {
-		t.Fatalf("isNotInDAGErr detected incorrect type")
+	if IsNotInDAGErr(err) {
+		t.Fatalf("IsNotInDAGErr detected incorrect type")
 	}
 }
 

blockdag/difficulty.go

@@ -6,14 +6,14 @@ package blockdag
 
 import (
 	"github.com/kaspanet/kaspad/util/bigintpool"
-	"time"
+	"github.com/kaspanet/kaspad/util/mstime"
 
 	"github.com/kaspanet/kaspad/util"
 )
 
 // requiredDifficulty calculates the required difficulty for a
 // block given its bluest parent.
-func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime time.Time) uint32 {
+func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime mstime.Time) uint32 {
 	// Genesis block.
 	if bluestParent == nil || bluestParent.blueScore < dag.difficultyAdjustmentWindowSize+1 {
 		return dag.powMaxBits
@@ -34,7 +34,7 @@ func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime ti
 	defer bigintpool.Release(newTarget)
 	windowTimeStampDifference := bigintpool.Acquire(windowMaxTimeStamp - windowMinTimestamp)
 	defer bigintpool.Release(windowTimeStampDifference)
-	targetTimePerBlock := bigintpool.Acquire(dag.targetTimePerBlock)
+	targetTimePerBlock := bigintpool.Acquire(dag.Params.TargetTimePerBlock.Milliseconds())
 	defer bigintpool.Release(targetTimePerBlock)
 	difficultyAdjustmentWindowSize := bigintpool.Acquire(int64(dag.difficultyAdjustmentWindowSize))
 	defer bigintpool.Release(difficultyAdjustmentWindowSize)
@@ -44,7 +44,7 @@ func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime ti
 		Mul(newTarget, windowTimeStampDifference).
 		Div(newTarget, targetTimePerBlock).
 		Div(newTarget, difficultyAdjustmentWindowSize)
-	if newTarget.Cmp(dag.dagParams.PowMax) > 0 {
+	if newTarget.Cmp(dag.Params.PowMax) > 0 {
 		return dag.powMaxBits
 	}
 	newTargetBits := util.BigToCompact(newTarget)
@@ -55,7 +55,7 @@ func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime ti
 // be built on top of the current tips.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) NextRequiredDifficulty(timestamp time.Time) uint32 {
+func (dag *BlockDAG) NextRequiredDifficulty(timestamp mstime.Time) uint32 {
 	difficulty := dag.requiredDifficulty(dag.virtual.parents.bluest(), timestamp)
 	return difficulty
 }

blockdag/difficulty_test.go

@@ -6,6 +6,7 @@ package blockdag
 
 import (
 	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"math/big"
 	"testing"
 	"time"
@@ -90,11 +91,11 @@ func TestDifficulty(t *testing.T) {
 	}
 	defer teardownFunc()
 
-	zeroTime := time.Unix(0, 0)
-	addNode := func(parents blockSet, blockTime time.Time) *blockNode {
+	zeroTime := mstime.Time{}
+	addNode := func(parents blockSet, blockTime mstime.Time) *blockNode {
 		bluestParent := parents.bluest()
-		if blockTime == zeroTime {
-			blockTime = time.Unix(bluestParent.timestamp, 0)
+		if blockTime.IsZero() {
+			blockTime = bluestParent.time()
 			blockTime = blockTime.Add(params.TargetTimePerBlock)
 		}
 		block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
@@ -114,7 +115,11 @@ func TestDifficulty(t *testing.T) {
 		if isOrphan {
 			t.Fatalf("block was unexpectedly orphan")
 		}
-		return dag.index.LookupNode(block.BlockHash())
+		node, ok := dag.index.LookupNode(block.BlockHash())
+		if !ok {
+			t.Fatalf("block %s does not exist in the DAG", block.BlockHash())
+		}
+		return node
 	}
 	tip := dag.genesis
 	for i := uint64(0); i < dag.difficultyAdjustmentWindowSize; i++ {
@@ -170,7 +175,7 @@ func TestDifficulty(t *testing.T) {
 			sameBitsCount = 0
 		}
 	}
-	slowBlockTime := time.Unix(tip.timestamp, 0)
+	slowBlockTime := tip.time()
 	slowBlockTime = slowBlockTime.Add(params.TargetTimePerBlock + time.Second)
 	slowNode := addNode(blockSetFromSlice(tip), slowBlockTime)
 	if slowNode.bits != tip.bits {

blockdag/error.go

@@ -28,11 +28,6 @@ const (
 	// to a newer version.
 	ErrBlockVersionTooOld
 
-	// ErrInvalidTime indicates the time in the passed block has a precision
-	// that is more than one second. The DAG consensus rules require
-	// timestamps to have a maximum precision of one second.
-	ErrInvalidTime
-
 	// ErrTimeTooOld indicates the time is either before the median time of
 	// the last several blocks per the DAG consensus rules.
 	ErrTimeTooOld
@@ -69,6 +64,9 @@ const (
 	// the expected value.
 	ErrBadUTXOCommitment
 
+	// ErrInvalidSubnetwork indicates the subnetwork is now allowed.
+	ErrInvalidSubnetwork
+
 	// ErrFinalityPointTimeTooOld indicates a block has a timestamp before the
 	// last finality point.
 	ErrFinalityPointTimeTooOld
@@ -208,6 +206,10 @@ const (
 	// ErrDelayedBlockIsNotAllowed indicates that a block with a delayed timestamp was
 	// submitted with BFDisallowDelay flag raised.
 	ErrDelayedBlockIsNotAllowed
+
+	// ErrOrphanBlockIsNotAllowed indicates that an orphan block was submitted with
+	// BFDisallowOrphans flag raised.
+	ErrOrphanBlockIsNotAllowed
 )
 
 // Map of ErrorCode values back to their constant names for pretty printing.
@@ -215,7 +217,6 @@ var errorCodeStrings = map[ErrorCode]string{
 	ErrDuplicateBlock:            "ErrDuplicateBlock",
 	ErrBlockMassTooHigh:          "ErrBlockMassTooHigh",
 	ErrBlockVersionTooOld:        "ErrBlockVersionTooOld",
-	ErrInvalidTime:               "ErrInvalidTime",
 	ErrTimeTooOld:                "ErrTimeTooOld",
 	ErrTimeTooNew:                "ErrTimeTooNew",
 	ErrNoParents:                 "ErrNoParents",
@@ -257,6 +258,7 @@ var errorCodeStrings = map[ErrorCode]string{
 	ErrInvalidPayloadHash:        "ErrInvalidPayloadHash",
 	ErrInvalidParentsRelation:    "ErrInvalidParentsRelation",
 	ErrDelayedBlockIsNotAllowed:  "ErrDelayedBlockIsNotAllowed",
+	ErrOrphanBlockIsNotAllowed:   "ErrOrphanBlockIsNotAllowed",
 }
 
 // String returns the ErrorCode as a human-readable name.

blockdag/error_test.go

@@ -17,7 +17,6 @@ func TestErrorCodeStringer(t *testing.T) {
 		{ErrDuplicateBlock, "ErrDuplicateBlock"},
 		{ErrBlockMassTooHigh, "ErrBlockMassTooHigh"},
 		{ErrBlockVersionTooOld, "ErrBlockVersionTooOld"},
-		{ErrInvalidTime, "ErrInvalidTime"},
 		{ErrTimeTooOld, "ErrTimeTooOld"},
 		{ErrTimeTooNew, "ErrTimeTooNew"},
 		{ErrNoParents, "ErrNoParents"},
@@ -58,6 +57,7 @@ func TestErrorCodeStringer(t *testing.T) {
 		{ErrInvalidPayloadHash, "ErrInvalidPayloadHash"},
 		{ErrInvalidParentsRelation, "ErrInvalidParentsRelation"},
 		{ErrDelayedBlockIsNotAllowed, "ErrDelayedBlockIsNotAllowed"},
+		{ErrOrphanBlockIsNotAllowed, "ErrOrphanBlockIsNotAllowed"},
 		{0xffff, "Unknown ErrorCode (65535)"},
 	}
 

blockdag/external_dag_test.go

@@ -2,11 +2,12 @@ package blockdag_test
 
 import (
 	"fmt"
-	"github.com/pkg/errors"
 	"math"
 	"strings"
 	"testing"
 
+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -40,7 +41,7 @@ import (
 func TestFinality(t *testing.T) {
 	params := dagconfig.SimnetParams
 	params.K = 1
-	params.FinalityInterval = 100
+	params.FinalityDuration = 100 * params.TargetTimePerBlock
 	dag, teardownFunc, err := blockdag.DAGSetup("TestFinality", true, blockdag.Config{
 		DAGParams: &params,
 	})
@@ -49,7 +50,7 @@ func TestFinality(t *testing.T) {
 	}
 	defer teardownFunc()
 	buildNodeToDag := func(parentHashes []*daghash.Hash) (*util.Block, error) {
-		msgBlock, err := mining.PrepareBlockForTest(dag, &params, parentHashes, nil, false)
+		msgBlock, err := mining.PrepareBlockForTest(dag, parentHashes, nil, false)
 		if err != nil {
 			return nil, err
 		}
@@ -74,7 +75,7 @@ func TestFinality(t *testing.T) {
 	currentNode := genesis
 
 	// First we build a chain of params.FinalityInterval blocks for future use
-	for i := uint64(0); i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < dag.FinalityInterval(); i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -86,7 +87,7 @@ func TestFinality(t *testing.T) {
 	// Now we build a new chain of 2 * params.FinalityInterval blocks, pointed to genesis, and
 	// we expect the block with height 1 * params.FinalityInterval to be the last finality point
 	currentNode = genesis
-	for i := uint64(0); i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < dag.FinalityInterval(); i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -95,7 +96,7 @@ func TestFinality(t *testing.T) {
 
 	expectedFinalityPoint := currentNode
 
-	for i := uint64(0); i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < dag.FinalityInterval(); i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -175,9 +176,19 @@ func TestFinalityInterval(t *testing.T) {
 		&dagconfig.SimnetParams,
 	}
 	for _, params := range netParams {
-		if params.FinalityInterval > wire.MaxInvPerMsg {
-			t.Errorf("FinalityInterval in %s should be lower or equal to wire.MaxInvPerMsg", params.Name)
-		}
+		func() {
+			dag, teardownFunc, err := blockdag.DAGSetup("TestFinalityInterval", true, blockdag.Config{
+				DAGParams: params,
+			})
+			if err != nil {
+				t.Fatalf("Failed to setup dag instance for %s: %v", params.Name, err)
+			}
+			defer teardownFunc()
+
+			if dag.FinalityInterval() > wire.MaxInvPerMsg {
+				t.Errorf("FinalityInterval in %s should be lower or equal to wire.MaxInvPerMsg", params.Name)
+			}
+		}()
 	}
 }
 
@@ -186,6 +197,7 @@ func TestSubnetworkRegistry(t *testing.T) {
 	params := dagconfig.SimnetParams
 	params.K = 1
 	params.BlockCoinbaseMaturity = 0
+	params.EnableNonNativeSubnetworks = true
 	dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", true, blockdag.Config{
 		DAGParams: &params,
 	})
@@ -199,7 +211,7 @@ func TestSubnetworkRegistry(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not register network: %s", err)
 	}
-	limit, err := blockdag.GasLimit(subnetworkID)
+	limit, err := dag.GasLimit(subnetworkID)
 	if err != nil {
 		t.Fatalf("could not retrieve gas limit: %s", err)
 	}
@@ -220,7 +232,7 @@ func TestChainedTransactions(t *testing.T) {
 	}
 	defer teardownFunc()
 
-	block1, err := mining.PrepareBlockForTest(dag, &params, []*daghash.Hash{params.GenesisHash}, nil, false)
+	block1, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{params.GenesisHash}, nil, false)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -268,7 +280,7 @@ func TestChainedTransactions(t *testing.T) {
 	}
 	chainedTx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{chainedTxIn}, []*wire.TxOut{chainedTxOut})
 
-	block2, err := mining.PrepareBlockForTest(dag, &params, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{tx}, false)
+	block2, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{tx}, false)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -314,7 +326,7 @@ func TestChainedTransactions(t *testing.T) {
 	}
 	nonChainedTx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{nonChainedTxIn}, []*wire.TxOut{nonChainedTxOut})
 
-	block3, err := mining.PrepareBlockForTest(dag, &params, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{nonChainedTx}, false)
+	block3, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{nonChainedTx}, false)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -371,7 +383,7 @@ func TestOrderInDiffFromAcceptanceData(t *testing.T) {
 		}
 
 		// Create the block
-		msgBlock, err := mining.PrepareBlockForTest(dag, &params, []*daghash.Hash{previousBlock.Hash()}, txs, false)
+		msgBlock, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{previousBlock.Hash()}, txs, false)
 		if err != nil {
 			t.Fatalf("TestOrderInDiffFromAcceptanceData: Failed to prepare block: %s", err)
 		}
@@ -410,6 +422,7 @@ func TestGasLimit(t *testing.T) {
 	params := dagconfig.SimnetParams
 	params.K = 1
 	params.BlockCoinbaseMaturity = 0
+	params.EnableNonNativeSubnetworks = true
 	dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", true, blockdag.Config{
 		DAGParams: &params,
 	})
@@ -427,7 +440,7 @@ func TestGasLimit(t *testing.T) {
 
 	cbTxs := []*wire.MsgTx{}
 	for i := 0; i < 4; i++ {
-		fundsBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), nil, false)
+		fundsBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), nil, false)
 		if err != nil {
 			t.Fatalf("PrepareBlockForTest: %v", err)
 		}
@@ -479,7 +492,7 @@ func TestGasLimit(t *testing.T) {
 	tx2 := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{tx2In}, []*wire.TxOut{tx2Out}, subnetworkID, 10000, []byte{})
 
 	// Here we check that we can't process a block that has transactions that exceed the gas limit
-	overLimitBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), []*wire.MsgTx{tx1, tx2}, true)
+	overLimitBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1, tx2}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -514,7 +527,7 @@ func TestGasLimit(t *testing.T) {
 		subnetworkID, math.MaxUint64, []byte{})
 
 	// Here we check that we can't process a block that its transactions' gas overflows uint64
-	overflowGasBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), []*wire.MsgTx{tx1, overflowGasTx}, true)
+	overflowGasBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1, overflowGasTx}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -548,7 +561,7 @@ func TestGasLimit(t *testing.T) {
 	nonExistentSubnetworkTx := wire.NewSubnetworkMsgTx(wire.TxVersion, []*wire.TxIn{nonExistentSubnetworkTxIn},
 		[]*wire.TxOut{nonExistentSubnetworkTxOut}, nonExistentSubnetwork, 1, []byte{})
 
-	nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), []*wire.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
+	nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -569,7 +582,7 @@ func TestGasLimit(t *testing.T) {
 	}
 
 	// Here we check that we can process a block with a transaction that doesn't exceed the gas limit
-	validBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), []*wire.MsgTx{tx1}, true)
+	validBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*wire.MsgTx{tx1}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}

blockdag/ghostdag.go

@@ -57,7 +57,7 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo
 			// newNode is always in the future of blueCandidate, so there's
 			// no point in checking it.
 			if chainBlock != newNode {
-				if isAncestorOfBlueCandidate, err := dag.isAncestorOf(chainBlock, blueCandidate); err != nil {
+				if isAncestorOfBlueCandidate, err := dag.isInPast(chainBlock, blueCandidate); err != nil {
 					return nil, err
 				} else if isAncestorOfBlueCandidate {
 					break
@@ -66,7 +66,7 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo
 
 			for _, block := range chainBlock.blues {
 				// Skip blocks that exist in the past of blueCandidate.
-				if isAncestorOfBlueCandidate, err := dag.isAncestorOf(block, blueCandidate); err != nil {
+				if isAncestorOfBlueCandidate, err := dag.isInPast(block, blueCandidate); err != nil {
 					return nil, err
 				} else if isAncestorOfBlueCandidate {
 					continue
@@ -78,13 +78,13 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo
 				}
 				candidateAnticoneSize++
 
-				if candidateAnticoneSize > dag.dagParams.K {
+				if candidateAnticoneSize > dag.Params.K {
 					// k-cluster violation: The candidate's blue anticone exceeded k
 					possiblyBlue = false
 					break
 				}
 
-				if candidateBluesAnticoneSizes[block] == dag.dagParams.K {
+				if candidateBluesAnticoneSizes[block] == dag.Params.K {
 					// k-cluster violation: A block in candidate's blue anticone already
 					// has k blue blocks in its own anticone
 					possiblyBlue = false
@@ -93,7 +93,7 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo
 
 				// This is a sanity check that validates that a blue
 				// block's blue anticone is not already larger than K.
-				if candidateBluesAnticoneSizes[block] > dag.dagParams.K {
+				if candidateBluesAnticoneSizes[block] > dag.Params.K {
 					return nil, errors.New("found blue anticone size larger than k")
 				}
 			}
@@ -109,7 +109,7 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo
 
 			// The maximum length of node.blues can be K+1 because
 			// it contains the selected parent.
-			if dagconfig.KType(len(newNode.blues)) == dag.dagParams.K+1 {
+			if dagconfig.KType(len(newNode.blues)) == dag.Params.K+1 {
 				break
 			}
 		}
@@ -148,7 +148,7 @@ func (dag *BlockDAG) selectedParentAnticone(node *blockNode) ([]*blockNode, erro
 			if anticoneSet.contains(parent) || selectedParentPast.contains(parent) {
 				continue
 			}
-			isAncestorOfSelectedParent, err := dag.isAncestorOf(parent, node.selectedParent)
+			isAncestorOfSelectedParent, err := dag.isInPast(parent, node.selectedParent)
 			if err != nil {
 				return nil, err
 			}

blockdag/ghostdag_test.go

@@ -2,14 +2,15 @@ package blockdag
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"reflect"
 	"sort"
 	"strings"
 	"testing"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 type testBlockData struct {
@@ -33,7 +34,7 @@ func TestGHOSTDAG(t *testing.T) {
 	}{
 		{
 			k:            3,
-			expectedReds: []string{"F", "G", "H", "I", "N", "O"},
+			expectedReds: []string{"F", "G", "H", "I", "N", "P"},
 			dagData: []*testBlockData{
 				{
 					parents:                []string{"A"},
@@ -166,7 +167,7 @@ func TestGHOSTDAG(t *testing.T) {
 					id:                     "T",
 					expectedScore:          13,
 					expectedSelectedParent: "S",
-					expectedBlues:          []string{"S", "P", "Q"},
+					expectedBlues:          []string{"S", "O", "Q"},
 				},
 			},
 		},
@@ -215,7 +216,10 @@ func TestGHOSTDAG(t *testing.T) {
 					t.Fatalf("TestGHOSTDAG: block %v was unexpectedly orphan", blockData.id)
 				}
 
-				node := dag.index.LookupNode(utilBlock.Hash())
+				node, ok := dag.index.LookupNode(utilBlock.Hash())
+				if !ok {
+					t.Fatalf("block %s does not exist in the DAG", utilBlock.Hash())
+				}
 
 				blockByIDMap[blockData.id] = node
 				idByBlockMap[node] = blockData.id
@@ -291,22 +295,29 @@ func TestBlueAnticoneSizeErrors(t *testing.T) {
 	defer teardownFunc()
 
 	// Prepare a block chain with size K beginning with the genesis block
-	currentBlockA := dag.dagParams.GenesisBlock
-	for i := dagconfig.KType(0); i < dag.dagParams.K; i++ {
+	currentBlockA := dag.Params.GenesisBlock
+	for i := dagconfig.KType(0); i < dag.Params.K; i++ {
 		newBlock := prepareAndProcessBlockByParentMsgBlocks(t, dag, currentBlockA)
 		currentBlockA = newBlock
 	}
 
 	// Prepare another block chain with size K beginning with the genesis block
-	currentBlockB := dag.dagParams.GenesisBlock
-	for i := dagconfig.KType(0); i < dag.dagParams.K; i++ {
+	currentBlockB := dag.Params.GenesisBlock
+	for i := dagconfig.KType(0); i < dag.Params.K; i++ {
 		newBlock := prepareAndProcessBlockByParentMsgBlocks(t, dag, currentBlockB)
 		currentBlockB = newBlock
 	}
 
 	// Get references to the tips of the two chains
-	blockNodeA := dag.index.LookupNode(currentBlockA.BlockHash())
-	blockNodeB := dag.index.LookupNode(currentBlockB.BlockHash())
+	blockNodeA, ok := dag.index.LookupNode(currentBlockA.BlockHash())
+	if !ok {
+		t.Fatalf("block %s does not exist in the DAG", currentBlockA.BlockHash())
+	}
+
+	blockNodeB, ok := dag.index.LookupNode(currentBlockB.BlockHash())
+	if !ok {
+		t.Fatalf("block %s does not exist in the DAG", currentBlockB.BlockHash())
+	}
 
 	// Try getting the blueAnticoneSize between them. Since the two
 	// blocks are not in the anticones of eachother, this should fail.
@@ -332,16 +343,16 @@ func TestGHOSTDAGErrors(t *testing.T) {
 	defer teardownFunc()
 
 	// Add two child blocks to the genesis
-	block1 := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.dagParams.GenesisBlock)
-	block2 := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.dagParams.GenesisBlock)
+	block1 := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.Params.GenesisBlock)
+	block2 := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.Params.GenesisBlock)
 
 	// Add a child block to the previous two blocks
 	block3 := prepareAndProcessBlockByParentMsgBlocks(t, dag, block1, block2)
 
 	// Clear the reachability store
-	dag.reachabilityStore.loaded = map[daghash.Hash]*reachabilityData{}
+	dag.reachabilityTree.store.loaded = map[daghash.Hash]*reachabilityData{}
 
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := dag.databaseContext.NewTx()
 	if err != nil {
 		t.Fatalf("NewTx: %s", err)
 	}
@@ -359,12 +370,15 @@ func TestGHOSTDAGErrors(t *testing.T) {
 
 	// Try to rerun GHOSTDAG on the last block. GHOSTDAG uses
 	// reachability data, so we expect it to fail.
-	blockNode3 := dag.index.LookupNode(block3.BlockHash())
+	blockNode3, ok := dag.index.LookupNode(block3.BlockHash())
+	if !ok {
+		t.Fatalf("block %s does not exist in the DAG", block3.BlockHash())
+	}
 	_, err = dag.ghostdag(blockNode3)
 	if err == nil {
 		t.Fatalf("TestGHOSTDAGErrors: ghostdag unexpectedly succeeded")
 	}
-	expectedErrSubstring := "Couldn't find reachability data"
+	expectedErrSubstring := "couldn't find reachability data"
 	if !strings.Contains(err.Error(), expectedErrSubstring) {
 		t.Fatalf("TestGHOSTDAGErrors: ghostdag returned wrong error. "+
 			"Want: %s, got: %s", expectedErrSubstring, err)

blockdag/indexers/acceptanceindex.go

@@ -3,6 +3,7 @@ package indexers
 import (
 	"bytes"
 	"encoding/gob"
+
 	"github.com/kaspanet/kaspad/blockdag"
 	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util"
@@ -14,7 +15,8 @@ import (
 // it stores a mapping between a block's hash and the set of transactions that the
 // block accepts among its blue blocks.
 type AcceptanceIndex struct {
-	dag *blockdag.BlockDAG
+	dag             *blockdag.BlockDAG
+	databaseContext *dbaccess.DatabaseContext
 }
 
 // Ensure the AcceptanceIndex type implements the Indexer interface.
@@ -31,8 +33,8 @@ func NewAcceptanceIndex() *AcceptanceIndex {
 }
 
 // DropAcceptanceIndex drops the acceptance index.
-func DropAcceptanceIndex() error {
-	dbTx, err := dbaccess.NewTx()
+func DropAcceptanceIndex(databaseContext *dbaccess.DatabaseContext) error {
+	dbTx, err := databaseContext.NewTx()
 	if err != nil {
 		return err
 	}
@@ -49,8 +51,9 @@ func DropAcceptanceIndex() error {
 // Init initializes the hash-based acceptance index.
 //
 // This is part of the Indexer interface.
-func (idx *AcceptanceIndex) Init(dag *blockdag.BlockDAG) error {
+func (idx *AcceptanceIndex) Init(dag *blockdag.BlockDAG, databaseContext *dbaccess.DatabaseContext) error {
 	idx.dag = dag
+	idx.databaseContext = databaseContext
 	return idx.recover()
 }
 
@@ -59,13 +62,13 @@ func (idx *AcceptanceIndex) Init(dag *blockdag.BlockDAG) error {
 //
 // This is part of the Indexer interface.
 func (idx *AcceptanceIndex) recover() error {
-	dbTx, err := dbaccess.NewTx()
-	if err != nil {
-		return err
-	}
-	defer dbTx.RollbackUnlessClosed()
+	return idx.dag.ForEachHash(func(hash daghash.Hash) error {
+		dbTx, err := idx.databaseContext.NewTx()
+		if err != nil {
+			return err
+		}
+		defer dbTx.RollbackUnlessClosed()
 
-	err = idx.dag.ForEachHash(func(hash daghash.Hash) error {
 		exists, err := dbaccess.HasAcceptanceData(dbTx, &hash)
 		if err != nil {
 			return err
@@ -77,13 +80,13 @@ func (idx *AcceptanceIndex) recover() error {
 		if err != nil {
 			return err
 		}
-		return idx.ConnectBlock(dbTx, &hash, txAcceptanceData)
-	})
-	if err != nil {
-		return err
-	}
+		err = idx.ConnectBlock(dbTx, &hash, txAcceptanceData)
+		if err != nil {
+			return err
+		}
 
-	return dbTx.Commit()
+		return dbTx.Commit()
+	})
 }
 
 // ConnectBlock is invoked by the index manager when a new block has been
@@ -102,7 +105,7 @@ func (idx *AcceptanceIndex) ConnectBlock(dbContext *dbaccess.TxContext, blockHas
 // TxsAcceptanceData returns the acceptance data of all the transactions that
 // were accepted by the block with hash blockHash.
 func (idx *AcceptanceIndex) TxsAcceptanceData(blockHash *daghash.Hash) (blockdag.MultiBlockTxsAcceptanceData, error) {
-	serializedTxsAcceptanceData, err := dbaccess.FetchAcceptanceData(dbaccess.NoTx(), blockHash)
+	serializedTxsAcceptanceData, err := dbaccess.FetchAcceptanceData(idx.databaseContext, blockHash)
 	if err != nil {
 		return nil, err
 	}

blockdag/indexers/acceptanceindex_test.go

@@ -1,13 +1,6 @@
 package indexers
 
 import (
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
 	"io"
 	"io/ioutil"
 	"os"
@@ -15,6 +8,14 @@ import (
 	"reflect"
 	"syscall"
 	"testing"
+
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
 )
 
 func TestAcceptanceIndexSerializationAndDeserialization(t *testing.T) {
@@ -96,14 +97,15 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 	}
 	defer os.RemoveAll(db1Path)
 
-	err = dbaccess.Open(db1Path)
+	databaseContext1, err := dbaccess.New(db1Path)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
 
 	db1Config := blockdag.Config{
-		IndexManager: db1IndexManager,
-		DAGParams:    params,
+		IndexManager:    db1IndexManager,
+		DAGParams:       params,
+		DatabaseContext: databaseContext1,
 	}
 
 	db1DAG, teardown, err := blockdag.DAGSetup("", false, db1Config)
@@ -160,17 +162,18 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 		t.Fatalf("Error fetching acceptance data: %s", err)
 	}
 
-	err = dbaccess.Close()
+	err = databaseContext1.Close()
 	if err != nil {
 		t.Fatalf("Error closing the database: %s", err)
 	}
-	err = dbaccess.Open(db2Path)
+	databaseContext2, err := dbaccess.New(db2Path)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
 
 	db2Config := blockdag.Config{
-		DAGParams: params,
+		DAGParams:       params,
+		DatabaseContext: databaseContext2,
 	}
 
 	db2DAG, teardown, err := blockdag.DAGSetup("", false, db2Config)
@@ -206,11 +209,11 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 		t.Fatalf("copyDirectory: %s", err)
 	}
 
-	err = dbaccess.Close()
+	err = databaseContext2.Close()
 	if err != nil {
 		t.Fatalf("Error closing the database: %s", err)
 	}
-	err = dbaccess.Open(db3Path)
+	databaseContext3, err := dbaccess.New(db3Path)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
@@ -218,8 +221,9 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 	db3AcceptanceIndex := NewAcceptanceIndex()
 	db3IndexManager := NewManager([]Indexer{db3AcceptanceIndex})
 	db3Config := blockdag.Config{
-		IndexManager: db3IndexManager,
-		DAGParams:    params,
+		IndexManager:    db3IndexManager,
+		DAGParams:       params,
+		DatabaseContext: databaseContext3,
 	}
 
 	_, teardown, err = blockdag.DAGSetup("", false, db3Config)

blockdag/indexers/indexer.go

@@ -18,7 +18,7 @@ import (
 type Indexer interface {
 	// Init is invoked when the index manager is first initializing the
 	// index.
-	Init(dag *blockdag.BlockDAG) error
+	Init(dag *blockdag.BlockDAG, databaseContext *dbaccess.DatabaseContext) error
 
 	// ConnectBlock is invoked when the index manager is notified that a new
 	// block has been connected to the DAG.

blockdag/indexers/manager.go

@@ -22,9 +22,9 @@ var _ blockdag.IndexManager = (*Manager)(nil)
 
 // Init initializes the enabled indexes.
 // This is part of the blockdag.IndexManager interface.
-func (m *Manager) Init(dag *blockdag.BlockDAG) error {
+func (m *Manager) Init(dag *blockdag.BlockDAG, databaseContext *dbaccess.DatabaseContext) error {
 	for _, indexer := range m.enabledIndexes {
-		if err := indexer.Init(dag); err != nil {
+		if err := indexer.Init(dag, databaseContext); err != nil {
 			return err
 		}
 	}

blockdag/mining.go

@@ -3,12 +3,14 @@ package blockdag
 import (
 	"bytes"
 	"encoding/binary"
+	"time"
+
 	"github.com/kaspanet/go-secp256k1"
 	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/kaspanet/kaspad/wire"
-	"time"
 )
 
 // BlockForMining returns a block with the given transactions
@@ -104,19 +106,19 @@ func (dag *BlockDAG) NextCoinbaseFromAddress(payToAddress util.Address, extraDat
 // on the end of the DAG. In particular, it is one second after
 // the median timestamp of the last several blocks per the DAG consensus
 // rules.
-func (dag *BlockDAG) NextBlockMinimumTime() time.Time {
-	return dag.CalcPastMedianTime().Add(time.Second)
+func (dag *BlockDAG) NextBlockMinimumTime() mstime.Time {
+	return dag.CalcPastMedianTime().Add(time.Millisecond)
 }
 
 // NextBlockTime returns a valid block time for the
 // next block that will point to the existing DAG tips.
-func (dag *BlockDAG) NextBlockTime() time.Time {
+func (dag *BlockDAG) NextBlockTime() mstime.Time {
 	// The timestamp for the block must not be before the median timestamp
 	// of the last several blocks. Thus, choose the maximum between the
 	// current time and one second after the past median time. The current
-	// timestamp is truncated to a second boundary before comparison since a
+	// timestamp is truncated to a millisecond boundary before comparison since a
 	// block timestamp does not supported a precision greater than one
-	// second.
+	// millisecond.
 	newTimestamp := dag.Now()
 	minTimestamp := dag.NextBlockMinimumTime()
 	if newTimestamp.Before(minTimestamp) {

blockdag/process.go

@@ -6,9 +6,10 @@ package blockdag
 
 import (
 	"fmt"
+	"time"
+
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/pkg/errors"
-	"time"
 
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -49,6 +50,10 @@ const (
 	// This is used for the case where a block is submitted through RPC.
 	BFDisallowDelay
 
+	// BFDisallowOrphans is set to indicate that an orphan block should be rejected.
+	// This is used for the case where a block is submitted through RPC.
+	BFDisallowOrphans
+
 	// BFNone is a convenience value to specifically indicate no flags.
 	BFNone BehaviorFlags = 0
 )
@@ -151,6 +156,7 @@ func (dag *BlockDAG) processBlockNoLock(block *util.Block, flags BehaviorFlags)
 	isAfterDelay := flags&BFAfterDelay == BFAfterDelay
 	wasBlockStored := flags&BFWasStored == BFWasStored
 	disallowDelay := flags&BFDisallowDelay == BFDisallowDelay
+	disallowOrphans := flags&BFDisallowOrphans == BFDisallowOrphans
 
 	blockHash := block.Hash()
 	log.Tracef("Processing block %s", blockHash)
@@ -199,12 +205,16 @@ func (dag *BlockDAG) processBlockNoLock(block *util.Block, flags BehaviorFlags)
 			missingParents = append(missingParents, parentHash)
 		}
 	}
+	if len(missingParents) > 0 && disallowOrphans {
+		str := fmt.Sprintf("Cannot process orphan blocks while the BFDisallowOrphans flag is raised %s", blockHash)
+		return false, false, ruleError(ErrOrphanBlockIsNotAllowed, str)
+	}
 
 	// 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
+		// Add Millisecond to ensure that parent process time will be after its child.
+		delay += time.Millisecond
 		err := dag.addDelayedBlock(block, delay)
 		if err != nil {
 			return false, false, err
@@ -221,7 +231,7 @@ func (dag *BlockDAG) processBlockNoLock(block *util.Block, flags BehaviorFlags)
 		// 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 {
+		if flags&BFIsSync == BFIsSync && dagconfig.KType(len(dag.orphans)) < dag.Params.K*2 {
 			log.Debugf("Adding orphan block %s. This is normal part of netsync process", blockHash)
 		} else {
 			log.Infof("Adding orphan block %s", blockHash)

blockdag/process_test.go

@@ -1,11 +1,12 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/util"
 	"path/filepath"
 	"testing"
 	"time"
 
+	"github.com/kaspanet/kaspad/util"
+
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
@@ -63,8 +64,8 @@ func TestProcessOrphans(t *testing.T) {
 	}
 
 	// Make sure that the child block had been rejected
-	node := dag.index.LookupNode(childBlock.Hash())
-	if node == nil {
+	node, ok := dag.index.LookupNode(childBlock.Hash())
+	if !ok {
 		t.Fatalf("TestProcessOrphans: child block missing from block index")
 	}
 	if !dag.index.NodeStatus(node).KnownInvalid() {
@@ -89,18 +90,18 @@ func TestProcessDelayedBlocks(t *testing.T) {
 		}
 	}()
 
-	initialTime := dag1.dagParams.GenesisBlock.Header.Timestamp
+	initialTime := dag1.Params.GenesisBlock.Header.Timestamp
 	// Here we use a fake time source that returns a timestamp
 	// one hour into the future to make delayedBlock artificially
 	// valid.
 	dag1.timeSource = newFakeTimeSource(initialTime.Add(time.Hour))
 
-	delayedBlock, err := PrepareBlockForTest(dag1, []*daghash.Hash{dag1.dagParams.GenesisBlock.BlockHash()}, nil)
+	delayedBlock, err := PrepareBlockForTest(dag1, []*daghash.Hash{dag1.Params.GenesisBlock.BlockHash()}, nil)
 	if err != nil {
 		t.Fatalf("error in PrepareBlockForTest: %s", err)
 	}
 
-	blockDelay := time.Duration(dag1.dagParams.TimestampDeviationTolerance*uint64(dag1.targetTimePerBlock)+5) * time.Second
+	blockDelay := time.Duration(dag1.Params.TimestampDeviationTolerance)*dag1.Params.TargetTimePerBlock + 5*time.Second
 	delayedBlock.Header.Timestamp = initialTime.Add(blockDelay)
 
 	isOrphan, isDelayed, err := dag1.ProcessBlock(util.NewBlock(delayedBlock), BFNoPoWCheck)
@@ -177,7 +178,7 @@ func TestProcessDelayedBlocks(t *testing.T) {
 		t.Errorf("dag.IsKnownBlock should return true for a child of a delayed block")
 	}
 
-	blockBeforeDelay, err := PrepareBlockForTest(dag2, []*daghash.Hash{dag2.dagParams.GenesisBlock.BlockHash()}, nil)
+	blockBeforeDelay, err := PrepareBlockForTest(dag2, []*daghash.Hash{dag2.Params.GenesisBlock.BlockHash()}, nil)
 	if err != nil {
 		t.Fatalf("error in PrepareBlockForTest: %s", err)
 	}
@@ -202,12 +203,15 @@ func TestProcessDelayedBlocks(t *testing.T) {
 	}
 
 	// We advance the clock to the point where delayedBlock timestamp is valid.
-	deviationTolerance := int64(dag2.TimestampDeviationTolerance) * dag2.targetTimePerBlock
-	secondsUntilDelayedBlockIsValid := delayedBlock.Header.Timestamp.Unix() - deviationTolerance - dag2.Now().Unix() + 1
-	dag2.timeSource = newFakeTimeSource(initialTime.Add(time.Duration(secondsUntilDelayedBlockIsValid) * time.Second))
+	deviationTolerance := time.Duration(dag2.TimestampDeviationTolerance) * dag2.Params.TargetTimePerBlock
+	timeUntilDelayedBlockIsValid := delayedBlock.Header.Timestamp.
+		Add(-deviationTolerance).
+		Sub(dag2.Now()) +
+		time.Second
+	dag2.timeSource = newFakeTimeSource(initialTime.Add(timeUntilDelayedBlockIsValid))
 
 	blockAfterDelay, err := PrepareBlockForTest(dag2,
-		[]*daghash.Hash{dag2.dagParams.GenesisBlock.BlockHash()},
+		[]*daghash.Hash{dag2.Params.GenesisBlock.BlockHash()},
 		nil)
 	if err != nil {
 		t.Fatalf("error in PrepareBlockForTest: %s", err)

blockdag/reachability_test.go

@@ -1,6 +1,8 @@
 package blockdag
 
 import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
 	"reflect"
 	"strings"
 	"testing"
@@ -11,19 +13,20 @@ func TestAddChild(t *testing.T) {
 	//             root -> a -> b -> c...
 	// Create the root node of a new reachability tree
 	root := newReachabilityTreeNode(&blockNode{})
-	root.setInterval(newReachabilityInterval(1, 100))
+	root.interval = 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)
+		modifiedNodes := newModifiedTreeNodes()
+		err := currentTip.addChild(node, root, modifiedNodes)
 		if err != nil {
 			t.Fatalf("TestAddChild: addChild failed: %s", err)
 		}
 
 		// Expect only the node and its parent to be affected
-		expectedModifiedNodes := []*reachabilityTreeNode{currentTip, node}
+		expectedModifiedNodes := newModifiedTreeNodes(currentTip, node)
 		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
 			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
 				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
@@ -34,7 +37,8 @@ func TestAddChild(t *testing.T) {
 
 	// 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)
+	modifiedNodes := newModifiedTreeNodes()
+	err := currentTip.addChild(lastChild, root, modifiedNodes)
 	if err != nil {
 		t.Fatalf("TestAddChild: addChild failed: %s", err)
 	}
@@ -45,19 +49,23 @@ func TestAddChild(t *testing.T) {
 		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
 	}
 
-	// Expect the tip to have an interval of 1 and remaining interval of 0
+	// Expect the tip to have an interval of 1 and remaining interval of 0 both before and after
 	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)
+	tipRemainingIntervalBefore := lastChild.remainingIntervalBefore().size()
+	if tipRemainingIntervalBefore != 0 {
+		t.Fatalf("TestAddChild: unexpected tip interval before size: want: 0, got: %d", tipRemainingIntervalBefore)
+	}
+	tipRemainingIntervalAfter := lastChild.remainingIntervalAfter().size()
+	if tipRemainingIntervalAfter != 0 {
+		t.Fatalf("TestAddChild: unexpected tip interval after size: want: 0, got: %d", tipRemainingIntervalAfter)
 	}
 
 	// Expect all nodes to be descendant nodes of root
 	currentNode := currentTip
-	for currentNode != nil {
+	for currentNode != root {
 		if !root.isAncestorOf(currentNode) {
 			t.Fatalf("TestAddChild: currentNode is not a descendant of root")
 		}
@@ -68,19 +76,20 @@ func TestAddChild(t *testing.T) {
 	//             root -> a, b, c...
 	// Create the root node of a new reachability tree
 	root = newReachabilityTreeNode(&blockNode{})
-	root.setInterval(newReachabilityInterval(1, 100))
+	root.interval = 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])
+		modifiedNodes := newModifiedTreeNodes()
+		err := root.addChild(childNodes[i], root, modifiedNodes)
 		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]}
+		expectedModifiedNodes := newModifiedTreeNodes(root, childNodes[i])
 		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
 			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
 				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
@@ -89,7 +98,8 @@ func TestAddChild(t *testing.T) {
 
 	// Add another node to the root to trigger a reindex (100 < 2^7=128)
 	lastChild = newReachabilityTreeNode(&blockNode{})
-	modifiedNodes, err = root.addChild(lastChild)
+	modifiedNodes = newModifiedTreeNodes()
+	err = root.addChild(lastChild, root, modifiedNodes)
 	if err != nil {
 		t.Fatalf("TestAddChild: addChild failed: %s", err)
 	}
@@ -100,14 +110,18 @@ func TestAddChild(t *testing.T) {
 		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
 	}
 
-	// Expect the last-added child to have an interval of 1 and remaining interval of 0
+	// Expect the last-added child to have an interval of 1 and remaining interval of 0 both before and after
 	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)
+	lastChildRemainingIntervalBefore := lastChild.remainingIntervalBefore().size()
+	if lastChildRemainingIntervalBefore != 0 {
+		t.Fatalf("TestAddChild: unexpected lastChild interval before size: want: 0, got: %d", lastChildRemainingIntervalBefore)
+	}
+	lastChildRemainingIntervalAfter := lastChild.remainingIntervalAfter().size()
+	if lastChildRemainingIntervalAfter != 0 {
+		t.Fatalf("TestAddChild: unexpected lastChild interval after size: want: 0, got: %d", lastChildRemainingIntervalAfter)
 	}
 
 	// Expect all nodes to be descendant nodes of root
@@ -118,6 +132,91 @@ func TestAddChild(t *testing.T) {
 	}
 }
 
+func TestReachabilityTreeNodeIsAncestorOf(t *testing.T) {
+	root := newReachabilityTreeNode(&blockNode{})
+	currentTip := root
+	const numberOfDescendants = 6
+	descendants := make([]*reachabilityTreeNode, numberOfDescendants)
+	for i := 0; i < numberOfDescendants; i++ {
+		node := newReachabilityTreeNode(&blockNode{})
+		err := currentTip.addChild(node, root, newModifiedTreeNodes())
+		if err != nil {
+			t.Fatalf("TestReachabilityTreeNodeIsAncestorOf: addChild failed: %s", err)
+		}
+		descendants[i] = node
+		currentTip = node
+	}
+
+	// Expect all descendants to be in the future of root
+	for _, node := range descendants {
+		if !root.isAncestorOf(node) {
+			t.Fatalf("TestReachabilityTreeNodeIsAncestorOf: node is not a descendant of root")
+		}
+	}
+
+	if !root.isAncestorOf(root) {
+		t.Fatalf("TestReachabilityTreeNodeIsAncestorOf: root is expected to be an ancestor of root")
+	}
+}
+
+func TestIntervalContains(t *testing.T) {
+	tests := []struct {
+		name              string
+		this, other       *reachabilityInterval
+		thisContainsOther bool
+	}{
+		{
+			name:              "this == other",
+			this:              newReachabilityInterval(10, 100),
+			other:             newReachabilityInterval(10, 100),
+			thisContainsOther: true,
+		},
+		{
+			name:              "this.start == other.start && this.end < other.end",
+			this:              newReachabilityInterval(10, 90),
+			other:             newReachabilityInterval(10, 100),
+			thisContainsOther: false,
+		},
+		{
+			name:              "this.start == other.start && this.end > other.end",
+			this:              newReachabilityInterval(10, 100),
+			other:             newReachabilityInterval(10, 90),
+			thisContainsOther: true,
+		},
+		{
+			name:              "this.start > other.start && this.end == other.end",
+			this:              newReachabilityInterval(20, 100),
+			other:             newReachabilityInterval(10, 100),
+			thisContainsOther: false,
+		},
+		{
+			name:              "this.start < other.start && this.end == other.end",
+			this:              newReachabilityInterval(10, 100),
+			other:             newReachabilityInterval(20, 100),
+			thisContainsOther: true,
+		},
+		{
+			name:              "this.start > other.start && this.end < other.end",
+			this:              newReachabilityInterval(20, 90),
+			other:             newReachabilityInterval(10, 100),
+			thisContainsOther: false,
+		},
+		{
+			name:              "this.start < other.start && this.end > other.end",
+			this:              newReachabilityInterval(10, 100),
+			other:             newReachabilityInterval(20, 90),
+			thisContainsOther: true,
+		},
+	}
+
+	for _, test := range tests {
+		if thisContainsOther := test.this.contains(test.other); thisContainsOther != test.thisContainsOther {
+			t.Errorf("test.this.contains(test.other) is expected to be %t but got %t",
+				test.thisContainsOther, thisContainsOther)
+		}
+	}
+}
+
 func TestSplitFraction(t *testing.T) {
 	tests := []struct {
 		interval      *reachabilityInterval
@@ -346,140 +445,140 @@ func TestSplitWithExponentialBias(t *testing.T) {
 	}
 }
 
-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)}},
+func TestHasAncestorOf(t *testing.T) {
+	treeNodes := futureCoveringTreeNodeSet{
+		&reachabilityTreeNode{interval: newReachabilityInterval(2, 3)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(67, 77)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
 	}
 
 	tests := []struct {
-		block          *futureCoveringBlock
+		treeNode       *reachabilityTreeNode
 		expectedResult bool
 	}{
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 1)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(1, 1)},
 			expectedResult: false,
 		},
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)},
 			expectedResult: true,
 		},
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 76)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(67, 76)},
 			expectedResult: true,
 		},
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(78, 100)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(78, 100)},
 			expectedResult: false,
 		},
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1980, 2000)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(1980, 2000)},
 			expectedResult: false,
 		},
 		{
-			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1920)}},
+			treeNode:       &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1920)},
 			expectedResult: true,
 		},
 	}
 
 	for i, test := range tests {
-		result := blocks.isInFuture(test.block)
+		result := treeNodes.hasAncestorOf(test.treeNode)
 		if result != test.expectedResult {
-			t.Errorf("TestIsInFuture: unexpected result in test #%d. Want: %t, got: %t",
+			t.Errorf("TestHasAncestorOf: 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)}},
+func TestInsertNode(t *testing.T) {
+	treeNodes := futureCoveringTreeNodeSet{
+		&reachabilityTreeNode{interval: newReachabilityInterval(1, 3)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(67, 77)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+		&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
 	}
 
 	tests := []struct {
-		toInsert       []*futureCoveringBlock
-		expectedResult futureCoveringBlockSet
+		toInsert       []*reachabilityTreeNode
+		expectedResult futureCoveringTreeNodeSet
 	}{
 		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
+			toInsert: []*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)}},
+			expectedResult: futureCoveringTreeNodeSet{
+				&reachabilityTreeNode{interval: newReachabilityInterval(1, 3)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(67, 77)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
 			},
 		},
 		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(65, 78)}},
+			toInsert: []*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)}},
+			expectedResult: futureCoveringTreeNodeSet{
+				&reachabilityTreeNode{interval: newReachabilityInterval(1, 3)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(65, 78)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
 			},
 		},
 		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
+			toInsert: []*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)}},
+			expectedResult: futureCoveringTreeNodeSet{
+				&reachabilityTreeNode{interval: newReachabilityInterval(1, 3)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(67, 77)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(88, 97)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
 			},
 		},
 		{
-			toInsert: []*futureCoveringBlock{
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
-				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(3000, 3010)}},
+			toInsert: []*reachabilityTreeNode{
+				{interval: newReachabilityInterval(88, 97)},
+				{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)}},
+			expectedResult: futureCoveringTreeNodeSet{
+				&reachabilityTreeNode{interval: newReachabilityInterval(1, 3)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(4, 67)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(67, 77)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(88, 97)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(657, 789)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)},
+				&reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)},
+				&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
+		// Create a clone of treeNodes so that we have a clean start for every test
+		treeNodesClone := make(futureCoveringTreeNodeSet, len(treeNodes))
+		for i, treeNode := range treeNodes {
+			treeNodesClone[i] = treeNode
 		}
 
-		for _, block := range test.toInsert {
-			blocksClone.insertBlock(block)
+		for _, treeNode := range test.toInsert {
+			treeNodesClone.insertNode(treeNode)
 		}
-		if !reflect.DeepEqual(blocksClone, test.expectedResult) {
-			t.Errorf("TestInsertBlock: unexpected result in test #%d. Want: %s, got: %s",
-				i, test.expectedResult, blocksClone)
+		if !reflect.DeepEqual(treeNodesClone, test.expectedResult) {
+			t.Errorf("TestInsertNode: unexpected result in test #%d. Want: %s, got: %s",
+				i, test.expectedResult, treeNodesClone)
 		}
 	}
 }
@@ -580,14 +679,14 @@ func TestSplitWithExponentialBiasErrors(t *testing.T) {
 func TestReindexIntervalErrors(t *testing.T) {
 	// Create a treeNode and give it size = 100
 	treeNode := newReachabilityTreeNode(&blockNode{})
-	treeNode.setInterval(newReachabilityInterval(0, 99))
+	treeNode.interval = newReachabilityInterval(0, 99)
 
 	// Add a chain of 100 child treeNodes to treeNode
 	var err error
 	currentTreeNode := treeNode
 	for i := 0; i < 100; i++ {
 		childTreeNode := newReachabilityTreeNode(&blockNode{})
-		_, err = currentTreeNode.addChild(childTreeNode)
+		err = currentTreeNode.addChild(childTreeNode, treeNode, newModifiedTreeNodes())
 		if err != nil {
 			break
 		}
@@ -619,12 +718,12 @@ func BenchmarkReindexInterval(b *testing.B) {
 		// its first child gets half of the interval, so a reindex
 		// from the root should happen after adding subTreeSize
 		// nodes.
-		root.setInterval(newReachabilityInterval(0, subTreeSize*2))
+		root.interval = newReachabilityInterval(0, subTreeSize*2)
 
 		currentTreeNode := root
 		for i := 0; i < subTreeSize; i++ {
 			childTreeNode := newReachabilityTreeNode(&blockNode{})
-			_, err := currentTreeNode.addChild(childTreeNode)
+			err := currentTreeNode.addChild(childTreeNode, root, newModifiedTreeNodes())
 			if err != nil {
 				b.Fatalf("addChild: %s", err)
 			}
@@ -632,50 +731,47 @@ func BenchmarkReindexInterval(b *testing.B) {
 			currentTreeNode = childTreeNode
 		}
 
-		remainingIntervalBefore := *root.remainingInterval
+		originalRemainingInterval := *root.remainingIntervalAfter()
 		// After we added subTreeSize nodes, adding the next
 		// node should lead to a reindex from root.
 		fullReindexTriggeringNode := newReachabilityTreeNode(&blockNode{})
 		b.StartTimer()
-		_, err := currentTreeNode.addChild(fullReindexTriggeringNode)
+		err := currentTreeNode.addChild(fullReindexTriggeringNode, root, newModifiedTreeNodes())
 		b.StopTimer()
 		if err != nil {
 			b.Fatalf("addChild: %s", err)
 		}
 
-		if *root.remainingInterval == remainingIntervalBefore {
+		if *root.remainingIntervalAfter() == originalRemainingInterval {
 			b.Fatal("Expected a reindex from root, but it didn't happen")
 		}
 	}
 }
 
-func TestFutureCoveringBlockSetString(t *testing.T) {
+func TestFutureCoveringTreeNodeSetString(t *testing.T) {
 	treeNodeA := newReachabilityTreeNode(&blockNode{})
-	treeNodeA.setInterval(newReachabilityInterval(123, 456))
+	treeNodeA.interval = newReachabilityInterval(123, 456)
 	treeNodeB := newReachabilityTreeNode(&blockNode{})
-	treeNodeB.setInterval(newReachabilityInterval(457, 789))
-	futureCoveringSet := futureCoveringBlockSet{
-		&futureCoveringBlock{treeNode: treeNodeA},
-		&futureCoveringBlock{treeNode: treeNodeB},
-	}
+	treeNodeB.interval = newReachabilityInterval(457, 789)
+	futureCoveringSet := futureCoveringTreeNodeSet{treeNodeA, treeNodeB}
 
 	str := futureCoveringSet.String()
 	expectedStr := "[123,456][457,789]"
 	if str != expectedStr {
-		t.Fatalf("TestFutureCoveringBlockSetString: unexpected "+
+		t.Fatalf("TestFutureCoveringTreeNodeSetString: unexpected "+
 			"string. Want: %s, got: %s", expectedStr, str)
 	}
 }
 
 func TestReachabilityTreeNodeString(t *testing.T) {
 	treeNodeA := newReachabilityTreeNode(&blockNode{})
-	treeNodeA.setInterval(newReachabilityInterval(100, 199))
+	treeNodeA.interval = newReachabilityInterval(100, 199)
 	treeNodeB1 := newReachabilityTreeNode(&blockNode{})
-	treeNodeB1.setInterval(newReachabilityInterval(100, 150))
+	treeNodeB1.interval = newReachabilityInterval(100, 150)
 	treeNodeB2 := newReachabilityTreeNode(&blockNode{})
-	treeNodeB2.setInterval(newReachabilityInterval(150, 199))
+	treeNodeB2.interval = newReachabilityInterval(150, 199)
 	treeNodeC := newReachabilityTreeNode(&blockNode{})
-	treeNodeC.setInterval(newReachabilityInterval(100, 149))
+	treeNodeC.interval = newReachabilityInterval(100, 149)
 	treeNodeA.children = []*reachabilityTreeNode{treeNodeB1, treeNodeB2}
 	treeNodeB2.children = []*reachabilityTreeNode{treeNodeC}
 
@@ -686,3 +782,268 @@ func TestReachabilityTreeNodeString(t *testing.T) {
 			"string. Want: %s, got: %s", expectedStr, str)
 	}
 }
+
+func TestIsInPast(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestIsInPast", true, Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestIsInPast: Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
+	// Add a chain of two blocks above the genesis. This will be the
+	// selected parent chain.
+	blockA := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+	blockB := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockA.BlockHash()}, nil)
+
+	// Add another block above the genesis
+	blockC := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+	nodeC, ok := dag.index.LookupNode(blockC.BlockHash())
+	if !ok {
+		t.Fatalf("TestIsInPast: block C is not in the block index")
+	}
+
+	// Add a block whose parents are the two tips
+	blockD := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockB.BlockHash(), blockC.BlockHash()}, nil)
+	nodeD, ok := dag.index.LookupNode(blockD.BlockHash())
+	if !ok {
+		t.Fatalf("TestIsInPast: block C is not in the block index")
+	}
+
+	// Make sure that node C is in the past of node D
+	isInFuture, err := dag.reachabilityTree.isInPast(nodeC, nodeD)
+	if err != nil {
+		t.Fatalf("TestIsInPast: isInPast unexpectedly failed: %s", err)
+	}
+	if !isInFuture {
+		t.Fatalf("TestIsInPast: node C is unexpectedly not the past of node D")
+	}
+}
+
+func TestAddChildThatPointsDirectlyToTheSelectedParentChainBelowReindexRoot(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestAddChildThatPointsDirectlyToTheSelectedParentChainBelowReindexRoot",
+		true, Config{DAGParams: &dagconfig.SimnetParams})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
+	// Set the reindex window to a low number to make this test run fast
+	originalReachabilityReindexWindow := reachabilityReindexWindow
+	reachabilityReindexWindow = 10
+	defer func() {
+		reachabilityReindexWindow = originalReachabilityReindexWindow
+	}()
+
+	// Add a block on top of the genesis block
+	chainRootBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+
+	// Add chain of reachabilityReindexWindow blocks above chainRootBlock.
+	// This should move the reindex root
+	chainRootBlockTipHash := chainRootBlock.BlockHash()
+	for i := uint64(0); i < reachabilityReindexWindow; i++ {
+		chainBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chainRootBlockTipHash}, nil)
+		chainRootBlockTipHash = chainBlock.BlockHash()
+	}
+
+	// Add another block over genesis
+	PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+}
+
+func TestUpdateReindexRoot(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestUpdateReindexRoot", true, Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
+	// Set the reindex window to a low number to make this test run fast
+	originalReachabilityReindexWindow := reachabilityReindexWindow
+	reachabilityReindexWindow = 10
+	defer func() {
+		reachabilityReindexWindow = originalReachabilityReindexWindow
+	}()
+
+	// Add two blocks on top of the genesis block
+	chain1RootBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+	chain2RootBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+
+	// Add chain of reachabilityReindexWindow - 1 blocks above chain1RootBlock and
+	// chain2RootBlock, respectively. This should not move the reindex root
+	chain1RootBlockTipHash := chain1RootBlock.BlockHash()
+	chain2RootBlockTipHash := chain2RootBlock.BlockHash()
+	genesisTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(dag.genesis.hash)
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	for i := uint64(0); i < reachabilityReindexWindow-1; i++ {
+		chain1Block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chain1RootBlockTipHash}, nil)
+		chain1RootBlockTipHash = chain1Block.BlockHash()
+
+		chain2Block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chain2RootBlockTipHash}, nil)
+		chain2RootBlockTipHash = chain2Block.BlockHash()
+
+		if dag.reachabilityTree.reindexRoot != genesisTreeNode {
+			t.Fatalf("reindex root unexpectedly moved")
+		}
+	}
+
+	// Add another block over chain1. This will move the reindex root to chain1RootBlock
+	PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chain1RootBlockTipHash}, nil)
+
+	// Make sure that chain1RootBlock is now the reindex root
+	chain1RootTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(chain1RootBlock.BlockHash())
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	if dag.reachabilityTree.reindexRoot != chain1RootTreeNode {
+		t.Fatalf("chain1RootBlock is not the reindex root after reindex")
+	}
+
+	// Make sure that tight intervals have been applied to chain2. Since
+	// we added reachabilityReindexWindow-1 blocks to chain2, the size
+	// of the interval at its root should be equal to reachabilityReindexWindow
+	chain2RootTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(chain2RootBlock.BlockHash())
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	if chain2RootTreeNode.interval.size() != reachabilityReindexWindow {
+		t.Fatalf("got unexpected chain2RootNode interval. Want: %d, got: %d",
+			chain2RootTreeNode.interval.size(), reachabilityReindexWindow)
+	}
+
+	// Make sure that the rest of the interval has been allocated to
+	// chain1RootNode, minus slack from both sides
+	expectedChain1RootIntervalSize := genesisTreeNode.interval.size() - 1 -
+		chain2RootTreeNode.interval.size() - 2*reachabilityReindexSlack
+	if chain1RootTreeNode.interval.size() != expectedChain1RootIntervalSize {
+		t.Fatalf("got unexpected chain1RootNode interval. Want: %d, got: %d",
+			chain1RootTreeNode.interval.size(), expectedChain1RootIntervalSize)
+	}
+}
+
+func TestReindexIntervalsEarlierThanReindexRoot(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestReindexIntervalsEarlierThanReindexRoot", true, Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
+	// Set the reindex window and slack to low numbers to make this test
+	// run fast
+	originalReachabilityReindexWindow := reachabilityReindexWindow
+	originalReachabilityReindexSlack := reachabilityReindexSlack
+	reachabilityReindexWindow = 10
+	reachabilityReindexSlack = 5
+	defer func() {
+		reachabilityReindexWindow = originalReachabilityReindexWindow
+		reachabilityReindexSlack = originalReachabilityReindexSlack
+	}()
+
+	// Add three children to the genesis: leftBlock, centerBlock, rightBlock
+	leftBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+	centerBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+	rightBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
+
+	// Add a chain of reachabilityReindexWindow blocks above centerBlock.
+	// This will move the reindex root to centerBlock
+	centerTipHash := centerBlock.BlockHash()
+	for i := uint64(0); i < reachabilityReindexWindow; i++ {
+		block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{centerTipHash}, nil)
+		centerTipHash = block.BlockHash()
+	}
+
+	// Make sure that centerBlock is now the reindex root
+	centerTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(centerBlock.BlockHash())
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	if dag.reachabilityTree.reindexRoot != centerTreeNode {
+		t.Fatalf("centerBlock is not the reindex root after reindex")
+	}
+
+	// Get the current interval for leftBlock. The reindex should have
+	// resulted in a tight interval there
+	leftTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(leftBlock.BlockHash())
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	if leftTreeNode.interval.size() != 1 {
+		t.Fatalf("leftBlock interval not tight after reindex")
+	}
+
+	// Get the current interval for rightBlock. The reindex should have
+	// resulted in a tight interval there
+	rightTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(rightBlock.BlockHash())
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	if rightTreeNode.interval.size() != 1 {
+		t.Fatalf("rightBlock interval not tight after reindex")
+	}
+
+	// Get the current interval for centerBlock. Its interval should be:
+	// genesisInterval - 1 - leftInterval - leftSlack - rightInterval - rightSlack
+	genesisTreeNode, err := dag.reachabilityTree.store.treeNodeByBlockHash(dag.genesis.hash)
+	if err != nil {
+		t.Fatalf("failed to get tree node: %s", err)
+	}
+	expectedCenterInterval := genesisTreeNode.interval.size() - 1 -
+		leftTreeNode.interval.size() - reachabilityReindexSlack -
+		rightTreeNode.interval.size() - reachabilityReindexSlack
+	if centerTreeNode.interval.size() != expectedCenterInterval {
+		t.Fatalf("unexpected centerBlock interval. Want: %d, got: %d",
+			expectedCenterInterval, centerTreeNode.interval.size())
+	}
+
+	// Add a chain of reachabilityReindexWindow - 1 blocks above leftBlock.
+	// Each addition will trigger a low-than-reindex-root reindex. We
+	// expect the centerInterval to shrink by 1 each time, but its child
+	// to remain unaffected
+	treeChildOfCenterBlock := centerTreeNode.children[0]
+	treeChildOfCenterBlockOriginalIntervalSize := treeChildOfCenterBlock.interval.size()
+	leftTipHash := leftBlock.BlockHash()
+	for i := uint64(0); i < reachabilityReindexWindow-1; i++ {
+		block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{leftTipHash}, nil)
+		leftTipHash = block.BlockHash()
+
+		expectedCenterInterval--
+		if centerTreeNode.interval.size() != expectedCenterInterval {
+			t.Fatalf("unexpected centerBlock interval. Want: %d, got: %d",
+				expectedCenterInterval, centerTreeNode.interval.size())
+		}
+
+		if treeChildOfCenterBlock.interval.size() != treeChildOfCenterBlockOriginalIntervalSize {
+			t.Fatalf("the interval of centerBlock's child unexpectedly changed")
+		}
+	}
+
+	// Add a chain of reachabilityReindexWindow - 1 blocks above rightBlock.
+	// Each addition will trigger a low-than-reindex-root reindex. We
+	// expect the centerInterval to shrink by 1 each time, but its child
+	// to remain unaffected
+	rightTipHash := rightBlock.BlockHash()
+	for i := uint64(0); i < reachabilityReindexWindow-1; i++ {
+		block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{rightTipHash}, nil)
+		rightTipHash = block.BlockHash()
+
+		expectedCenterInterval--
+		if centerTreeNode.interval.size() != expectedCenterInterval {
+			t.Fatalf("unexpected centerBlock interval. Want: %d, got: %d",
+				expectedCenterInterval, centerTreeNode.interval.size())
+		}
+
+		if treeChildOfCenterBlock.interval.size() != treeChildOfCenterBlockOriginalIntervalSize {
+			t.Fatalf("the interval of centerBlock's child unexpectedly changed")
+		}
+	}
+}

blockdag/reachabilitystore.go

@@ -12,7 +12,7 @@ import (
 
 type reachabilityData struct {
 	treeNode          *reachabilityTreeNode
-	futureCoveringSet futureCoveringBlockSet
+	futureCoveringSet futureCoveringTreeNodeSet
 }
 
 type reachabilityStore struct {
@@ -41,11 +41,11 @@ func (store *reachabilityStore) setTreeNode(treeNode *reachabilityTreeNode) {
 	store.setBlockAsDirty(node.hash)
 }
 
-func (store *reachabilityStore) setFutureCoveringSet(node *blockNode, futureCoveringSet futureCoveringBlockSet) error {
+func (store *reachabilityStore) setFutureCoveringSet(node *blockNode, futureCoveringSet futureCoveringTreeNodeSet) error {
 	// load the reachability data from DB to store.loaded
 	_, exists := store.reachabilityDataByHash(node.hash)
 	if !exists {
-		return reachabilityNotFoundError(node)
+		return reachabilityNotFoundError(node.hash)
 	}
 
 	store.loaded[*node.hash].futureCoveringSet = futureCoveringSet
@@ -57,22 +57,26 @@ func (store *reachabilityStore) setBlockAsDirty(blockHash *daghash.Hash) {
 	store.dirty[*blockHash] = struct{}{}
 }
 
-func reachabilityNotFoundError(node *blockNode) error {
-	return errors.Errorf("Couldn't find reachability data for block %s", node.hash)
+func reachabilityNotFoundError(hash *daghash.Hash) error {
+	return errors.Errorf("couldn't find reachability data for block %s", hash)
 }
 
-func (store *reachabilityStore) treeNodeByBlockNode(node *blockNode) (*reachabilityTreeNode, error) {
-	reachabilityData, exists := store.reachabilityDataByHash(node.hash)
+func (store *reachabilityStore) treeNodeByBlockHash(hash *daghash.Hash) (*reachabilityTreeNode, error) {
+	reachabilityData, exists := store.reachabilityDataByHash(hash)
 	if !exists {
-		return nil, reachabilityNotFoundError(node)
+		return nil, reachabilityNotFoundError(hash)
 	}
 	return reachabilityData.treeNode, nil
 }
 
-func (store *reachabilityStore) futureCoveringSetByBlockNode(node *blockNode) (futureCoveringBlockSet, error) {
+func (store *reachabilityStore) treeNodeByBlockNode(node *blockNode) (*reachabilityTreeNode, error) {
+	return store.treeNodeByBlockHash(node.hash)
+}
+
+func (store *reachabilityStore) futureCoveringSetByBlockNode(node *blockNode) (futureCoveringTreeNodeSet, error) {
 	reachabilityData, exists := store.reachabilityDataByHash(node.hash)
 	if !exists {
-		return nil, reachabilityNotFoundError(node)
+		return nil, reachabilityNotFoundError(node.hash)
 	}
 	return reachabilityData.futureCoveringSet, nil
 }
@@ -176,7 +180,10 @@ func (store *reachabilityStore) loadReachabilityDataFromCursor(cursor database.C
 	}
 
 	// Connect the treeNode with its blockNode
-	reachabilityData.treeNode.blockNode = store.dag.index.LookupNode(hash)
+	reachabilityData.treeNode.blockNode, ok = store.dag.index.LookupNode(hash)
+	if !ok {
+		return errors.Errorf("block %s does not exist in the DAG", hash)
+	}
 
 	return nil
 }
@@ -212,12 +219,6 @@ func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachab
 		return err
 	}
 
-	// Serialize the remaining interval
-	err = store.serializeReachabilityInterval(w, treeNode.remainingInterval)
-	if err != nil {
-		return err
-	}
-
 	// Serialize the parent
 	// If this is the genesis block, write the zero hash instead
 	parentHash := &daghash.ZeroHash
@@ -262,16 +263,16 @@ func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, inter
 	return nil
 }
 
-func (store *reachabilityStore) serializeFutureCoveringSet(w io.Writer, futureCoveringSet futureCoveringBlockSet) error {
+func (store *reachabilityStore) serializeFutureCoveringSet(w io.Writer, futureCoveringSet futureCoveringTreeNodeSet) error {
 	// Serialize the set size
 	err := wire.WriteVarInt(w, uint64(len(futureCoveringSet)))
 	if err != nil {
 		return err
 	}
 
-	// Serialize each block in the set
-	for _, block := range futureCoveringSet {
-		err = wire.WriteElement(w, block.blockNode.hash)
+	// Serialize each node in the set
+	for _, node := range futureCoveringSet {
+		err = wire.WriteElement(w, node.blockNode.hash)
 		if err != nil {
 			return err
 		}
@@ -308,13 +309,6 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
 	}
 	destination.treeNode.interval = interval
 
-	// Deserialize the remaining interval
-	remainingInterval, err := store.deserializeReachabilityInterval(r)
-	if err != nil {
-		return err
-	}
-	destination.treeNode.remainingInterval = remainingInterval
-
 	// Deserialize the parent
 	// If this is the zero hash, this node is the genesis and as such doesn't have a parent
 	parentHash := &daghash.Hash{}
@@ -385,25 +379,18 @@ func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destin
 	}
 
 	// Deserialize each block in the set
-	futureCoveringSet := make(futureCoveringBlockSet, setSize)
+	futureCoveringSet := make(futureCoveringTreeNodeSet, setSize)
 	for i := uint64(0); i < setSize; i++ {
 		blockHash := &daghash.Hash{}
 		err = wire.ReadElement(r, blockHash)
 		if err != nil {
 			return err
 		}
-		blockNode := store.dag.index.LookupNode(blockHash)
-		if blockNode == nil {
-			return errors.Errorf("blockNode not found for hash %s", blockHash)
-		}
 		blockReachabilityData, ok := store.reachabilityDataByHash(blockHash)
 		if !ok {
 			return errors.Errorf("block reachability data not found for hash: %s", blockHash)
 		}
-		futureCoveringSet[i] = &futureCoveringBlock{
-			blockNode: blockNode,
-			treeNode:  blockReachabilityData.treeNode,
-		}
+		futureCoveringSet[i] = blockReachabilityData.treeNode
 	}
 	destination.futureCoveringSet = futureCoveringSet
 

blockdag/scriptval.go

@@ -126,7 +126,7 @@ func (v *txValidator) Validate(items []*txValidateItem) error {
 	// Start up validation handlers that are used to asynchronously
 	// validate each transaction input.
 	for i := 0; i < maxGoRoutines; i++ {
-		spawn(v.validateHandler)
+		spawn("txValidator.validateHandler", v.validateHandler)
 	}
 
 	// Validate each of the inputs. The quit channel is closed when any
@@ -179,11 +179,6 @@ func newTxValidator(utxoSet UTXOSet, flags txscript.ScriptFlags, sigCache *txscr
 // ValidateTransactionScripts validates the scripts for the passed transaction
 // using multiple goroutines.
 func ValidateTransactionScripts(tx *util.Tx, utxoSet UTXOSet, flags txscript.ScriptFlags, sigCache *txscript.SigCache) error {
-	// Don't validate coinbase transaction scripts.
-	if tx.IsCoinBase() {
-		return nil
-	}
-
 	// Collect all of the transaction inputs and required information for
 	// validation.
 	txIns := tx.MsgTx().TxIn
@@ -213,10 +208,6 @@ func checkBlockScripts(block *blockNode, utxoSet UTXOSet, transactions []*util.T
 	}
 	txValItems := make([]*txValidateItem, 0, numInputs)
 	for _, tx := range transactions {
-		// Skip coinbase transactions.
-		if tx.IsCoinBase() {
-			continue
-		}
 		for txInIdx, txIn := range tx.MsgTx().TxIn {
 			txVI := &txValidateItem{
 				txInIndex: txInIdx,

blockdag/subnetworks.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+
 	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/pkg/errors"
 
@@ -75,8 +76,8 @@ func TxToSubnetworkID(tx *wire.MsgTx) (*subnetworkid.SubnetworkID, error) {
 }
 
 // fetchSubnetwork returns a registered subnetwork.
-func fetchSubnetwork(subnetworkID *subnetworkid.SubnetworkID) (*subnetwork, error) {
-	serializedSubnetwork, err := dbaccess.FetchSubnetworkData(dbaccess.NoTx(), subnetworkID)
+func (dag *BlockDAG) fetchSubnetwork(subnetworkID *subnetworkid.SubnetworkID) (*subnetwork, error) {
+	serializedSubnetwork, err := dbaccess.FetchSubnetworkData(dag.databaseContext, subnetworkID)
 	if err != nil {
 		return nil, err
 	}
@@ -91,8 +92,8 @@ func fetchSubnetwork(subnetworkID *subnetworkid.SubnetworkID) (*subnetwork, erro
 
 // GasLimit returns the gas limit of a registered subnetwork. If the subnetwork does not
 // exist this method returns an error.
-func GasLimit(subnetworkID *subnetworkid.SubnetworkID) (uint64, error) {
-	sNet, err := fetchSubnetwork(subnetworkID)
+func (dag *BlockDAG) GasLimit(subnetworkID *subnetworkid.SubnetworkID) (uint64, error) {
+	sNet, err := dag.fetchSubnetwork(subnetworkID)
 	if err != nil {
 		return 0, err
 	}

blockdag/sync_rate.go

@@ -1,6 +1,9 @@
 package blockdag
 
-import "time"
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"time"
+)
 
 const syncRateWindowDuration = 15 * time.Minute
 
@@ -8,7 +11,7 @@ const syncRateWindowDuration = 15 * time.Minute
 //
 // This function MUST be called with the DAG state lock held (for writes).
 func (dag *BlockDAG) addBlockProcessingTimestamp() {
-	now := time.Now()
+	now := mstime.Now()
 	dag.recentBlockProcessingTimestamps = append(dag.recentBlockProcessingTimestamps, now)
 	dag.removeNonRecentTimestampsFromRecentBlockProcessingTimestamps()
 }
@@ -21,8 +24,8 @@ func (dag *BlockDAG) removeNonRecentTimestampsFromRecentBlockProcessingTimestamp
 	dag.recentBlockProcessingTimestamps = dag.recentBlockProcessingTimestampsRelevantWindow()
 }
 
-func (dag *BlockDAG) recentBlockProcessingTimestampsRelevantWindow() []time.Time {
-	minTime := time.Now().Add(-syncRateWindowDuration)
+func (dag *BlockDAG) recentBlockProcessingTimestampsRelevantWindow() []mstime.Time {
+	minTime := mstime.Now().Add(-syncRateWindowDuration)
 	windowStartIndex := len(dag.recentBlockProcessingTimestamps)
 	for i, processTime := range dag.recentBlockProcessingTimestamps {
 		if processTime.After(minTime) {
@@ -49,9 +52,9 @@ func (dag *BlockDAG) IsSyncRateBelowThreshold(maxDeviation float64) bool {
 		return false
 	}
 
-	return dag.syncRate() < 1/dag.dagParams.TargetTimePerBlock.Seconds()*maxDeviation
+	return dag.syncRate() < 1/dag.Params.TargetTimePerBlock.Seconds()*maxDeviation
 }
 
 func (dag *BlockDAG) uptime() time.Duration {
-	return time.Now().Sub(dag.startTime)
+	return mstime.Now().Sub(dag.startTime)
 }

blockdag/test_utils.go

@@ -5,9 +5,6 @@ package blockdag
 import (
 	"compress/bzip2"
 	"encoding/binary"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/pkg/errors"
 	"io"
 	"io/ioutil"
 	"os"
@@ -17,6 +14,12 @@ import (
 	"sync"
 	"testing"
 
+	"github.com/kaspanet/kaspad/database/ffldb/ldb"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/pkg/errors"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 
 	"github.com/kaspanet/kaspad/txscript"
@@ -47,9 +50,9 @@ func DAGSetup(dbName string, openDb bool, config Config) (*BlockDAG, func(), err
 	// overwrite `spawn` to count the number of running goroutines
 	spawnWaitGroup := sync.WaitGroup{}
 	realSpawn := spawn
-	spawn = func(f func()) {
+	spawn = func(name string, f func()) {
 		spawnWaitGroup.Add(1)
-		realSpawn(func() {
+		realSpawn(name, func() {
 			f()
 			spawnWaitGroup.Done()
 		})
@@ -62,19 +65,31 @@ func DAGSetup(dbName string, openDb bool, config Config) (*BlockDAG, func(), err
 			return nil, nil, errors.Errorf("error creating temp dir: %s", err)
 		}
 
+		// We set ldb.Options here to return nil because normally
+		// the database is initialized with very large caches that
+		// can make opening/closing the database for every test
+		// quite heavy.
+		originalLDBOptions := ldb.Options
+		ldb.Options = func() *opt.Options {
+			return nil
+		}
+
 		dbPath := filepath.Join(tmpDir, dbName)
 		_ = os.RemoveAll(dbPath)
-		err = dbaccess.Open(dbPath)
+		databaseContext, err := dbaccess.New(dbPath)
 		if err != nil {
 			return nil, nil, errors.Errorf("error creating db: %s", err)
 		}
 
+		config.DatabaseContext = databaseContext
+
 		// Setup a teardown function for cleaning up. This function is
 		// returned to the caller to be invoked when it is done testing.
 		teardown = func() {
 			spawnWaitGroup.Wait()
 			spawn = realSpawn
-			dbaccess.Close()
+			databaseContext.Close()
+			ldb.Options = originalLDBOptions
 			os.RemoveAll(dbPath)
 		}
 	} else {
@@ -146,8 +161,8 @@ func SetVirtualForTest(dag *BlockDAG, virtual VirtualForTest) VirtualForTest {
 func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (VirtualForTest, error) {
 	parents := newBlockSet()
 	for _, hash := range parentHashes {
-		parent := dag.index.LookupNode(hash)
-		if parent == nil {
+		parent, ok := dag.index.LookupNode(hash)
+		if !ok {
 			return nil, errors.Errorf("GetVirtualFromParentsForTest: didn't found node for hash %s", hash)
 		}
 		parents.add(parent)
@@ -237,7 +252,7 @@ func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactio
 	oldVirtual := SetVirtualForTest(dag, newVirtual)
 	defer SetVirtualForTest(dag, oldVirtual)
 
-	OpTrueAddr, err := opTrueAddress(dag.dagParams.Prefix)
+	OpTrueAddr, err := opTrueAddress(dag.Params.Prefix)
 	if err != nil {
 		return nil, err
 	}

blockdag/thresholdstate.go

@@ -157,7 +157,7 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 
 		// The state is simply defined if the start time hasn't been
 		// been reached yet.
-		if uint64(medianTime.Unix()) < checker.BeginTime() {
+		if uint64(medianTime.UnixMilliseconds()) < checker.BeginTime() {
 			cache.Update(prevNode.hash, ThresholdDefined)
 			break
 		}
@@ -194,7 +194,7 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 			// 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())
+			medianTimeUnix := uint64(medianTime.UnixMilliseconds())
 			if medianTimeUnix >= checker.EndTime() {
 				state = ThresholdFailed
 				break
@@ -211,7 +211,7 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 			// 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() {
+			if uint64(medianTime.UnixMilliseconds()) >= checker.EndTime() {
 				state = ThresholdFailed
 				break
 			}
@@ -297,11 +297,11 @@ func (dag *BlockDAG) IsDeploymentActive(deploymentID uint32) (bool, error) {
 //
 // 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)) {
+	if deploymentID > uint32(len(dag.Params.Deployments)) {
 		return ThresholdFailed, errors.Errorf("deployment ID %d does not exist", deploymentID)
 	}
 
-	deployment := &dag.dagParams.Deployments[deploymentID]
+	deployment := &dag.Params.Deployments[deploymentID]
 	checker := deploymentChecker{deployment: deployment, dag: dag}
 	cache := &dag.deploymentCaches[deploymentID]
 
@@ -325,8 +325,8 @@ func (dag *BlockDAG) initThresholdCaches() error {
 			return err
 		}
 	}
-	for id := 0; id < len(dag.dagParams.Deployments); id++ {
-		deployment := &dag.dagParams.Deployments[id]
+	for id := 0; id < len(dag.Params.Deployments); id++ {
+		deployment := &dag.Params.Deployments[id]
 		cache := &dag.deploymentCaches[id]
 		checker := deploymentChecker{deployment: deployment, dag: dag}
 		_, err := dag.thresholdState(prevNode, checker, cache)
@@ -336,8 +336,8 @@ func (dag *BlockDAG) initThresholdCaches() error {
 	}
 
 	// No warnings about unknown rules or versions until the DAG is
-	// current.
-	if dag.isCurrent() {
+	// synced.
+	if dag.isSynced() {
 		// Warn if a high enough percentage of the last blocks have
 		// unexpected versions.
 		bestNode := dag.selectedTip()

blockdag/timesource.go

@@ -1,22 +1,22 @@
 package blockdag
 
 import (
-	"time"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 // TimeSource is the interface to access time.
 type TimeSource interface {
 	// Now returns the current time.
-	Now() time.Time
+	Now() mstime.Time
 }
 
 // timeSource provides an implementation of the TimeSource interface
 // that simply returns the current local time.
 type timeSource struct{}
 
-// Now returns the current local time, with one second precision.
-func (m *timeSource) Now() time.Time {
-	return time.Unix(time.Now().Unix(), 0)
+// Now returns the current local time, with one millisecond precision.
+func (m *timeSource) Now() mstime.Time {
+	return mstime.Now()
 }
 
 // NewTimeSource returns a new instance of a TimeSource

blockdag/utxodiffstore.go

@@ -2,6 +2,7 @@ package blockdag
 
 import (
 	"bytes"
+
 	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/locks"
@@ -116,7 +117,7 @@ func (diffStore *utxoDiffStore) diffChildByNode(node *blockNode) (*blockNode, er
 }
 
 func (diffStore *utxoDiffStore) diffDataFromDB(hash *daghash.Hash) (*blockUTXODiffData, error) {
-	serializedBlockDiffData, err := dbaccess.FetchUTXODiffData(dbaccess.NoTx(), hash)
+	serializedBlockDiffData, err := dbaccess.FetchUTXODiffData(diffStore.dag.databaseContext, hash)
 	if err != nil {
 		return nil, err
 	}
@@ -156,17 +157,24 @@ func (diffStore *utxoDiffStore) clearDirtyEntries() {
 var maxBlueScoreDifferenceToKeepLoaded uint64 = 100
 
 // clearOldEntries removes entries whose blue score is lower than
-// virtual.blueScore - maxBlueScoreDifferenceToKeepLoaded.
+// virtual.blueScore - maxBlueScoreDifferenceToKeepLoaded. Note
+// that tips are not removed either even if their blue score is
+// lower than the above.
 func (diffStore *utxoDiffStore) clearOldEntries() {
+	diffStore.mtx.HighPriorityWriteLock()
+	defer diffStore.mtx.HighPriorityWriteUnlock()
+
 	virtualBlueScore := diffStore.dag.VirtualBlueScore()
 	minBlueScore := virtualBlueScore - maxBlueScoreDifferenceToKeepLoaded
 	if maxBlueScoreDifferenceToKeepLoaded > virtualBlueScore {
 		minBlueScore = 0
 	}
 
+	tips := diffStore.dag.virtual.tips()
+
 	toRemove := make(map[*blockNode]struct{})
 	for node := range diffStore.loaded {
-		if node.blueScore < minBlueScore {
+		if node.blueScore < minBlueScore && !tips.contains(node) {
 			toRemove[node] = struct{}{}
 		}
 	}

blockdag/utxodiffstore_test.go

@@ -1,12 +1,13 @@
 package blockdag
 
 import (
+	"reflect"
+	"testing"
+
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/wire"
-	"reflect"
-	"testing"
 )
 
 func TestUTXODiffStore(t *testing.T) {
@@ -65,7 +66,7 @@ func TestUTXODiffStore(t *testing.T) {
 
 	// Flush changes to db, delete them from the dag.utxoDiffStore.loaded
 	// map, and check if the diff data is re-fetched from the database.
-	dbTx, err := dbaccess.NewTx()
+	dbTx, err := dag.databaseContext.NewTx()
 	if err != nil {
 		t.Fatalf("Failed to open database transaction: %s", err)
 	}
@@ -114,8 +115,8 @@ func TestClearOldEntries(t *testing.T) {
 	for i := 0; i < 10; i++ {
 		processedBlock := PrepareAndProcessBlockForTest(t, dag, dag.TipHashes(), nil)
 
-		node := dag.index.LookupNode(processedBlock.BlockHash())
-		if node == nil {
+		node, ok := dag.index.LookupNode(processedBlock.BlockHash())
+		if !ok {
 			t.Fatalf("TestClearOldEntries: missing blockNode for hash %s", processedBlock.BlockHash())
 		}
 		blockNodes[i] = node
@@ -144,15 +145,16 @@ func TestClearOldEntries(t *testing.T) {
 
 	// Add a block on top of the genesis to force the retrieval of all diffData
 	processedBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.genesis.hash}, nil)
-	node := dag.index.LookupNode(processedBlock.BlockHash())
-	if node == nil {
+	node, ok := dag.index.LookupNode(processedBlock.BlockHash())
+	if !ok {
 		t.Fatalf("TestClearOldEntries: missing blockNode for hash %s", processedBlock.BlockHash())
 	}
 
-	// Make sure that the child-of-genesis node isn't in the loaded set
-	_, ok := dag.utxoDiffStore.loaded[node]
-	if ok {
-		t.Fatalf("TestClearOldEntries: diffData for node %s is in the loaded set", node.hash)
+	// Make sure that the child-of-genesis node is in the loaded set, since it
+	// is a tip.
+	_, ok = dag.utxoDiffStore.loaded[node]
+	if !ok {
+		t.Fatalf("TestClearOldEntries: diffData for node %s is not in the loaded set", node.hash)
 	}
 
 	// Make sure that all the old nodes still do not exist in the loaded set

blockdag/utxoio.go

@@ -52,7 +52,12 @@ func (diffStore *utxoDiffStore) deserializeBlockUTXODiffData(serializedDiffData
 		if err != nil {
 			return nil, err
 		}
-		diffData.diffChild = diffStore.dag.index.LookupNode(hash)
+
+		var ok bool
+		diffData.diffChild, ok = diffStore.dag.index.LookupNode(hash)
+		if !ok {
+			return nil, errors.Errorf("block %s does not exist in the DAG", hash)
+		}
 	}
 
 	diffData.diff, err = deserializeUTXODiff(r)

blockdag/utxoset.go

@@ -457,17 +457,15 @@ func (fus *FullUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
 //
 // This function MUST be called with the DAG lock held.
 func (fus *FullUTXOSet) AddTx(tx *wire.MsgTx, blueScore uint64) (isAccepted bool, err error) {
-	isCoinbase := tx.IsCoinBase()
-	if !isCoinbase {
-		if !fus.containsInputs(tx) {
-			return false, nil
-		}
-
-		for _, txIn := range tx.TxIn {
-			fus.remove(txIn.PreviousOutpoint)
-		}
+	if !fus.containsInputs(tx) {
+		return false, nil
 	}
 
+	for _, txIn := range tx.TxIn {
+		fus.remove(txIn.PreviousOutpoint)
+	}
+
+	isCoinbase := tx.IsCoinBase()
 	for i, txOut := range tx.TxOut {
 		outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
 		entry := NewUTXOEntry(txOut, isCoinbase, blueScore)
@@ -543,12 +541,11 @@ func (dus *DiffUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
 // If dus.UTXODiff.useMultiset is true, this function MUST be
 // called with the DAG lock held.
 func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockBlueScore uint64) (bool, error) {
-	isCoinbase := tx.IsCoinBase()
-	if !isCoinbase && !dus.containsInputs(tx) {
+	if !dus.containsInputs(tx) {
 		return false, nil
 	}
 
-	err := dus.appendTx(tx, blockBlueScore, isCoinbase)
+	err := dus.appendTx(tx, blockBlueScore)
 	if err != nil {
 		return false, err
 	}
@@ -556,20 +553,19 @@ func (dus *DiffUTXOSet) AddTx(tx *wire.MsgTx, blockBlueScore uint64) (bool, erro
 	return true, nil
 }
 
-func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockBlueScore uint64, isCoinbase bool) error {
-	if !isCoinbase {
-		for _, txIn := range tx.TxIn {
-			entry, ok := dus.Get(txIn.PreviousOutpoint)
-			if !ok {
-				return errors.Errorf("Couldn't find entry for outpoint %s", txIn.PreviousOutpoint)
-			}
-			err := dus.UTXODiff.RemoveEntry(txIn.PreviousOutpoint, entry)
-			if err != nil {
-				return err
-			}
+func (dus *DiffUTXOSet) appendTx(tx *wire.MsgTx, blockBlueScore uint64) error {
+	for _, txIn := range tx.TxIn {
+		entry, ok := dus.Get(txIn.PreviousOutpoint)
+		if !ok {
+			return errors.Errorf("couldn't find entry for outpoint %s", txIn.PreviousOutpoint)
+		}
+		err := dus.UTXODiff.RemoveEntry(txIn.PreviousOutpoint, entry)
+		if err != nil {
+			return err
 		}
 	}
 
+	isCoinbase := tx.IsCoinBase()
 	for i, txOut := range tx.TxOut {
 		outpoint := *wire.NewOutpoint(tx.TxID(), uint32(i))
 		entry := NewUTXOEntry(txOut, isCoinbase, blockBlueScore)

blockdag/utxoset_test.go

@@ -1,7 +1,6 @@
 package blockdag
 
 import (
-	"math"
 	"reflect"
 	"testing"
 
@@ -947,12 +946,9 @@ func TestUTXOSetDiffRules(t *testing.T) {
 
 // TestDiffUTXOSet_addTx makes sure that diffUTXOSet addTx works as expected
 func TestDiffUTXOSet_addTx(t *testing.T) {
-	// coinbaseTX is coinbase. As such, it has exactly one input with hash zero and MaxUInt32 index
-	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
-	txIn0 := &wire.TxIn{SignatureScript: []byte{}, PreviousOutpoint: wire.Outpoint{TxID: *txID0, Index: math.MaxUint32}, Sequence: 0}
 	txOut0 := &wire.TxOut{ScriptPubKey: []byte{0}, Value: 10}
 	utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
-	coinbaseTX := wire.NewSubnetworkMsgTx(1, []*wire.TxIn{txIn0}, []*wire.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
+	coinbaseTX := wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, []*wire.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
 
 	// transaction1 spends coinbaseTX
 	id1 := coinbaseTX.TxID()

blockdag/validate.go

@@ -6,6 +6,7 @@ package blockdag
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"math"
 	"sort"
 	"time"
@@ -56,12 +57,12 @@ func isNullOutpoint(outpoint *wire.Outpoint) bool {
 // met, meaning that all the inputs of a given transaction have reached a
 // blue score or time sufficient for their relative lock-time maturity.
 func SequenceLockActive(sequenceLock *SequenceLock, blockBlueScore uint64,
-	medianTimePast time.Time) bool {
+	medianTimePast mstime.Time) bool {
 
-	// If either the seconds, or blue score relative-lock time has not yet
+	// If either the milliseconds, or blue score relative-lock time has not yet
 	// reached, then the transaction is not yet mature according to its
 	// sequence locks.
-	if sequenceLock.Seconds >= medianTimePast.Unix() ||
+	if sequenceLock.Milliseconds >= medianTimePast.UnixMilliseconds() ||
 		sequenceLock.BlockBlueScore >= int64(blockBlueScore) {
 		return false
 	}
@@ -70,7 +71,7 @@ func SequenceLockActive(sequenceLock *SequenceLock, blockBlueScore uint64,
 }
 
 // IsFinalizedTransaction determines whether or not a transaction is finalized.
-func IsFinalizedTransaction(tx *util.Tx, blockBlueScore uint64, blockTime time.Time) bool {
+func IsFinalizedTransaction(tx *util.Tx, blockBlueScore uint64, blockTime mstime.Time) bool {
 	msgTx := tx.MsgTx()
 
 	// Lock time of zero means the transaction is finalized.
@@ -87,7 +88,7 @@ func IsFinalizedTransaction(tx *util.Tx, blockBlueScore uint64, blockTime time.T
 	if lockTime < txscript.LockTimeThreshold {
 		blockTimeOrBlueScore = int64(blockBlueScore)
 	} else {
-		blockTimeOrBlueScore = blockTime.Unix()
+		blockTimeOrBlueScore = blockTime.UnixMilliseconds()
 	}
 	if int64(lockTime) < blockTimeOrBlueScore {
 		return true
@@ -133,15 +134,6 @@ func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID
 		return ruleError(ErrNoTxInputs, "transaction has no inputs")
 	}
 
-	// A transaction must not exceed the maximum allowed block mass when
-	// serialized.
-	serializedTxSize := msgTx.SerializeSize()
-	if serializedTxSize*MassPerTxByte > wire.MaxMassPerTx {
-		str := fmt.Sprintf("serialized transaction is too big - got "+
-			"%d, max %d", serializedTxSize, wire.MaxMassPerBlock)
-		return ruleError(ErrTxMassTooHigh, str)
-	}
-
 	// Ensure the transaction amounts are in range. Each transaction
 	// output must not be negative or more than the max allowed per
 	// transaction. Also, the total of all outputs must abide by the same
@@ -273,9 +265,9 @@ func (dag *BlockDAG) checkProofOfWork(header *wire.BlockHeader, flags BehaviorFl
 	}
 
 	// The target difficulty must be less than the maximum allowed.
-	if target.Cmp(dag.dagParams.PowMax) > 0 {
+	if target.Cmp(dag.Params.PowMax) > 0 {
 		str := fmt.Sprintf("block target difficulty of %064x is "+
-			"higher than max of %064x", target, dag.dagParams.PowMax)
+			"higher than max of %064x", target, dag.Params.PowMax)
 		return ruleError(ErrUnexpectedDifficulty, str)
 	}
 
@@ -400,17 +392,18 @@ func CalcTxMass(tx *util.Tx, previousScriptPubKeys [][]byte) uint64 {
 //
 // The flags do not modify the behavior of this function directly, however they
 // are needed to pass along to checkProofOfWork.
-func (dag *BlockDAG) checkBlockHeaderSanity(header *wire.BlockHeader, flags BehaviorFlags) (delay time.Duration, err error) {
+func (dag *BlockDAG) checkBlockHeaderSanity(block *util.Block, flags BehaviorFlags) (delay time.Duration, err error) {
 	// Ensure the proof of work bits in the block header is in min/max range
 	// and the block hash is less than the target value described by the
 	// bits.
+	header := &block.MsgBlock().Header
 	err = dag.checkProofOfWork(header, flags)
 	if err != nil {
 		return 0, err
 	}
 
 	if len(header.ParentHashes) == 0 {
-		if !header.BlockHash().IsEqual(dag.dagParams.GenesisHash) {
+		if !header.BlockHash().IsEqual(dag.Params.GenesisHash) {
 			return 0, ruleError(ErrNoParents, "block has no parents")
 		}
 	} else {
@@ -420,23 +413,11 @@ func (dag *BlockDAG) checkBlockHeaderSanity(header *wire.BlockHeader, flags Beha
 		}
 	}
 
-	// A block timestamp must not have a greater precision than one second.
-	// This check is necessary because Go time.Time values support
-	// nanosecond precision whereas the consensus rules only apply to
-	// seconds and it's much nicer to deal with standard Go time values
-	// instead of converting to seconds everywhere.
-	if !header.Timestamp.Equal(time.Unix(header.Timestamp.Unix(), 0)) {
-		str := fmt.Sprintf("block timestamp of %s has a higher "+
-			"precision than one second", header.Timestamp)
-		return 0, ruleError(ErrInvalidTime, str)
-	}
-
 	// Ensure the block time is not too far in the future. If it's too far, return
 	// the duration of time that should be waited before the block becomes valid.
 	// This check needs to be last as it does not return an error but rather marks the
 	// header as delayed (and valid).
-	maxTimestamp := dag.Now().Add(time.Second *
-		time.Duration(int64(dag.TimestampDeviationTolerance)*dag.targetTimePerBlock))
+	maxTimestamp := dag.Now().Add(time.Duration(dag.TimestampDeviationTolerance) * dag.Params.TargetTimePerBlock)
 	if header.Timestamp.After(maxTimestamp) {
 		return header.Timestamp.Sub(maxTimestamp), nil
 	}
@@ -465,101 +446,182 @@ func checkBlockParentsOrder(header *wire.BlockHeader) error {
 // The flags do not modify the behavior of this function directly, however they
 // are needed to pass along to checkBlockHeaderSanity.
 func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) (time.Duration, error) {
-	msgBlock := block.MsgBlock()
-	header := &msgBlock.Header
-	delay, err := dag.checkBlockHeaderSanity(header, flags)
+	delay, err := dag.checkBlockHeaderSanity(block, flags)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockContainsAtLeastOneTransaction(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockContainsLessThanMaxBlockMassTransactions(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkFirstBlockTransactionIsCoinbase(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockContainsOnlyOneCoinbase(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockTransactionOrder(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkNoNonNativeTransactions(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockTransactionSanity(block)
+	if err != nil {
+		return 0, err
+	}
+	err = dag.checkBlockHashMerkleRoot(block)
 	if err != nil {
 		return 0, err
 	}
 
-	// A block must have at least one transaction.
-	numTx := len(msgBlock.Transactions)
-	if numTx == 0 {
-		return 0, ruleError(ErrNoTransactions, "block does not contain "+
-			"any transactions")
+	// The following check will be fairly quick since the transaction IDs
+	// are already cached due to building the merkle tree above.
+	err = dag.checkBlockDuplicateTransactions(block)
+	if err != nil {
+		return 0, err
 	}
 
+	err = dag.checkBlockDoubleSpends(block)
+	if err != nil {
+		return 0, err
+	}
+	return delay, nil
+}
+
+func (dag *BlockDAG) checkBlockContainsAtLeastOneTransaction(block *util.Block) error {
+	transactions := block.Transactions()
+	numTx := len(transactions)
+	if numTx == 0 {
+		return ruleError(ErrNoTransactions, "block does not contain "+
+			"any transactions")
+	}
+	return nil
+}
+
+func (dag *BlockDAG) checkBlockContainsLessThanMaxBlockMassTransactions(block *util.Block) error {
 	// A block must not have more transactions than the max block mass or
 	// else it is certainly over the block mass limit.
+	transactions := block.Transactions()
+	numTx := len(transactions)
 	if numTx > wire.MaxMassPerBlock {
 		str := fmt.Sprintf("block contains too many transactions - "+
 			"got %d, max %d", numTx, wire.MaxMassPerBlock)
-		return 0, ruleError(ErrBlockMassTooHigh, str)
+		return ruleError(ErrBlockMassTooHigh, str)
 	}
+	return nil
+}
 
-	// The first transaction in a block must be a coinbase.
+func (dag *BlockDAG) checkFirstBlockTransactionIsCoinbase(block *util.Block) error {
 	transactions := block.Transactions()
 	if !transactions[util.CoinbaseTransactionIndex].IsCoinBase() {
-		return 0, ruleError(ErrFirstTxNotCoinbase, "first transaction in "+
+		return ruleError(ErrFirstTxNotCoinbase, "first transaction in "+
 			"block is not a coinbase")
 	}
+	return nil
+}
 
-	txOffset := util.CoinbaseTransactionIndex + 1
-
-	// A block must not have more than one coinbase. And transactions must be
-	// ordered by subnetwork
-	for i, tx := range transactions[txOffset:] {
+func (dag *BlockDAG) checkBlockContainsOnlyOneCoinbase(block *util.Block) error {
+	transactions := block.Transactions()
+	for i, tx := range transactions[util.CoinbaseTransactionIndex+1:] {
 		if tx.IsCoinBase() {
 			str := fmt.Sprintf("block contains second coinbase at "+
 				"index %d", i+2)
-			return 0, ruleError(ErrMultipleCoinbases, str)
-		}
-		if i != 0 && subnetworkid.Less(&tx.MsgTx().SubnetworkID, &transactions[i].MsgTx().SubnetworkID) {
-			return 0, ruleError(ErrTransactionsNotSorted, "transactions must be sorted by subnetwork")
+			return ruleError(ErrMultipleCoinbases, str)
 		}
 	}
+	return nil
+}
 
-	// Do some preliminary checks on each transaction to ensure they are
-	// sane before continuing.
+func (dag *BlockDAG) checkBlockTransactionOrder(block *util.Block) error {
+	transactions := block.Transactions()
+	for i, tx := range transactions[util.CoinbaseTransactionIndex+1:] {
+		if i != 0 && subnetworkid.Less(&tx.MsgTx().SubnetworkID, &transactions[i].MsgTx().SubnetworkID) {
+			return ruleError(ErrTransactionsNotSorted, "transactions must be sorted by subnetwork")
+		}
+	}
+	return nil
+}
+
+func (dag *BlockDAG) checkNoNonNativeTransactions(block *util.Block) error {
+	// Disallow non-native/coinbase subnetworks in networks that don't allow them
+	if !dag.Params.EnableNonNativeSubnetworks {
+		transactions := block.Transactions()
+		for _, tx := range transactions {
+			if !(tx.MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) ||
+				tx.MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDCoinbase)) {
+				return ruleError(ErrInvalidSubnetwork, "non-native/coinbase subnetworks are not allowed")
+			}
+		}
+	}
+	return nil
+}
+
+func (dag *BlockDAG) checkBlockTransactionSanity(block *util.Block) error {
+	transactions := block.Transactions()
 	for _, tx := range transactions {
 		err := CheckTransactionSanity(tx, dag.subnetworkID)
 		if err != nil {
-			return 0, err
+			return err
 		}
 	}
+	return nil
+}
 
+func (dag *BlockDAG) checkBlockHashMerkleRoot(block *util.Block) error {
 	// Build merkle tree and ensure the calculated merkle root matches the
 	// entry in the block header. This also has the effect of caching all
 	// of the transaction hashes in the block to speed up future hash
 	// checks.
 	hashMerkleTree := BuildHashMerkleTreeStore(block.Transactions())
 	calculatedHashMerkleRoot := hashMerkleTree.Root()
-	if !header.HashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
+	if !block.MsgBlock().Header.HashMerkleRoot.IsEqual(calculatedHashMerkleRoot) {
 		str := fmt.Sprintf("block hash merkle root is invalid - block "+
 			"header indicates %s, but calculated value is %s",
-			header.HashMerkleRoot, calculatedHashMerkleRoot)
-		return 0, ruleError(ErrBadMerkleRoot, str)
+			block.MsgBlock().Header.HashMerkleRoot, calculatedHashMerkleRoot)
+		return ruleError(ErrBadMerkleRoot, str)
 	}
+	return nil
+}
 
-	// Check for duplicate transactions. This check will be fairly quick
-	// since the transaction IDs are already cached due to building the
-	// merkle tree above.
+func (dag *BlockDAG) checkBlockDuplicateTransactions(block *util.Block) error {
 	existingTxIDs := make(map[daghash.TxID]struct{})
+	transactions := block.Transactions()
 	for _, tx := range transactions {
 		id := tx.ID()
 		if _, exists := existingTxIDs[*id]; exists {
 			str := fmt.Sprintf("block contains duplicate "+
 				"transaction %s", id)
-			return 0, ruleError(ErrDuplicateTx, str)
+			return ruleError(ErrDuplicateTx, str)
 		}
 		existingTxIDs[*id] = struct{}{}
 	}
+	return nil
+}
 
-	// Check for double spends with transactions on the same block.
+func (dag *BlockDAG) checkBlockDoubleSpends(block *util.Block) error {
 	usedOutpoints := make(map[wire.Outpoint]*daghash.TxID)
+	transactions := block.Transactions()
 	for _, tx := range transactions {
 		for _, txIn := range tx.MsgTx().TxIn {
 			if spendingTxID, exists := usedOutpoints[txIn.PreviousOutpoint]; exists {
 				str := fmt.Sprintf("transaction %s spends "+
 					"outpoint %s that was already spent by "+
 					"transaction %s in this block", tx.ID(), txIn.PreviousOutpoint, spendingTxID)
-				return 0, ruleError(ErrDoubleSpendInSameBlock, str)
+				return ruleError(ErrDoubleSpendInSameBlock, str)
 			}
 			usedOutpoints[txIn.PreviousOutpoint] = tx.ID()
 		}
 	}
-
-	return delay, nil
+	return nil
 }
 
 // checkBlockHeaderContext performs several validation checks on the block header
@@ -616,7 +678,7 @@ func (dag *BlockDAG) validateParents(blockHeader *wire.BlockHeader, parents bloc
 	for parentA := range parents {
 		// isFinalized might be false-negative because node finality status is
 		// updated in a separate goroutine. This is why later the block is
-		// checked more thoroughly on the finality rules in dag.checkFinalityRules.
+		// checked more thoroughly on the finality rules in dag.checkFinalityViolation.
 		if parentA.isFinalized {
 			return ruleError(ErrFinality, fmt.Sprintf("block %s is a finalized "+
 				"parent of block %s", parentA.hash, blockHeader.BlockHash()))
@@ -627,7 +689,7 @@ func (dag *BlockDAG) validateParents(blockHeader *wire.BlockHeader, parents bloc
 				continue
 			}
 
-			isAncestorOf, err := dag.isAncestorOf(parentA, parentB)
+			isAncestorOf, err := dag.isInPast(parentA, parentB)
 			if err != nil {
 				return err
 			}
@@ -876,7 +938,7 @@ func (dag *BlockDAG) checkConnectToPastUTXO(block *blockNode, pastUTXO UTXOSet,
 
 	for _, tx := range transactions {
 		txFee, err := CheckTransactionInputsAndCalulateFee(tx, block.blueScore, pastUTXO,
-			dag.dagParams, fastAdd)
+			dag.Params, fastAdd)
 		if err != nil {
 			return nil, err
 		}

blockdag/validate_test.go

@@ -10,6 +10,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/kaspanet/kaspad/util/mstime"
+
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/dagconfig"
@@ -22,37 +24,37 @@ import (
 // TestSequenceLocksActive tests the SequenceLockActive function to ensure it
 // works as expected in all possible combinations/scenarios.
 func TestSequenceLocksActive(t *testing.T) {
-	seqLock := func(h int64, s int64) *SequenceLock {
+	seqLock := func(blueScore int64, milliseconds int64) *SequenceLock {
 		return &SequenceLock{
-			Seconds:        s,
-			BlockBlueScore: h,
+			Milliseconds:   milliseconds,
+			BlockBlueScore: blueScore,
 		}
 	}
 
 	tests := []struct {
 		seqLock        *SequenceLock
 		blockBlueScore uint64
-		mtp            time.Time
+		mtp            mstime.Time
 
 		want bool
 	}{
 		// Block based sequence lock with equal block blue score.
-		{seqLock: seqLock(1000, -1), blockBlueScore: 1001, mtp: time.Unix(9, 0), want: true},
+		{seqLock: seqLock(1000, -1), blockBlueScore: 1001, mtp: mstime.UnixMilliseconds(9), want: true},
 
 		// Time based sequence lock with mtp past the absolute time.
-		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(31, 0), want: true},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: mstime.UnixMilliseconds(31), want: true},
 
 		// Block based sequence lock with current blue score below seq lock block blue score.
-		{seqLock: seqLock(1000, -1), blockBlueScore: 90, mtp: time.Unix(9, 0), want: false},
+		{seqLock: seqLock(1000, -1), blockBlueScore: 90, mtp: mstime.UnixMilliseconds(9), want: false},
 
 		// Time based sequence lock with current time before lock time.
-		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(29, 0), want: false},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: mstime.UnixMilliseconds(29), want: false},
 
 		// Block based sequence lock at the same blue score, so shouldn't yet be active.
-		{seqLock: seqLock(1000, -1), blockBlueScore: 1000, mtp: time.Unix(9, 0), want: false},
+		{seqLock: seqLock(1000, -1), blockBlueScore: 1000, mtp: mstime.UnixMilliseconds(9), want: false},
 
 		// Time based sequence lock with current time equal to lock time, so shouldn't yet be active.
-		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(30, 0), want: false},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: mstime.UnixMilliseconds(30), want: false},
 	}
 
 	t.Logf("Running %d sequence locks tests", len(tests))
@@ -125,12 +127,6 @@ func TestCheckConnectBlockTemplate(t *testing.T) {
 			"block 4: %v", err)
 	}
 
-	blockNode3 := dag.index.LookupNode(blocks[3].Hash())
-	blockNode4 := dag.index.LookupNode(blocks[4].Hash())
-	if blockNode3.children.contains(blockNode4) {
-		t.Errorf("Block 4 wasn't successfully detached as a child from block3")
-	}
-
 	// Block 3a should connect even though it does not build on dag tips.
 	err = dag.CheckConnectBlockTemplateNoLock(blocks[5])
 	if err != nil {
@@ -170,7 +166,7 @@ func TestCheckBlockSanity(t *testing.T) {
 		return
 	}
 	defer teardownFunc()
-	dag.timeSource = newFakeTimeSource(time.Now())
+	dag.timeSource = newFakeTimeSource(mstime.Now())
 
 	block := util.NewBlock(&Block100000)
 	if len(block.Transactions()) < 3 {
@@ -200,18 +196,6 @@ func TestCheckBlockSanity(t *testing.T) {
 		t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
 	}
 
-	// Ensure a block that has a timestamp with a precision higher than one
-	// second fails.
-	timestamp := block.MsgBlock().Header.Timestamp
-	block.MsgBlock().Header.Timestamp = timestamp.Add(time.Nanosecond)
-	delay, err = dag.checkBlockSanity(block, BFNone)
-	if err == nil {
-		t.Errorf("CheckBlockSanity: error is nil when it shouldn't be")
-	}
-	if delay != 0 {
-		t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
-	}
-
 	var invalidParentsOrderBlock = wire.MsgBlock{
 		Header: wire.BlockHeader{
 			Version: 0x10000000,
@@ -247,7 +231,7 @@ func TestCheckBlockSanity(t *testing.T) {
 				0x4e, 0x06, 0xba, 0x64, 0xd7, 0x61, 0xda, 0x25,
 				0x1a, 0x0e, 0x21, 0xd4, 0x64, 0x49, 0x02, 0xa2,
 			},
-			Timestamp: time.Unix(0x5cd18053, 0),
+			Timestamp: mstime.UnixMilliseconds(0x5cd18053000),
 			Bits:      0x207fffff,
 			Nonce:     0x1,
 		},
@@ -495,7 +479,7 @@ func TestCheckBlockSanity(t *testing.T) {
 
 	blockInTheFuture := Block100000
 	expectedDelay := 10 * time.Second
-	deviationTolerance := time.Duration(dag.TimestampDeviationTolerance*uint64(dag.targetTimePerBlock)) * time.Second
+	deviationTolerance := time.Duration(dag.TimestampDeviationTolerance) * dag.Params.TargetTimePerBlock
 	blockInTheFuture.Header.Timestamp = dag.Now().Add(deviationTolerance + expectedDelay)
 	delay, err = dag.checkBlockSanity(util.NewBlock(&blockInTheFuture), BFNoPoWCheck)
 	if err != nil {
@@ -571,9 +555,9 @@ func TestValidateParents(t *testing.T) {
 	}
 	defer teardownFunc()
 
-	a := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.dagParams.GenesisBlock)
+	a := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.Params.GenesisBlock)
 	b := prepareAndProcessBlockByParentMsgBlocks(t, dag, a)
-	c := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.dagParams.GenesisBlock)
+	c := prepareAndProcessBlockByParentMsgBlocks(t, dag, dag.Params.GenesisBlock)
 
 	aNode := nodeByMsgBlock(t, dag, a)
 	bNode := nodeByMsgBlock(t, dag, b)
@@ -618,7 +602,6 @@ func TestCheckTransactionSanity(t *testing.T) {
 		{"good one", 1, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
 		{"no inputs", 0, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, ruleError(ErrNoTxInputs, "")},
 		{"no outputs", 1, 0, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
-		{"too massive", 1, 1000000, 1, *subnetworkid.SubnetworkIDNative, nil, nil, ruleError(ErrTxMassTooHigh, "")},
 		{"too much sompi in one output", 1, 1, util.MaxSompi + 1,
 			*subnetworkid.SubnetworkIDNative,
 			nil,
@@ -746,9 +729,9 @@ var Block100000 = wire.MsgBlock{
 			0x3c, 0xb1, 0x16, 0x8f, 0x5f, 0x6b, 0x45, 0x87,
 		},
 		UTXOCommitment: &daghash.ZeroHash,
-		Timestamp:      time.Unix(0x5cdac4b1, 0),
+		Timestamp:      mstime.UnixMilliseconds(0x17305aa654a),
 		Bits:           0x207fffff,
-		Nonce:          0x00000001,
+		Nonce:          1,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -1053,9 +1036,9 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
 			0x0b, 0x79, 0xf5, 0x29, 0x6d, 0x1c, 0xaa, 0x90,
 			0x2f, 0x01, 0xd4, 0x83, 0x9b, 0x2a, 0x04, 0x5e,
 		},
-		Timestamp: time.Unix(0x5cd16eaa, 0),
+		Timestamp: mstime.UnixMilliseconds(0x5cd16eaa000),
 		Bits:      0x207fffff,
-		Nonce:     0x0,
+		Nonce:     1,
 	},
 	Transactions: []*wire.MsgTx{
 		{

blockdag/versionbits.go

@@ -78,7 +78,7 @@ func (c bitConditionChecker) EndTime() uint64 {
 //
 // This is part of the thresholdConditionChecker interface implementation.
 func (c bitConditionChecker) RuleChangeActivationThreshold() uint64 {
-	return c.dag.dagParams.RuleChangeActivationThreshold
+	return c.dag.Params.RuleChangeActivationThreshold
 }
 
 // MinerConfirmationWindow is the number of blocks in each threshold state
@@ -89,7 +89,7 @@ func (c bitConditionChecker) RuleChangeActivationThreshold() uint64 {
 //
 // This is part of the thresholdConditionChecker interface implementation.
 func (c bitConditionChecker) MinerConfirmationWindow() uint64 {
-	return c.dag.dagParams.MinerConfirmationWindow
+	return c.dag.Params.MinerConfirmationWindow
 }
 
 // Condition returns true when the specific bit associated with the checker is
@@ -159,7 +159,7 @@ func (c deploymentChecker) EndTime() uint64 {
 //
 // This is part of the thresholdConditionChecker interface implementation.
 func (c deploymentChecker) RuleChangeActivationThreshold() uint64 {
-	return c.dag.dagParams.RuleChangeActivationThreshold
+	return c.dag.Params.RuleChangeActivationThreshold
 }
 
 // MinerConfirmationWindow is the number of blocks in each threshold state
@@ -170,7 +170,7 @@ func (c deploymentChecker) RuleChangeActivationThreshold() uint64 {
 //
 // This is part of the thresholdConditionChecker interface implementation.
 func (c deploymentChecker) MinerConfirmationWindow() uint64 {
-	return c.dag.dagParams.MinerConfirmationWindow
+	return c.dag.Params.MinerConfirmationWindow
 }
 
 // Condition returns true when the specific bit defined by the deployment
@@ -198,8 +198,8 @@ func (dag *BlockDAG) calcNextBlockVersion(prevNode *blockNode) (int32, error) {
 	// 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]
+	for id := 0; id < len(dag.Params.Deployments); id++ {
+		deployment := &dag.Params.Deployments[id]
 		cache := &dag.deploymentCaches[id]
 		checker := deploymentChecker{deployment: deployment, dag: dag}
 		state, err := dag.thresholdState(prevNode, checker, cache)

blockdag/virtualblock_test.go

@@ -97,7 +97,7 @@ func TestVirtualBlock(t *testing.T) {
 			tipsToSet:              []*blockNode{},
 			tipsToAdd:              []*blockNode{node0, node1, node2, node3, node4, node5, node6},
 			expectedTips:           blockSetFromSlice(node2, node5, node6),
-			expectedSelectedParent: node6,
+			expectedSelectedParent: node5,
 		},
 	}
 

cmd/addblock/addblock.go

@@ -21,7 +21,7 @@ const (
 var (
 	cfg   *ConfigFlags
 	log   *logs.Logger
-	spawn func(func())
+	spawn func(string, func())
 )
 
 // realMain is the real main function for the utility. It is necessary to work

cmd/addblock/import.go

@@ -7,6 +7,7 @@ package main
 import (
 	"encoding/binary"
 	"github.com/kaspanet/kaspad/blockdag/indexers"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/pkg/errors"
 	"io"
 	"sync"
@@ -39,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.
@@ -170,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
@@ -264,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
 	})
@@ -277,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
@@ -315,6 +316,6 @@ func newBlockImporter(r io.ReadSeeker) (*blockImporter, error) {
 		errChan:      make(chan error),
 		quit:         make(chan struct{}),
 		dag:          dag,
-		lastLogTime:  time.Now(),
+		lastLogTime:  mstime.Now(),
 	}, nil
 }

cmd/kaspactl/config.go

@@ -16,7 +16,7 @@ import (
 	"strings"
 
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/rpcmodel"
+	"github.com/kaspanet/kaspad/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 (
@@ -45,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.
@@ -60,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.

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/rpc/model"
 )
 
 // newHTTPClient returns a new HTTP client that is configured according to the
@@ -117,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

@@ -11,7 +11,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/kaspanet/kaspad/rpcmodel"
+	"github.com/kaspanet/kaspad/rpc/model"
 )
 
 const (
@@ -21,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.
@@ -60,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)
@@ -105,13 +105,13 @@ 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.
-		var rpcModelErr rpcmodel.Error
+		var rpcModelErr model.Error
 		if ok := errors.As(err, &rpcModelErr); ok {
 			fmt.Fprintf(os.Stderr, "%s error: %s (command code: %s)\n",
 				method, err, rpcModelErr.ErrorCode)
@@ -119,7 +119,7 @@ func main() {
 			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)
@@ -129,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/kaspaminer/client.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/kaspanet/kaspad/rpcclient"
+	"github.com/kaspanet/kaspad/rpc/client"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/wire"
 	"github.com/pkg/errors"
@@ -10,30 +10,30 @@ import (
 )
 
 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{
+	notificationHandlers := &client.NotificationHandlers{
 		OnFilteredBlockAdded: func(_ uint64, header *wire.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) {
@@ -47,7 +47,7 @@ func connectToServer(cfg *configFlags) (*minerClient, error) {
 		return nil, err
 	}
 
-	connCfg := &rpcclient.ConnConfig{
+	connCfg := &client.ConnConfig{
 		Host:           rpcAddr,
 		Endpoint:       "ws",
 		User:           cfg.RPCUser,

cmd/kaspaminer/config.go

@@ -36,6 +36,7 @@ type configFlags struct {
 	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."`

cmd/kaspaminer/log.go

@@ -3,7 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/kaspanet/kaspad/logs"
-	"github.com/kaspanet/kaspad/rpcclient"
+	"github.com/kaspanet/kaspad/rpc/client"
 	"github.com/kaspanet/kaspad/util/panics"
 	"os"
 )
@@ -28,5 +28,5 @@ func initLog(logFile, errLogFile string) {
 }
 
 func enableRPCLogging() {
-	rpcclient.UseLogger(backendLog, logs.LevelTrace)
+	client.UseLogger(backendLog, logs.LevelTrace)
 }

cmd/kaspaminer/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/util"
 	"os"
 
 	"github.com/kaspanet/kaspad/version"
@@ -16,7 +17,7 @@ import (
 )
 
 func main() {
-	defer panics.HandlePanic(log, nil)
+	defer panics.HandlePanic(log, "MAIN", nil)
 	interrupt := signal.InterruptListener()
 
 	cfg, err := parseConfig()
@@ -39,15 +40,20 @@ func main() {
 
 	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, cfg.MineWhenNotSynced)
+	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,23 +1,17 @@
 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/rpc/client"
+	"github.com/kaspanet/kaspad/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()))
@@ -25,21 +19,23 @@ var hashesTried uint64
 
 const logHashRateInterval = 10 * time.Second
 
-func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64, mineWhenNotSynced bool) error {
+func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64, mineWhenNotSynced bool,
+	miningAddr util.Address) 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, mineWhenNotSynced, 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)
 				}
@@ -65,7 +61,7 @@ func mineLoop(client *minerClient, numberOfBlocks uint64, blockDelay uint64, min
 }
 
 func logHashRate() {
-	spawn(func() {
+	spawn("logHashRate", func() {
 		lastCheck := time.Now()
 		for range time.Tick(logHashRateInterval) {
 			currentHashesTried := hashesTried
@@ -80,14 +76,14 @@ func logHashRate() {
 	})
 }
 
-func mineNextBlock(client *minerClient, foundBlock chan *util.Block, mineWhenNotSynced bool,
+func mineNextBlock(client *minerClient, miningAddr util.Address, foundBlock chan *util.Block, mineWhenNotSynced bool,
 	templateStopChan chan struct{}, errChan chan error) {
 
-	newTemplateChan := make(chan *rpcmodel.GetBlockTemplateResult)
-	spawn(func() {
-		templatesLoop(client, newTemplateChan, errChan, templateStopChan)
+	newTemplateChan := make(chan *model.GetBlockTemplateResult)
+	spawn("templatesLoop", func() {
+		templatesLoop(client, miningAddr, newTemplateChan, errChan, templateStopChan)
 	})
-	spawn(func() {
+	spawn("solveLoop", func() {
 		solveLoop(newTemplateChan, foundBlock, mineWhenNotSynced, errChan)
 	})
 }
@@ -95,64 +91,18 @@ func mineNextBlock(client *minerClient, foundBlock chan *util.Block, mineWhenNot
 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
@@ -169,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 != "" {
@@ -177,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 {
@@ -205,11 +157,11 @@ 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,
+func solveLoop(newTemplateChan chan *model.GetBlockTemplateResult, foundBlock chan *util.Block,
 	mineWhenNotSynced bool, errChan chan error) {
 
 	var stopOldTemplateSolving chan struct{}
@@ -227,13 +179,13 @@ func solveLoop(newTemplateChan chan *rpcmodel.GetBlockTemplateResult, foundBlock
 		}
 
 		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
 		}
 
-		spawn(func() {
+		spawn("solveBlock", func() {
 			solveBlock(block, stopOldTemplateSolving, foundBlock)
 		})
 	}

config/config.go

@@ -18,6 +18,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/kaspanet/kaspad/dagconfig"
+
 	"github.com/pkg/errors"
 
 	"github.com/btcsuite/go-socks/socks"
@@ -68,8 +70,6 @@ var (
 	defaultLogDir      = filepath.Join(DefaultHomeDir, defaultLogDirname)
 )
 
-var activeConfig *Config
-
 // RunServiceCommand is only set to a real function on Windows. It is used
 // to parse and execute service commands specified via the -s flag.
 var RunServiceCommand func(string) error
@@ -117,7 +117,6 @@ type Flags struct {
 	Upnp                 bool          `long:"upnp" description:"Use UPnP to map our listening port outside of NAT"`
 	MinRelayTxFee        float64       `long:"minrelaytxfee" description:"The minimum transaction fee in KAS/kB to be considered a non-zero fee."`
 	MaxOrphanTxs         int           `long:"maxorphantx" description:"Max number of orphan transactions to keep in memory"`
-	MiningAddrs          []string      `long:"miningaddr" description:"Add the specified payment address to the list of addresses to use for generated blocks -- At least one address is required if the generate option is set"`
 	BlockMaxMass         uint64        `long:"blockmaxmass" description:"Maximum transaction mass to be used when creating a block"`
 	UserAgentComments    []string      `long:"uacomment" description:"Comment to add to the user agent -- See BIP 14 for more information."`
 	NoPeerBloomFilters   bool          `long:"nopeerbloomfilters" description:"Disable bloom filtering support"`
@@ -127,7 +126,6 @@ type Flags struct {
 	DropAcceptanceIndex  bool          `long:"dropacceptanceindex" description:"Deletes the hash-based acceptance index from the database on start up and then exits."`
 	RelayNonStd          bool          `long:"relaynonstd" description:"Relay non-standard transactions regardless of the default settings for the active network."`
 	RejectNonStd         bool          `long:"rejectnonstd" description:"Reject non-standard transactions regardless of the default settings for the active network."`
-	Subnetwork           string        `long:"subnetwork" description:"If subnetwork ID is specified, than node will request and process only payloads from specified subnetwork. And if subnetwork ID is ommited, than payloads of all subnetworks are processed. Subnetworks with IDs 2 through 255 are reserved for future use and are currently not allowed."`
 	ResetDatabase        bool          `long:"reset-db" description:"Reset database before starting node. It's needed when switching between subnetworks."`
 	NetworkFlags
 }
@@ -174,42 +172,8 @@ func newConfigParser(cfgFlags *Flags, so *serviceOptions, options flags.Options)
 	return parser
 }
 
-//LoadAndSetActiveConfig loads the config that can be afterward be accesible through ActiveConfig()
-func LoadAndSetActiveConfig() error {
-	tcfg, _, err := loadConfig()
-	if err != nil {
-		return err
-	}
-	activeConfig = tcfg
-	return nil
-}
-
-// ActiveConfig is a getter to the main config
-func ActiveConfig() *Config {
-	return activeConfig
-}
-
-// SetActiveConfig sets the active config
-// to the given config.
-func SetActiveConfig(cfg *Config) {
-	activeConfig = cfg
-}
-
-// loadConfig initializes and parses the config using a config file and command
-// line options.
-//
-// The configuration proceeds as follows:
-// 	1) Start with a default config with sane settings
-// 	2) Pre-parse the command line to check for an alternative config file
-// 	3) Load configuration file overwriting defaults with any specified options
-// 	4) Parse CLI options and overwrite/add any specified options
-//
-// The above results in kaspad functioning properly without any config settings
-// while still allowing the user to override settings with config files and
-// command line options. Command line options always take precedence.
-func loadConfig() (*Config, []string, error) {
-	// Default config.
-	cfgFlags := Flags{
+func defaultFlags() *Flags {
+	return &Flags{
 		ConfigFile:           defaultConfigFile,
 		DebugLevel:           defaultLogLevel,
 		TargetOutboundPeers:  defaultTargetOutboundPeers,
@@ -229,6 +193,29 @@ func loadConfig() (*Config, []string, error) {
 		MinRelayTxFee:        defaultMinRelayTxFee,
 		AcceptanceIndex:      defaultAcceptanceIndex,
 	}
+}
+
+// DefaultConfig returns the default kaspad configuration
+func DefaultConfig() *Config {
+	config := &Config{Flags: defaultFlags()}
+	config.NetworkFlags.ActiveNetParams = &dagconfig.MainnetParams
+	return config
+}
+
+// LoadConfig initializes and parses the config using a config file and command
+// line options.
+//
+// The configuration proceeds as follows:
+// 	1) Start with a default config with sane settings
+// 	2) Pre-parse the command line to check for an alternative config file
+// 	3) Load configuration file overwriting defaults with any specified options
+// 	4) Parse CLI options and overwrite/add any specified options
+//
+// The above results in kaspad functioning properly without any config settings
+// while still allowing the user to override settings with config files and
+// command line options. Command line options always take precedence.
+func LoadConfig() (cfg *Config, remainingArgs []string, err error) {
+	cfgFlags := defaultFlags()
 
 	// Service options which are only added on Windows.
 	serviceOpts := serviceOptions{}
@@ -238,8 +225,8 @@ func loadConfig() (*Config, []string, error) {
 	// help message error can be ignored here since they will be caught by
 	// the final parse below.
 	preCfg := cfgFlags
-	preParser := newConfigParser(&preCfg, &serviceOpts, flags.HelpFlag)
-	_, err := preParser.Parse()
+	preParser := newConfigParser(preCfg, &serviceOpts, flags.HelpFlag)
+	_, err = preParser.Parse()
 	if err != nil {
 		var flagsErr *flags.Error
 		if ok := errors.As(err, &flagsErr); ok && flagsErr.Type == flags.ErrHelp {
@@ -271,9 +258,9 @@ func loadConfig() (*Config, []string, error) {
 
 	// Load additional config from file.
 	var configFileError error
-	parser := newConfigParser(&cfgFlags, &serviceOpts, flags.Default)
-	activeConfig = &Config{
-		Flags: &cfgFlags,
+	parser := newConfigParser(cfgFlags, &serviceOpts, flags.Default)
+	cfg = &Config{
+		Flags: cfgFlags,
 	}
 	if !(preCfg.RegressionTest || preCfg.Simnet) || preCfg.ConfigFile !=
 		defaultConfigFile {
@@ -299,12 +286,12 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// Don't add peers from the config file when in regression test mode.
-	if preCfg.RegressionTest && len(activeConfig.AddPeers) > 0 {
-		activeConfig.AddPeers = nil
+	if preCfg.RegressionTest && len(cfg.AddPeers) > 0 {
+		cfg.AddPeers = nil
 	}
 
 	// Parse command line options again to ensure they take precedence.
-	remainingArgs, err := parser.Parse()
+	remainingArgs, err = parser.Parse()
 	if err != nil {
 		var flagsErr *flags.Error
 		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
@@ -334,8 +321,8 @@ func loadConfig() (*Config, []string, error) {
 		return nil, nil, err
 	}
 
-	if !activeConfig.DisableRPC {
-		if activeConfig.RPCUser == "" {
+	if !cfg.DisableRPC {
+		if cfg.RPCUser == "" {
 			str := "%s: rpcuser cannot be empty"
 			err := errors.Errorf(str, funcName)
 			fmt.Fprintln(os.Stderr, err)
@@ -343,7 +330,7 @@ func loadConfig() (*Config, []string, error) {
 			return nil, nil, err
 		}
 
-		if activeConfig.RPCPass == "" {
+		if cfg.RPCPass == "" {
 			str := "%s: rpcpass cannot be empty"
 			err := errors.Errorf(str, funcName)
 			fmt.Fprintln(os.Stderr, err)
@@ -352,7 +339,7 @@ func loadConfig() (*Config, []string, error) {
 		}
 	}
 
-	err = activeConfig.ResolveNetwork(parser)
+	err = cfg.ResolveNetwork(parser)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -361,21 +348,21 @@ func loadConfig() (*Config, []string, error) {
 	// according to the default of the active network. The set
 	// configuration value takes precedence over the default value for the
 	// selected network.
-	relayNonStd := activeConfig.NetParams().RelayNonStdTxs
+	relayNonStd := cfg.NetParams().RelayNonStdTxs
 	switch {
-	case activeConfig.RelayNonStd && activeConfig.RejectNonStd:
+	case cfg.RelayNonStd && cfg.RejectNonStd:
 		str := "%s: rejectnonstd and relaynonstd cannot be used " +
 			"together -- choose only one"
 		err := errors.Errorf(str, funcName)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
-	case activeConfig.RejectNonStd:
+	case cfg.RejectNonStd:
 		relayNonStd = false
-	case activeConfig.RelayNonStd:
+	case cfg.RelayNonStd:
 		relayNonStd = true
 	}
-	activeConfig.RelayNonStd = relayNonStd
+	cfg.RelayNonStd = relayNonStd
 
 	// Append the network type to the data directory so it is "namespaced"
 	// per network. In addition to the block database, there are other
@@ -383,26 +370,26 @@ func loadConfig() (*Config, []string, error) {
 	// 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.
-	activeConfig.DataDir = cleanAndExpandPath(activeConfig.DataDir)
-	activeConfig.DataDir = filepath.Join(activeConfig.DataDir, activeConfig.NetParams().Name)
+	cfg.DataDir = cleanAndExpandPath(cfg.DataDir)
+	cfg.DataDir = filepath.Join(cfg.DataDir, cfg.NetParams().Name)
 
 	// Append the network type to the log directory so it is "namespaced"
 	// per network in the same fashion as the data directory.
-	activeConfig.LogDir = cleanAndExpandPath(activeConfig.LogDir)
-	activeConfig.LogDir = filepath.Join(activeConfig.LogDir, activeConfig.NetParams().Name)
+	cfg.LogDir = cleanAndExpandPath(cfg.LogDir)
+	cfg.LogDir = filepath.Join(cfg.LogDir, cfg.NetParams().Name)
 
 	// Special show command to list supported subsystems and exit.
-	if activeConfig.DebugLevel == "show" {
+	if cfg.DebugLevel == "show" {
 		fmt.Println("Supported subsystems", logger.SupportedSubsystems())
 		os.Exit(0)
 	}
 
 	// Initialize log rotation. After log rotation has been initialized, the
 	// logger variables may be used.
-	logger.InitLog(filepath.Join(activeConfig.LogDir, defaultLogFilename), filepath.Join(activeConfig.LogDir, defaultErrLogFilename))
+	logger.InitLog(filepath.Join(cfg.LogDir, defaultLogFilename), filepath.Join(cfg.LogDir, defaultErrLogFilename))
 
 	// Parse, validate, and set debug log level(s).
-	if err := logger.ParseAndSetDebugLevels(activeConfig.DebugLevel); err != nil {
+	if err := logger.ParseAndSetDebugLevels(cfg.DebugLevel); err != nil {
 		err := errors.Errorf("%s: %s", funcName, err.Error())
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
@@ -410,8 +397,8 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// Validate profile port number
-	if activeConfig.Profile != "" {
-		profilePort, err := strconv.Atoi(activeConfig.Profile)
+	if cfg.Profile != "" {
+		profilePort, err := strconv.Atoi(cfg.Profile)
 		if err != nil || profilePort < 1024 || profilePort > 65535 {
 			str := "%s: The profile port must be between 1024 and 65535"
 			err := errors.Errorf(str, funcName)
@@ -422,20 +409,20 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// Don't allow ban durations that are too short.
-	if activeConfig.BanDuration < time.Second {
+	if cfg.BanDuration < time.Second {
 		str := "%s: The banduration option may not be less than 1s -- parsed [%s]"
-		err := errors.Errorf(str, funcName, activeConfig.BanDuration)
+		err := errors.Errorf(str, funcName, cfg.BanDuration)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
 	}
 
 	// Validate any given whitelisted IP addresses and networks.
-	if len(activeConfig.Whitelists) > 0 {
+	if len(cfg.Whitelists) > 0 {
 		var ip net.IP
-		activeConfig.Whitelists = make([]*net.IPNet, 0, len(activeConfig.Flags.Whitelists))
+		cfg.Whitelists = make([]*net.IPNet, 0, len(cfg.Flags.Whitelists))
 
-		for _, addr := range activeConfig.Flags.Whitelists {
+		for _, addr := range cfg.Flags.Whitelists {
 			_, ipnet, err := net.ParseCIDR(addr)
 			if err != nil {
 				ip = net.ParseIP(addr)
@@ -458,12 +445,12 @@ func loadConfig() (*Config, []string, error) {
 					Mask: net.CIDRMask(bits, bits),
 				}
 			}
-			activeConfig.Whitelists = append(activeConfig.Whitelists, ipnet)
+			cfg.Whitelists = append(cfg.Whitelists, ipnet)
 		}
 	}
 
 	// --addPeer and --connect do not mix.
-	if len(activeConfig.AddPeers) > 0 && len(activeConfig.ConnectPeers) > 0 {
+	if len(cfg.AddPeers) > 0 && len(cfg.ConnectPeers) > 0 {
 		str := "%s: the --addpeer and --connect options can not be " +
 			"mixed"
 		err := errors.Errorf(str, funcName)
@@ -473,27 +460,28 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// --proxy or --connect without --listen disables listening.
-	if (activeConfig.Proxy != "" || len(activeConfig.ConnectPeers) > 0) &&
-		len(activeConfig.Listeners) == 0 {
-		activeConfig.DisableListen = true
+	if (cfg.Proxy != "" || len(cfg.ConnectPeers) > 0) &&
+		len(cfg.Listeners) == 0 {
+		cfg.DisableListen = true
 	}
 
-	// Connect means no DNS seeding.
-	if len(activeConfig.ConnectPeers) > 0 {
-		activeConfig.DisableDNSSeed = true
+	// ConnectPeers means no DNS seeding and no outbound peers
+	if len(cfg.ConnectPeers) > 0 {
+		cfg.DisableDNSSeed = true
+		cfg.TargetOutboundPeers = 0
 	}
 
 	// Add the default listener if none were specified. The default
 	// listener is all addresses on the listen port for the network
 	// we are to connect to.
-	if len(activeConfig.Listeners) == 0 {
-		activeConfig.Listeners = []string{
-			net.JoinHostPort("", activeConfig.NetParams().DefaultPort),
+	if len(cfg.Listeners) == 0 {
+		cfg.Listeners = []string{
+			net.JoinHostPort("", cfg.NetParams().DefaultPort),
 		}
 	}
 
 	// Check to make sure limited and admin users don't have the same username
-	if activeConfig.RPCUser == activeConfig.RPCLimitUser && activeConfig.RPCUser != "" {
+	if cfg.RPCUser == cfg.RPCLimitUser && cfg.RPCUser != "" {
 		str := "%s: --rpcuser and --rpclimituser must not specify the " +
 			"same username"
 		err := errors.Errorf(str, funcName)
@@ -503,7 +491,7 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// Check to make sure limited and admin users don't have the same password
-	if activeConfig.RPCPass == activeConfig.RPCLimitPass && activeConfig.RPCPass != "" {
+	if cfg.RPCPass == cfg.RPCLimitPass && cfg.RPCPass != "" {
 		str := "%s: --rpcpass and --rpclimitpass must not specify the " +
 			"same password"
 		err := errors.Errorf(str, funcName)
@@ -513,39 +501,39 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// The RPC server is disabled if no username or password is provided.
-	if (activeConfig.RPCUser == "" || activeConfig.RPCPass == "") &&
-		(activeConfig.RPCLimitUser == "" || activeConfig.RPCLimitPass == "") {
-		activeConfig.DisableRPC = true
+	if (cfg.RPCUser == "" || cfg.RPCPass == "") &&
+		(cfg.RPCLimitUser == "" || cfg.RPCLimitPass == "") {
+		cfg.DisableRPC = true
 	}
 
-	if activeConfig.DisableRPC {
+	if cfg.DisableRPC {
 		log.Infof("RPC service is disabled")
 	}
 
 	// Default RPC to listen on localhost only.
-	if !activeConfig.DisableRPC && len(activeConfig.RPCListeners) == 0 {
+	if !cfg.DisableRPC && len(cfg.RPCListeners) == 0 {
 		addrs, err := net.LookupHost("localhost")
 		if err != nil {
 			return nil, nil, err
 		}
-		activeConfig.RPCListeners = make([]string, 0, len(addrs))
+		cfg.RPCListeners = make([]string, 0, len(addrs))
 		for _, addr := range addrs {
-			addr = net.JoinHostPort(addr, activeConfig.NetParams().RPCPort)
-			activeConfig.RPCListeners = append(activeConfig.RPCListeners, addr)
+			addr = net.JoinHostPort(addr, cfg.NetParams().RPCPort)
+			cfg.RPCListeners = append(cfg.RPCListeners, addr)
 		}
 	}
 
-	if activeConfig.RPCMaxConcurrentReqs < 0 {
+	if cfg.RPCMaxConcurrentReqs < 0 {
 		str := "%s: The rpcmaxwebsocketconcurrentrequests option may " +
 			"not be less than 0 -- parsed [%d]"
-		err := errors.Errorf(str, funcName, activeConfig.RPCMaxConcurrentReqs)
+		err := errors.Errorf(str, funcName, cfg.RPCMaxConcurrentReqs)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
 	}
 
 	// Validate the the minrelaytxfee.
-	activeConfig.MinRelayTxFee, err = util.NewAmount(activeConfig.Flags.MinRelayTxFee)
+	cfg.MinRelayTxFee, err = util.NewAmount(cfg.Flags.MinRelayTxFee)
 	if err != nil {
 		str := "%s: invalid minrelaytxfee: %s"
 		err := errors.Errorf(str, funcName, err)
@@ -555,39 +543,39 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// Disallow 0 and negative min tx fees.
-	if activeConfig.MinRelayTxFee == 0 {
+	if cfg.MinRelayTxFee == 0 {
 		str := "%s: The minrelaytxfee option must be greater than 0 -- parsed [%d]"
-		err := errors.Errorf(str, funcName, activeConfig.MinRelayTxFee)
+		err := errors.Errorf(str, funcName, cfg.MinRelayTxFee)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
 	}
 
 	// Limit the max block mass to a sane value.
-	if activeConfig.BlockMaxMass < blockMaxMassMin || activeConfig.BlockMaxMass >
+	if cfg.BlockMaxMass < blockMaxMassMin || cfg.BlockMaxMass >
 		blockMaxMassMax {
 
 		str := "%s: The blockmaxmass option must be in between %d " +
 			"and %d -- parsed [%d]"
 		err := errors.Errorf(str, funcName, blockMaxMassMin,
-			blockMaxMassMax, activeConfig.BlockMaxMass)
+			blockMaxMassMax, cfg.BlockMaxMass)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
 	}
 
 	// Limit the max orphan count to a sane value.
-	if activeConfig.MaxOrphanTxs < 0 {
+	if cfg.MaxOrphanTxs < 0 {
 		str := "%s: The maxorphantx option may not be less than 0 " +
 			"-- parsed [%d]"
-		err := errors.Errorf(str, funcName, activeConfig.MaxOrphanTxs)
+		err := errors.Errorf(str, funcName, cfg.MaxOrphanTxs)
 		fmt.Fprintln(os.Stderr, err)
 		fmt.Fprintln(os.Stderr, usageMessage)
 		return nil, nil, err
 	}
 
 	// Look for illegal characters in the user agent comments.
-	for _, uaComment := range activeConfig.UserAgentComments {
+	for _, uaComment := range cfg.UserAgentComments {
 		if strings.ContainsAny(uaComment, "/:()") {
 			err := errors.Errorf("%s: The following characters must not "+
 				"appear in user agent comments: '/', ':', '(', ')'",
@@ -599,7 +587,7 @@ func loadConfig() (*Config, []string, error) {
 	}
 
 	// --acceptanceindex and --dropacceptanceindex do not mix.
-	if activeConfig.AcceptanceIndex && activeConfig.DropAcceptanceIndex {
+	if cfg.AcceptanceIndex && cfg.DropAcceptanceIndex {
 		err := errors.Errorf("%s: the --acceptanceindex and --dropacceptanceindex "+
 			"options may not be activated at the same time",
 			funcName)
@@ -608,61 +596,31 @@ func loadConfig() (*Config, []string, error) {
 		return nil, nil, err
 	}
 
-	// Check mining addresses are valid and saved parsed versions.
-	activeConfig.MiningAddrs = make([]util.Address, 0, len(activeConfig.Flags.MiningAddrs))
-	for _, strAddr := range activeConfig.Flags.MiningAddrs {
-		addr, err := util.DecodeAddress(strAddr, activeConfig.NetParams().Prefix)
-		if err != nil {
-			str := "%s: mining address '%s' failed to decode: %s"
-			err := errors.Errorf(str, funcName, strAddr, err)
-			fmt.Fprintln(os.Stderr, err)
-			fmt.Fprintln(os.Stderr, usageMessage)
-			return nil, nil, err
-		}
-		if !addr.IsForPrefix(activeConfig.NetParams().Prefix) {
-			str := "%s: mining address '%s' is on the wrong network"
-			err := errors.Errorf(str, funcName, strAddr)
-			fmt.Fprintln(os.Stderr, err)
-			fmt.Fprintln(os.Stderr, usageMessage)
-			return nil, nil, err
-		}
-		activeConfig.MiningAddrs = append(activeConfig.MiningAddrs, addr)
-	}
-
-	if activeConfig.Flags.Subnetwork != "" {
-		activeConfig.SubnetworkID, err = subnetworkid.NewFromStr(activeConfig.Flags.Subnetwork)
-		if err != nil {
-			return nil, nil, err
-		}
-	} else {
-		activeConfig.SubnetworkID = nil
-	}
-
 	// Add default port to all listener addresses if needed and remove
 	// duplicate addresses.
-	activeConfig.Listeners, err = network.NormalizeAddresses(activeConfig.Listeners,
-		activeConfig.NetParams().DefaultPort)
+	cfg.Listeners, err = network.NormalizeAddresses(cfg.Listeners,
+		cfg.NetParams().DefaultPort)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// Add default port to all rpc listener addresses if needed and remove
 	// duplicate addresses.
-	activeConfig.RPCListeners, err = network.NormalizeAddresses(activeConfig.RPCListeners,
-		activeConfig.NetParams().RPCPort)
+	cfg.RPCListeners, err = network.NormalizeAddresses(cfg.RPCListeners,
+		cfg.NetParams().RPCPort)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// Only allow TLS to be disabled if the RPC is bound to localhost
 	// addresses.
-	if !activeConfig.DisableRPC && activeConfig.DisableTLS {
+	if !cfg.DisableRPC && cfg.DisableTLS {
 		allowedTLSListeners := map[string]struct{}{
 			"localhost": {},
 			"127.0.0.1": {},
 			"::1":       {},
 		}
-		for _, addr := range activeConfig.RPCListeners {
+		for _, addr := range cfg.RPCListeners {
 			host, _, err := net.SplitHostPort(addr)
 			if err != nil {
 				str := "%s: RPC listen interface '%s' is " +
@@ -684,16 +642,25 @@ func loadConfig() (*Config, []string, error) {
 		}
 	}
 
+	// Disallow --addpeer and --connect used together
+	if len(cfg.AddPeers) > 0 && len(cfg.ConnectPeers) > 0 {
+		str := "%s: --addpeer and --connect can not be used together"
+		err := errors.Errorf(str, funcName)
+		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, usageMessage)
+		return nil, nil, err
+	}
+
 	// Add default port to all added peer addresses if needed and remove
 	// duplicate addresses.
-	activeConfig.AddPeers, err = network.NormalizeAddresses(activeConfig.AddPeers,
-		activeConfig.NetParams().DefaultPort)
+	cfg.AddPeers, err = network.NormalizeAddresses(cfg.AddPeers,
+		cfg.NetParams().DefaultPort)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	activeConfig.ConnectPeers, err = network.NormalizeAddresses(activeConfig.ConnectPeers,
-		activeConfig.NetParams().DefaultPort)
+	cfg.ConnectPeers, err = network.NormalizeAddresses(cfg.ConnectPeers,
+		cfg.NetParams().DefaultPort)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -703,24 +670,24 @@ func loadConfig() (*Config, []string, error) {
 	// net.DialTimeout function as well as the system DNS resolver. When a
 	// proxy is specified, the dial function is set to the proxy specific
 	// dial function.
-	activeConfig.Dial = net.DialTimeout
-	activeConfig.Lookup = net.LookupIP
-	if activeConfig.Proxy != "" {
-		_, _, err := net.SplitHostPort(activeConfig.Proxy)
+	cfg.Dial = net.DialTimeout
+	cfg.Lookup = net.LookupIP
+	if cfg.Proxy != "" {
+		_, _, err := net.SplitHostPort(cfg.Proxy)
 		if err != nil {
 			str := "%s: Proxy address '%s' is invalid: %s"
-			err := errors.Errorf(str, funcName, activeConfig.Proxy, err)
+			err := errors.Errorf(str, funcName, cfg.Proxy, err)
 			fmt.Fprintln(os.Stderr, err)
 			fmt.Fprintln(os.Stderr, usageMessage)
 			return nil, nil, err
 		}
 
 		proxy := &socks.Proxy{
-			Addr:     activeConfig.Proxy,
-			Username: activeConfig.ProxyUser,
-			Password: activeConfig.ProxyPass,
+			Addr:     cfg.Proxy,
+			Username: cfg.ProxyUser,
+			Password: cfg.ProxyPass,
 		}
-		activeConfig.Dial = proxy.DialTimeout
+		cfg.Dial = proxy.DialTimeout
 	}
 
 	// Warn about missing config file only after all other configuration is
@@ -730,7 +697,7 @@ func loadConfig() (*Config, []string, error) {
 		log.Warnf("%s", configFileError)
 	}
 
-	return activeConfig, remainingArgs, nil
+	return cfg, remainingArgs, nil
 }
 
 // createDefaultConfig copies the file sample-kaspad.conf to the given destination path,

connmanager/connection_requests.go

@@ -0,0 +1,113 @@
+package connmanager
+
+import (
+	"time"
+)
+
+const (
+	minRetryDuration = 30 * time.Second
+	maxRetryDuration = 10 * time.Minute
+)
+
+func nextRetryDuration(previousDuration time.Duration) time.Duration {
+	if previousDuration < minRetryDuration {
+		return minRetryDuration
+	}
+	if previousDuration*2 > maxRetryDuration {
+		return maxRetryDuration
+	}
+	return previousDuration * 2
+}
+
+// checkRequestedConnections checks that all activeRequested are still active, and initiates connections
+// for pendingRequested.
+// While doing so, it filters out of connSet all connections that were initiated as a connectionRequest
+func (c *ConnectionManager) checkRequestedConnections(connSet connectionSet) {
+	c.connectionRequestsLock.Lock()
+	defer c.connectionRequestsLock.Unlock()
+
+	now := time.Now()
+
+	for address, connReq := range c.activeRequested {
+		connection, ok := connSet.get(address)
+		if !ok { // a requested connection was disconnected
+			delete(c.activeRequested, address)
+
+			if connReq.isPermanent { // if is one-try - ignore. If permanent - add to pending list to retry
+				connReq.nextAttempt = now
+				connReq.retryDuration = 0
+				c.pendingRequested[address] = connReq
+			}
+			continue
+		}
+
+		connSet.remove(connection)
+	}
+
+	for address, connReq := range c.pendingRequested {
+		if connReq.nextAttempt.After(now) { // ignore connection requests which are still waiting for retry
+			continue
+		}
+
+		connection, ok := connSet.get(address)
+		// The pending connection request has already connected - move it to active
+		// This can happen in rare cases such as when the other side has connected to our node
+		// while it has been pending on our side.
+		if ok {
+			delete(c.pendingRequested, address)
+			c.pendingRequested[address] = connReq
+
+			connSet.remove(connection)
+
+			continue
+		}
+
+		// try to initiate connection
+		err := c.initiateConnection(connReq.address)
+		if err != nil {
+			log.Infof("Couldn't connect to %s: %s", address, err)
+			// if connection request is one try - remove from pending and ignore failure
+			if !connReq.isPermanent {
+				delete(c.pendingRequested, address)
+				continue
+			}
+			// if connection request is permanent - keep in pending, and increase retry time
+			connReq.retryDuration = nextRetryDuration(connReq.retryDuration)
+			connReq.nextAttempt = now.Add(connReq.retryDuration)
+			log.Debugf("Retrying permanent connection to %s in %s", address, connReq.retryDuration)
+			continue
+		}
+
+		// if connected successfully - move from pending to active
+		delete(c.pendingRequested, address)
+		c.activeRequested[address] = connReq
+	}
+}
+
+// AddConnectionRequest adds the given address to list of pending connection requests
+func (c *ConnectionManager) AddConnectionRequest(address string, isPermanent bool) {
+	// spawn goroutine so that caller doesn't wait in case connectionManager is in the midst of handling
+	// connection requests
+	spawn("ConnectionManager.AddConnectionRequest", func() {
+		c.connectionRequestsLock.Lock()
+		defer c.connectionRequestsLock.Unlock()
+
+		if _, ok := c.activeRequested[address]; ok {
+			return
+		}
+
+		c.pendingRequested[address] = &connectionRequest{
+			address:     address,
+			isPermanent: isPermanent,
+		}
+
+		c.run()
+	})
+}
+
+// RemoveConnection disconnects the connection for the given address
+// and removes it entirely from the connection manager.
+func (c *ConnectionManager) RemoveConnection(address string) {
+	// TODO(libp2p): unimplemented
+	panic("unimplemented")
+}

connmanager/connection_set.go

@@ -0,0 +1,30 @@
+package connmanager
+
+import (
+	"github.com/kaspanet/kaspad/netadapter"
+)
+
+type connectionSet map[string]*netadapter.NetConnection
+
+func (cs connectionSet) add(connection *netadapter.NetConnection) {
+	cs[connection.Address()] = connection
+}
+
+func (cs connectionSet) remove(connection *netadapter.NetConnection) {
+	delete(cs, connection.Address())
+}
+
+func (cs connectionSet) get(address string) (*netadapter.NetConnection, bool) {
+	connection, ok := cs[address]
+	return connection, ok
+}
+
+func convertToSet(connections []*netadapter.NetConnection) connectionSet {
+	connSet := make(connectionSet, len(connections))
+
+	for _, connection := range connections {
+		connSet[connection.Address()] = connection
+	}
+
+	return connSet
+}

connmanager/connmanager.go

@@ -0,0 +1,145 @@
+package connmanager
+
+import (
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/kaspanet/kaspad/addressmanager"
+
+	"github.com/kaspanet/kaspad/netadapter"
+
+	"github.com/kaspanet/kaspad/config"
+)
+
+// connectionRequest represents a user request (either through CLI or RPC) to connect to a certain node
+type connectionRequest struct {
+	address       string
+	isPermanent   bool
+	nextAttempt   time.Time
+	retryDuration time.Duration
+}
+
+// ConnectionManager monitors that the current active connections satisfy the requirements of
+// outgoing, requested and incoming connections
+type ConnectionManager struct {
+	cfg            *config.Config
+	netAdapter     *netadapter.NetAdapter
+	addressManager *addressmanager.AddressManager
+
+	activeRequested  map[string]*connectionRequest
+	pendingRequested map[string]*connectionRequest
+	activeOutgoing   map[string]struct{}
+	targetOutgoing   int
+	activeIncoming   map[string]struct{}
+	maxIncoming      int
+
+	stop                   uint32
+	connectionRequestsLock sync.Mutex
+
+	resetLoopChan chan struct{}
+	loopTicker    *time.Ticker
+}
+
+// New instantiates a new instance of a ConnectionManager
+func New(cfg *config.Config, netAdapter *netadapter.NetAdapter, addressManager *addressmanager.AddressManager) (*ConnectionManager, error) {
+	c := &ConnectionManager{
+		cfg:              cfg,
+		netAdapter:       netAdapter,
+		addressManager:   addressManager,
+		activeRequested:  map[string]*connectionRequest{},
+		pendingRequested: map[string]*connectionRequest{},
+		activeOutgoing:   map[string]struct{}{},
+		activeIncoming:   map[string]struct{}{},
+		resetLoopChan:    make(chan struct{}),
+		loopTicker:       time.NewTicker(connectionsLoopInterval),
+	}
+
+	connectPeers := cfg.AddPeers
+	if len(cfg.ConnectPeers) > 0 {
+		connectPeers = cfg.ConnectPeers
+	}
+
+	c.maxIncoming = cfg.MaxInboundPeers
+	c.targetOutgoing = cfg.TargetOutboundPeers
+
+	for _, connectPeer := range connectPeers {
+		c.pendingRequested[connectPeer] = &connectionRequest{
+			address:     connectPeer,
+			isPermanent: true,
+		}
+	}
+
+	return c, nil
+}
+
+// Start begins the operation of the ConnectionManager
+func (c *ConnectionManager) Start() {
+	spawn("ConnectionManager.connectionsLoop", c.connectionsLoop)
+}
+
+// Stop halts the operation of the ConnectionManager
+func (c *ConnectionManager) Stop() {
+	atomic.StoreUint32(&c.stop, 1)
+
+	for _, connection := range c.netAdapter.Connections() {
+		connection.Disconnect()
+	}
+
+	c.loopTicker.Stop()
+}
+
+func (c *ConnectionManager) run() {
+	c.resetLoopChan <- struct{}{}
+}
+
+func (c *ConnectionManager) initiateConnection(address string) error {
+	log.Infof("Connecting to %s", address)
+	return c.netAdapter.Connect(address)
+}
+
+const connectionsLoopInterval = 30 * time.Second
+
+func (c *ConnectionManager) connectionsLoop() {
+	for atomic.LoadUint32(&c.stop) == 0 {
+		connections := c.netAdapter.Connections()
+
+		// We convert the connections list to a set, so that connections can be found quickly
+		// Then we go over the set, classifying connection by category: requested, outgoing or incoming.
+		// Every step removes all matching connections so that once we get to checkIncomingConnections -
+		// the only connections left are the incoming ones
+		connSet := convertToSet(connections)
+
+		c.checkRequestedConnections(connSet)
+
+		c.checkOutgoingConnections(connSet)
+
+		c.checkIncomingConnections(connSet)
+
+		c.waitTillNextIteration()
+	}
+}
+
+// ConnectionCount returns the count of the connected connections
+func (c *ConnectionManager) ConnectionCount() int {
+	return c.netAdapter.ConnectionCount()
+}
+
+// Ban marks the given netConnection as banned
+func (c *ConnectionManager) Ban(netConnection *netadapter.NetConnection) error {
+	return c.addressManager.Ban(netConnection.NetAddress())
+}
+
+// IsBanned returns whether the given netConnection is banned
+func (c *ConnectionManager) IsBanned(netConnection *netadapter.NetConnection) (bool, error) {
+	return c.addressManager.IsBanned(netConnection.NetAddress())
+}
+
+func (c *ConnectionManager) waitTillNextIteration() {
+	select {
+	case <-c.resetLoopChan:
+		c.loopTicker.Stop()
+		c.loopTicker = time.NewTicker(connectionsLoopInterval)
+	case <-c.loopTicker.C:
+	}
+}

connmanager/incoming_connections.go

@@ -0,0 +1,20 @@
+package connmanager
+
+// checkIncomingConnections makes sure there's no more than maxIncoming incoming connections
+// if there are - it randomly disconnects enough to go below that number
+func (c *ConnectionManager) checkIncomingConnections(incomingConnectionSet connectionSet) {
+	if len(incomingConnectionSet) <= c.maxIncoming {
+		return
+	}
+
+	numConnectionsOverMax := len(incomingConnectionSet) - c.maxIncoming
+	// randomly disconnect nodes until the number of incoming connections is smaller than maxIncoming
+	for _, connection := range incomingConnectionSet {
+		connection.Disconnect()
+
+		numConnectionsOverMax--
+		if numConnectionsOverMax == 0 {
+			break
+		}
+	}
+}

connmanager/log.go

@@ -0,0 +1,9 @@
+package connmanager
+
+import (
+	"github.com/kaspanet/kaspad/logger"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.CMGR)
+var spawn = panics.GoroutineWrapperFunc(log)

connmanager/outgoing_connections.go

@@ -0,0 +1,61 @@
+package connmanager
+
+// checkOutgoingConnections goes over all activeOutgoing and makes sure they are still active.
+// Then it opens connections so that we have targetOutgoing active connections
+func (c *ConnectionManager) checkOutgoingConnections(connSet connectionSet) {
+	for address := range c.activeOutgoing {
+		connection, ok := connSet.get(address)
+		if ok { // connection is still connected
+			connSet.remove(connection)
+			continue
+		}
+
+		// if connection is dead - remove from list of active ones
+		delete(c.activeOutgoing, address)
+	}
+
+	liveConnections := len(c.activeOutgoing)
+	if c.targetOutgoing == liveConnections {
+		return
+	}
+
+	log.Debugf("Have got %d outgoing connections out of target %d, adding %d more",
+		liveConnections, c.targetOutgoing, c.targetOutgoing-liveConnections)
+
+	connectionsNeededCount := c.targetOutgoing - len(c.activeOutgoing)
+	connectionAttempts := connectionsNeededCount * 2
+	for i := 0; i < connectionAttempts; i++ {
+		// Return in case we've already reached or surpassed our target
+		if len(c.activeOutgoing) >= c.targetOutgoing {
+			return
+		}
+
+		address := c.addressManager.GetAddress()
+		if address == nil {
+			log.Warnf("No more addresses available")
+			return
+		}
+
+		netAddress := address.NetAddress()
+		tcpAddress := netAddress.TCPAddress()
+		addressString := tcpAddress.String()
+		isBanned, err := c.addressManager.IsBanned(netAddress)
+		if err != nil {
+			log.Infof("Couldn't resolve whether %s is banned: %s", addressString, err)
+			continue
+		}
+		if isBanned {
+			continue
+		}
+
+		c.addressManager.Attempt(netAddress)
+		err = c.initiateConnection(addressString)
+		if err != nil {
+			log.Infof("Couldn't connect to %s: %s", addressString, err)
+			continue
+		}
+
+		c.addressManager.Connected(netAddress)
+		c.activeOutgoing[addressString] = struct{}{}
+	}
+}

connmgr/README.md

@@ -1,27 +0,0 @@
-connmgr
-=======
-
-[![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/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,779 +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"
-	"github.com/kaspanet/kaspad/addrmgr"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/wire"
-	"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
-)
-
-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")
-
-	//ErrAddressManagerNil is used to indicate that Address Manager cannot be nil in the configuration.
-	ErrAddressManagerNil = errors.New("Config: Address manager cannot be nil")
-)
-
-// 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.TCPAddr
-	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()
-	defer c.stateMtx.Unlock()
-	c.state = state
-}
-
-// 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()
-	defer c.stateMtx.RUnlock()
-	state := c.state
-	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)
-
-	// OnConnectionFailed is a callback that is fired when a new outbound
-	// connection has failed to be established.
-	OnConnectionFailed func(*ConnReq)
-
-	// OnDisconnection is a callback that is fired when an outbound
-	// connection is disconnected.
-	OnDisconnection func(*ConnReq)
-
-	AddrManager *addrmgr.AddrManager
-
-	// 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
-
-	addressMtx         sync.Mutex
-	usedOutboundGroups map[string]int64
-	usedAddresses      map[string]struct{}
-
-	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)
-		})
-	} else {
-		if c.Addr != nil {
-			cm.releaseAddress(c.Addr)
-		}
-		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)
-		} else {
-			spawn(cm.NewConnReq)
-		}
-	}
-}
-
-func (cm *ConnManager) releaseAddress(addr *net.TCPAddr) {
-	cm.addressMtx.Lock()
-	defer cm.addressMtx.Unlock()
-
-	groupKey := usedOutboundGroupsKey(addr)
-	cm.usedOutboundGroups[groupKey]--
-	if cm.usedOutboundGroups[groupKey] < 0 {
-		panic(fmt.Errorf("cm.usedOutboundGroups[%s] has a negative value of %d. This should never happen", groupKey, cm.usedOutboundGroups[groupKey]))
-	}
-	delete(cm.usedAddresses, usedAddressesKey(addr))
-}
-
-func (cm *ConnManager) markAddressAsUsed(addr *net.TCPAddr) {
-	cm.usedOutboundGroups[usedOutboundGroupsKey(addr)]++
-	cm.usedAddresses[usedAddressesKey(addr)] = struct{}{}
-}
-
-func (cm *ConnManager) isOutboundGroupUsed(addr *net.TCPAddr) bool {
-	_, ok := cm.usedOutboundGroups[usedOutboundGroupsKey(addr)]
-	return ok
-}
-
-func (cm *ConnManager) isAddressUsed(addr *net.TCPAddr) bool {
-	_, ok := cm.usedAddresses[usedAddressesKey(addr)]
-	return ok
-}
-
-func usedOutboundGroupsKey(addr *net.TCPAddr) string {
-	// A fake service flag is used since it doesn't affect the group key.
-	na := wire.NewNetAddress(addr, wire.SFNodeNetwork)
-	return addrmgr.GroupKey(na)
-}
-
-func usedAddressesKey(addr *net.TCPAddr) string {
-	return addr.String()
-}
-
-// 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
-
-				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 {
-					spawn(func() {
-						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.
-				// The connection request is re added to the
-				// pending map, so that subsequent processing
-				// of connections and failures do not ignore
-				// the request.
-				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)
-
-				if cm.cfg.OnConnectionFailed != nil {
-					cm.cfg.OnConnectionFailed(connReq)
-				}
-			}
-
-		case <-cm.quit:
-			break out
-		}
-	}
-
-	cm.wg.Done()
-	log.Trace("Connection handler done")
-}
-
-// NotifyConnectionRequestComplete notifies the connection
-// manager that a peer had been successfully connected and
-// marked as good.
-func (cm *ConnManager) NotifyConnectionRequestComplete() {
-	cm.failedAttempts = 0
-}
-
-// NewConnReq creates a new connection request and connects to the
-// corresponding address.
-func (cm *ConnManager) NewConnReq() {
-	if atomic.LoadInt32(&cm.stop) != 0 {
-		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
-	}
-	err := cm.associateAddressToConnReq(c)
-	if err != nil {
-		select {
-		case cm.requests <- handleFailed{c, err}:
-		case <-cm.quit:
-		}
-		return
-	}
-
-	cm.connect(c)
-}
-
-func (cm *ConnManager) associateAddressToConnReq(c *ConnReq) error {
-	cm.addressMtx.Lock()
-	defer cm.addressMtx.Unlock()
-
-	addr, err := cm.getNewAddress()
-	if err != nil {
-		return err
-	}
-
-	cm.markAddressAsUsed(addr)
-	c.Addr = addr
-	return nil
-}
-
-// Connect assigns an id and dials a connection to the address of the
-// connection request.
-func (cm *ConnManager) Connect(c *ConnReq) error {
-	err := func() error {
-		cm.addressMtx.Lock()
-		defer cm.addressMtx.Unlock()
-
-		if cm.isAddressUsed(c.Addr) {
-			return fmt.Errorf("address %s is already in use", c.Addr)
-		}
-		cm.markAddressAsUsed(c.Addr)
-		return nil
-	}()
-	if err != nil {
-		return err
-	}
-
-	cm.connect(c)
-	return nil
-}
-
-// connect assigns an id and dials a connection to the address of the
-// connection request. This function assumes that the connection address
-// has checked and already marked as used.
-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
-		}
-		spawn(func() {
-			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)
-
-	// 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 _, listener := range cm.cfg.Listeners {
-			// Declaring this variable is necessary as it needs be declared in the same
-			// scope of the anonymous function below it.
-			listenerCopy := listener
-			cm.wg.Add(1)
-			spawn(func() {
-				cm.listenHandler(listenerCopy)
-			})
-		}
-	}
-
-	for i := atomic.LoadUint64(&cm.connReqCount); i < uint64(cm.cfg.TargetOutbound); i++ {
-		spawn(cm.NewConnReq)
-	}
-}
-
-// Wait blocks until the connection manager halts gracefully.
-func (cm *ConnManager) Wait() {
-	cm.wg.Wait()
-}
-
-// 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")
-}
-
-func (cm *ConnManager) getNewAddress() (*net.TCPAddr, error) {
-	for tries := 0; tries < 100; tries++ {
-		addr := cm.cfg.AddrManager.GetAddress()
-		if addr == nil {
-			break
-		}
-
-		// Check if there's already a connection to the same address.
-		netAddr := addr.NetAddress().TCPAddress()
-		if cm.isAddressUsed(netAddr) {
-			continue
-		}
-
-		// Address will not be invalid, local or unroutable
-		// because addrmanager rejects those on addition.
-		// Just check that we don't already have an address
-		// in the same group so that we are not connecting
-		// to the same network segment at the expense of
-		// others.
-		//
-		// Networks that accept unroutable connections are exempt
-		// from this rule, since they're meant to run within a
-		// private subnet, like 10.0.0.0/16.
-		if !config.ActiveConfig().NetParams().AcceptUnroutable && cm.isOutboundGroupUsed(netAddr) {
-			continue
-		}
-
-		// only allow recent nodes (10mins) after we failed 30
-		// times
-		if tries < 30 && time.Since(addr.LastAttempt()) < 10*time.Minute {
-			continue
-		}
-
-		// allow nondefault ports after 50 failed tries.
-		if tries < 50 && fmt.Sprintf("%d", netAddr.Port) !=
-			config.ActiveConfig().NetParams().DefaultPort {
-			continue
-		}
-
-		return netAddr, nil
-	}
-	return nil, ErrNoAddress
-}
-
-// 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, errors.WithStack(ErrDialNil)
-	}
-	if cfg.AddrManager == nil {
-		return nil, errors.WithStack(ErrAddressManagerNil)
-	}
-	// Default to sane values
-	if cfg.RetryDuration <= 0 {
-		cfg.RetryDuration = defaultRetryDuration
-	}
-	cm := ConnManager{
-		cfg:                *cfg, // Copy so caller can't mutate
-		requests:           make(chan interface{}),
-		quit:               make(chan struct{}),
-		usedAddresses:      make(map[string]struct{}),
-		usedOutboundGroups: make(map[string]int64),
-	}
-	return &cm, nil
-}

connmgr/connmanager_test.go

@@ -1,972 +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"
-	"github.com/kaspanet/kaspad/addrmgr"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/pkg/errors"
-	"io"
-	"io/ioutil"
-	"net"
-	"os"
-	"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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	_, err := New(&Config{})
-	if !errors.Is(err, ErrDialNil) {
-		t.Fatalf("New expected error: %s, got %s", ErrDialNil, err)
-	}
-
-	_, err = New(&Config{
-		Dial: mockDialer,
-	})
-	if !errors.Is(err, ErrAddressManagerNil) {
-		t.Fatalf("New expected error: %s, got %s", ErrAddressManagerNil, err)
-	}
-
-	amgr, teardown := addressManagerForTest(t, "TestNewConfig", 10)
-	defer teardown()
-
-	_, err = New(&Config{
-		Dial:        mockDialer,
-		AddrManager: amgr,
-	})
-	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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	connected := make(chan *ConnReq)
-	disconnected := make(chan *ConnReq)
-
-	amgr, teardown := addressManagerForTest(t, "TestStartStop", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		TargetOutbound: 1,
-		AddrManager:    amgr,
-		Dial:           mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		OnDisconnection: func(c *ConnReq) {
-			disconnected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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,
-	}
-	err = cmgr.Connect(cr)
-	if err != nil {
-		t.Fatalf("Connect error: %s", err)
-	}
-	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
-	}
-}
-
-func overrideActiveConfig() func() {
-	originalActiveCfg := config.ActiveConfig()
-	config.SetActiveConfig(&config.Config{
-		Flags: &config.Flags{
-			NetworkFlags: config.NetworkFlags{
-				ActiveNetParams: &dagconfig.SimnetParams},
-		},
-	})
-	return func() {
-		// Give some extra time to all open NewConnReq goroutines
-		// to finish before restoring the active config to prevent
-		// potential panics.
-		time.Sleep(10 * time.Millisecond)
-
-		config.SetActiveConfig(originalActiveCfg)
-	}
-}
-
-func addressManagerForTest(t *testing.T, testName string, numAddresses uint8) (*addrmgr.AddrManager, func()) {
-	amgr, teardown := createEmptyAddressManagerForTest(t, testName)
-
-	for i := uint8(0); i < numAddresses; i++ {
-		ip := fmt.Sprintf("173.%d.115.66:16511", i)
-		err := amgr.AddAddressByIP(ip, nil)
-		if err != nil {
-			t.Fatalf("AddAddressByIP unexpectedly failed to add IP %s: %s", ip, err)
-		}
-	}
-
-	return amgr, teardown
-}
-
-func createEmptyAddressManagerForTest(t *testing.T, testName string) (*addrmgr.AddrManager, func()) {
-	path, err := ioutil.TempDir("", fmt.Sprintf("%s-addressmanager", testName))
-	if err != nil {
-		t.Fatalf("createEmptyAddressManagerForTest: TempDir unexpectedly "+
-			"failed: %s", err)
-	}
-
-	return addrmgr.New(path, nil, nil), func() {
-		// Wait for the connection manager to finish
-		time.Sleep(10 * time.Millisecond)
-
-		err := os.RemoveAll(path)
-		if err != nil {
-			t.Fatalf("couldn't remove path %s", path)
-		}
-	}
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	connected := make(chan *ConnReq)
-	amgr, teardown := addressManagerForTest(t, "TestConnectMode", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		TargetOutbound: 0,
-		Dial:           mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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()
-	cmgr.Wait()
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	const numAddressesInAddressManager = 10
-	targetOutbound := uint32(numAddressesInAddressManager - 2)
-	connected := make(chan *ConnReq)
-
-	amgr, teardown := addressManagerForTest(t, "TestTargetOutbound", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		TargetOutbound: targetOutbound,
-		Dial:           mockDialer,
-		AddrManager:    amgr,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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()
-	cmgr.Wait()
-}
-
-// TestDuplicateOutboundConnections tests that connection requests cannot use an already used address.
-// It checks it by creating one connection request for each address in the address manager, so that
-// the next connection request will have to fail because no unused address will be available.
-func TestDuplicateOutboundConnections(t *testing.T) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	const numAddressesInAddressManager = 10
-	targetOutbound := uint32(numAddressesInAddressManager - 1)
-	connected := make(chan struct{})
-	failedConnections := make(chan struct{})
-
-	amgr, teardown := addressManagerForTest(t, "TestDuplicateOutboundConnections", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		TargetOutbound: targetOutbound,
-		Dial:           mockDialer,
-		AddrManager:    amgr,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- struct{}{}
-		},
-		OnConnectionFailed: func(_ *ConnReq) {
-			failedConnections <- struct{}{}
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", err)
-	}
-	cmgr.Start()
-	for i := uint32(0); i < targetOutbound; i++ {
-		<-connected
-	}
-
-	time.Sleep(time.Millisecond)
-
-	// Here we check that making a manual connection request beyond the target outbound connection
-	// doesn't fail, so we can know that the reason such connection request will fail is an address
-	// related issue.
-	cmgr.NewConnReq()
-	select {
-	case <-connected:
-		break
-	case <-time.After(time.Millisecond):
-		t.Fatalf("connection request unexpectedly didn't connect")
-	}
-
-	select {
-	case <-failedConnections:
-		t.Fatalf("a connection request unexpectedly failed")
-	case <-time.After(time.Millisecond):
-		break
-	}
-
-	// After we created numAddressesInAddressManager connection requests, this request should fail
-	// because there aren't any more available addresses.
-	cmgr.NewConnReq()
-	select {
-	case <-connected:
-		t.Fatalf("connection request unexpectedly succeeded")
-	case <-time.After(time.Millisecond):
-		t.Fatalf("connection request didn't fail as expected")
-	case <-failedConnections:
-		break
-	}
-
-	cmgr.Stop()
-	cmgr.Wait()
-}
-
-// TestSameOutboundGroupConnections tests that connection requests cannot use an address with an already used
-// address CIDR group.
-// It checks it by creating an address manager with only two addresses, that both belong to the same CIDR group
-// and checks that the second connection request fails.
-func TestSameOutboundGroupConnections(t *testing.T) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	amgr, teardown := createEmptyAddressManagerForTest(t, "TestSameOutboundGroupConnections")
-	defer teardown()
-
-	err := amgr.AddAddressByIP("173.190.115.66:16511", nil)
-	if err != nil {
-		t.Fatalf("AddAddressByIP unexpectedly failed: %s", err)
-	}
-
-	err = amgr.AddAddressByIP("173.190.115.67:16511", nil)
-	if err != nil {
-		t.Fatalf("AddAddressByIP unexpectedly failed: %s", err)
-	}
-
-	connected := make(chan struct{})
-	failedConnections := make(chan struct{})
-	cmgr, err := New(&Config{
-		TargetOutbound: 0,
-		Dial:           mockDialer,
-		AddrManager:    amgr,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- struct{}{}
-		},
-		OnConnectionFailed: func(_ *ConnReq) {
-			failedConnections <- struct{}{}
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", err)
-	}
-
-	cmgr.Start()
-
-	cmgr.NewConnReq()
-	select {
-	case <-connected:
-		break
-	case <-time.After(time.Millisecond):
-		t.Fatalf("connection request unexpectedly didn't connect")
-	}
-
-	select {
-	case <-failedConnections:
-		t.Fatalf("a connection request unexpectedly failed")
-	case <-time.After(time.Millisecond):
-		break
-	}
-
-	cmgr.NewConnReq()
-	select {
-	case <-connected:
-		t.Fatalf("connection request unexpectedly succeeded")
-	case <-time.After(time.Millisecond):
-		t.Fatalf("connection request didn't fail as expected")
-	case <-failedConnections:
-		break
-	}
-
-	cmgr.Stop()
-	cmgr.Wait()
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	connected := make(chan *ConnReq)
-	disconnected := make(chan *ConnReq)
-
-	amgr, teardown := addressManagerForTest(t, "TestRetryPermanent", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		RetryDuration:  time.Millisecond,
-		TargetOutbound: 0,
-		Dial:           mockDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		OnDisconnection: func(c *ConnReq) {
-			disconnected <- c
-		},
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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
-
-	// Wait for status to be updated
-	time.Sleep(10 * time.Millisecond)
-	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()
-	cmgr.Wait()
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	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")
-		}
-	}
-
-	amgr, teardown := addressManagerForTest(t, "TestMaxRetryDuration", 10)
-	defer teardown()
-
-	connected := make(chan *ConnReq)
-	cmgr, err := New(&Config{
-		RetryDuration:  time.Millisecond,
-		TargetOutbound: 1,
-		Dial:           timedDialer,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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")
-	}
-	cmgr.Stop()
-	cmgr.Wait()
-}
-
-// TestNetworkFailure tests that the connection manager handles a network
-// failure gracefully.
-func TestNetworkFailure(t *testing.T) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	var dials uint32
-	errDialer := func(net net.Addr) (net.Conn, error) {
-		atomic.AddUint32(&dials, 1)
-		return nil, errors.New("network down")
-	}
-
-	amgr, teardown := addressManagerForTest(t, "TestNetworkFailure", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		TargetOutbound: 5,
-		RetryDuration:  5 * time.Millisecond,
-		Dial:           errDialer,
-		AddrManager:    amgr,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			t.Fatalf("network failure: got unexpected connection - %v", c.Addr)
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", err)
-	}
-	cmgr.Start()
-	time.Sleep(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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	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")
-	}
-
-	amgr, teardown := addressManagerForTest(t, "TestStopFailed", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		Dial:        waitDialer,
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	// 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")
-	}
-
-	amgr, teardown := addressManagerForTest(t, "TestRemovePendingConnection", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		Dial:        indefiniteDialer,
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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()
-	cmgr.Wait()
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	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)
-
-	amgr, teardown := addressManagerForTest(t, "TestCancelIgnoreDelayedConnection", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		Dial:          failingDialer,
-		RetryDuration: retryTimeout,
-		OnConnection: func(c *ConnReq, conn net.Conn) {
-			connected <- c
-		},
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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,
-		},
-	}
-	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):
-	}
-	cmgr.Stop()
-	cmgr.Wait()
-}
-
-// 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) {
-	restoreConfig := overrideActiveConfig()
-	defer restoreConfig()
-
-	// 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}
-
-	amgr, teardown := addressManagerForTest(t, "TestListeners", 10)
-	defer teardown()
-
-	cmgr, err := New(&Config{
-		Listeners: listeners,
-		OnAccept: func(conn net.Conn) {
-			receivedConns <- conn
-		},
-		Dial:        mockDialer,
-		AddrManager: amgr,
-	})
-	if err != nil {
-		t.Fatalf("unexpected error from New: %s", 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()
-	defer s.mtx.Unlock()
-	r := fmt.Sprintf("persistent %d + transient %f at %d = %d as of now",
-		s.persistent, s.transient, s.lastUnix, s.Int())
-	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()
-	defer s.mtx.Unlock()
-	r := s.int(time.Now())
-	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()
-	defer s.mtx.Unlock()
-	r := s.increase(persistent, transient, time.Now())
-	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()
-	defer s.mtx.Unlock()
-	s.persistent = 0
-	s.transient = 0
-	s.lastUnix = 0
-}
-
-// 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()
-
-	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.go

@@ -5,30 +5,16 @@
 package dagconfig
 
 import (
-	"math"
-	"time"
-
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 	"github.com/kaspanet/kaspad/wire"
 )
 
-var genesisTxIns = []*wire.TxIn{
-	{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{
-			0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
-			0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
 var genesisTxOuts = []*wire.TxOut{}
 
 var genesisTxPayload = []byte{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
 	0x17,                                           // Varint
 	0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5, 0x49, // OP-TRUE p2sh
 	0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71, 0xc7,
@@ -37,58 +23,46 @@ var genesisTxPayload = []byte{
 
 // genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
 // the main network.
-var genesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, genesisTxIns, genesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, genesisTxPayload)
+var genesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, genesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, genesisTxPayload)
 
 // genesisHash is the hash of the first block in the block DAG for the main
 // network (genesis block).
 var genesisHash = daghash.Hash{
-	0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
-	0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
-	0x38, 0x7e, 0xd1, 0xd5, 0x8c, 0x42, 0x59, 0x1a,
-	0x31, 0xac, 0x9a, 0xa6, 0x2e, 0xd5, 0x2b, 0x0f,
+	0xfa, 0x00, 0xbd, 0xcb, 0x46, 0x74, 0xc5, 0xdb,
+	0xf7, 0x63, 0xcb, 0x78, 0x7a, 0x94, 0xc5, 0xbf,
+	0xd4, 0x81, 0xd3, 0x52, 0x2d, 0x79, 0xac, 0x57,
+	0x73, 0xe6, 0x14, 0x7e, 0x15, 0xef, 0x85, 0x27,
 }
 
 // genesisMerkleRoot is the hash of the first transaction in the genesis block
 // for the main network.
 var genesisMerkleRoot = daghash.Hash{
-	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,
+	0xca, 0x85, 0x56, 0x27, 0xc7, 0x6a, 0xb5, 0x7a,
+	0x26, 0x1d, 0x63, 0x62, 0x1e, 0x57, 0x21, 0xf0,
+	0x5e, 0x60, 0x1f, 0xee, 0x1d, 0x4d, 0xaa, 0x53,
+	0x72, 0xe1, 0x16, 0xda, 0x4b, 0xb3, 0xd8, 0x0e,
 }
 
 // genesisBlock defines the genesis block of the block DAG which serves as the
 // public transaction ledger for the main network.
 var genesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
-		Version:              1,
+		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &genesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            time.Unix(0x5cdac4b0, 0),
+		Timestamp:            mstime.UnixMilliseconds(0x1730a81bdb4),
 		Bits:                 0x207fffff,
 		Nonce:                0x1,
 	},
 	Transactions: []*wire.MsgTx{genesisCoinbaseTx},
 }
 
-var devnetGenesisTxIns = []*wire.TxIn{
-	{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{
-			0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
-			0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
 var devnetGenesisTxOuts = []*wire.TxOut{}
 
 var devnetGenesisTxPayload = []byte{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
 	0x17,                                           // Varint
 	0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5, 0x49, // OP-TRUE p2sh
 	0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71, 0xc7,
@@ -98,58 +72,46 @@ var devnetGenesisTxPayload = []byte{
 
 // devnetGenesisCoinbaseTx is the coinbase transaction for the genesis blocks for
 // the development network.
-var devnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, devnetGenesisTxIns, devnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, devnetGenesisTxPayload)
+var devnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, devnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, devnetGenesisTxPayload)
 
 // devGenesisHash is the hash of the first block in the block DAG for the development
 // network (genesis block).
 var devnetGenesisHash = daghash.Hash{
-	0x17, 0x59, 0x5c, 0x09, 0xdd, 0x1a, 0x51, 0x65,
-	0x14, 0xbc, 0x19, 0xff, 0x29, 0xea, 0xf3, 0xcb,
-	0xe2, 0x76, 0xf0, 0xc7, 0x86, 0xf8, 0x0c, 0x53,
-	0x59, 0xbe, 0xee, 0x0c, 0x2b, 0x5d, 0x00, 0x00,
+	0x2e, 0x03, 0x7d, 0x31, 0x09, 0x56, 0x82, 0x72,
+	0x1d, 0x49, 0x39, 0xf3, 0x7d, 0xd5, 0xc8, 0xf4,
+	0xef, 0x4f, 0xcd, 0xeb, 0x1d, 0x95, 0xad, 0x6e,
+	0x02, 0x4f, 0x52, 0xf2, 0xd6, 0x66, 0x00, 0x00,
 }
 
 // devnetGenesisMerkleRoot is the hash of the first transaction in the genesis block
 // for the devopment network.
 var devnetGenesisMerkleRoot = daghash.Hash{
-	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,
+	0x68, 0x60, 0xe7, 0x77, 0x47, 0x74, 0x7f, 0xd5,
+	0x55, 0x58, 0x8a, 0xb5, 0xc2, 0x29, 0x0c, 0xa6,
+	0x65, 0x44, 0xb4, 0x4f, 0xfa, 0x31, 0x7a, 0xfa,
+	0x55, 0xe0, 0xcf, 0xac, 0x9c, 0x86, 0x30, 0x2a,
 }
 
 // devnetGenesisBlock defines the genesis block of the block DAG which serves as the
 // public transaction ledger for the development network.
 var devnetGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
-		Version:              1,
+		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &devnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            time.Unix(0x5e15e758, 0),
+		Timestamp:            mstime.UnixMilliseconds(0x17305b05694),
 		Bits:                 0x1e7fffff,
-		Nonce:                0x282ac,
+		Nonce:                0x10bb,
 	},
 	Transactions: []*wire.MsgTx{devnetGenesisCoinbaseTx},
 }
 
-var regtestGenesisTxIns = []*wire.TxIn{
-	{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{
-			0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
-			0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
 var regtestGenesisTxOuts = []*wire.TxOut{}
 
 var regtestGenesisTxPayload = []byte{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
 	0x17,                                           // Varint
 	0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5, 0x49, // OP-TRUE p2sh
 	0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71, 0xc7,
@@ -159,58 +121,46 @@ var regtestGenesisTxPayload = []byte{
 
 // regtestGenesisCoinbaseTx is the coinbase transaction for
 // the genesis blocks for the regtest network.
-var regtestGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, regtestGenesisTxIns, regtestGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, regtestGenesisTxPayload)
+var regtestGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, regtestGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, regtestGenesisTxPayload)
 
 // devGenesisHash is the hash of the first block in the block DAG for the development
 // network (genesis block).
 var regtestGenesisHash = daghash.Hash{
-	0xfc, 0x02, 0x19, 0x6f, 0x79, 0x7a, 0xed, 0x2d,
-	0x0f, 0x31, 0xa5, 0xbd, 0x32, 0x13, 0x29, 0xc7,
-	0x7c, 0x0c, 0x5c, 0x1a, 0x5b, 0x7c, 0x20, 0x68,
-	0xb7, 0xc9, 0x9f, 0x61, 0x13, 0x11, 0x00, 0x00,
+	0xda, 0x23, 0x61, 0x5e, 0xf6, 0x2a, 0x95, 0x27,
+	0x7f, 0x5a, 0x40, 0xd5, 0x91, 0x97, 0x1c, 0xef,
+	0xd5, 0x86, 0xac, 0xac, 0x82, 0xb3, 0xc9, 0x43,
+	0xd3, 0x49, 0x5f, 0x7e, 0x93, 0x0b, 0x35, 0x2d,
 }
 
 // regtestGenesisMerkleRoot is the hash of the first transaction in the genesis block
 // for the regtest.
 var regtestGenesisMerkleRoot = daghash.Hash{
-	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,
+	0x1e, 0x08, 0xae, 0x1f, 0x43, 0xf5, 0xfc, 0x24,
+	0xe6, 0xec, 0x54, 0x5b, 0xf7, 0x52, 0x99, 0xe4,
+	0xcc, 0x4c, 0xa0, 0x79, 0x41, 0xfc, 0xbe, 0x76,
+	0x72, 0x4c, 0x7e, 0xd8, 0xa3, 0x43, 0x65, 0x94,
 }
 
 // regtestGenesisBlock defines the genesis block of the block DAG which serves as the
 // public transaction ledger for the development network.
 var regtestGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
-		Version:              1,
+		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &regtestGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            time.Unix(0x5e15e2d8, 0),
-		Bits:                 0x1e7fffff,
-		Nonce:                0x15a6,
+		Timestamp:            mstime.UnixMilliseconds(0x1730a958ac4),
+		Bits:                 0x207fffff,
+		Nonce:                0x0,
 	},
 	Transactions: []*wire.MsgTx{regtestGenesisCoinbaseTx},
 }
 
-var simnetGenesisTxIns = []*wire.TxIn{
-	{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{
-			0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
-			0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
 var simnetGenesisTxOuts = []*wire.TxOut{}
 
 var simnetGenesisTxPayload = []byte{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
 	0x17,                                           // Varint
 	0xa9, 0x14, 0xda, 0x17, 0x45, 0xe9, 0xb5, 0x49, // OP-TRUE p2sh
 	0xbd, 0x0b, 0xfa, 0x1a, 0x56, 0x99, 0x71, 0xc7,
@@ -219,96 +169,84 @@ var simnetGenesisTxPayload = []byte{
 }
 
 // simnetGenesisCoinbaseTx is the coinbase transaction for the simnet genesis block.
-var simnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, simnetGenesisTxIns, simnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, simnetGenesisTxPayload)
+var simnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, simnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, simnetGenesisTxPayload)
 
 // simnetGenesisHash is the hash of the first block in the block DAG for
 // the simnet (genesis block).
 var simnetGenesisHash = daghash.Hash{
-	0xff, 0x69, 0xcc, 0x45, 0x45, 0x74, 0x5b, 0xf9,
-	0xd5, 0x4e, 0x43, 0x56, 0x4f, 0x1b, 0xdf, 0x31,
-	0x09, 0xb7, 0x76, 0xaa, 0x2a, 0x33, 0x35, 0xc9,
-	0xa1, 0x80, 0xe0, 0x92, 0xbb, 0xae, 0xcd, 0x49,
+	0x86, 0x27, 0xdc, 0x5e, 0xa9, 0x38, 0xc7, 0xa5,
+	0x7a, 0x18, 0xcd, 0xe7, 0xda, 0xed, 0x13, 0xe0,
+	0x24, 0x1b, 0xab, 0xfe, 0xbd, 0xe6, 0x6f, 0xd3,
+	0x95, 0x34, 0x81, 0x1c, 0x57, 0xd1, 0xc4, 0x3f,
 }
 
 // simnetGenesisMerkleRoot is the hash of the first transaction in the genesis block
 // for the devopment network.
 var simnetGenesisMerkleRoot = daghash.Hash{
-	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,
+	0x47, 0x52, 0xc7, 0x23, 0x70, 0x4d, 0x89, 0x17,
+	0xbd, 0x44, 0x26, 0xfa, 0x82, 0x7e, 0x1b, 0xa9,
+	0xc6, 0x46, 0x1a, 0x37, 0x5a, 0x73, 0x88, 0x09,
+	0xe8, 0x17, 0xff, 0xb1, 0xdb, 0x1a, 0xb3, 0x3f,
 }
 
 // simnetGenesisBlock defines the genesis block of the block DAG which serves as the
 // public transaction ledger for the development network.
 var simnetGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
-		Version:              1,
+		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &simnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            time.Unix(0x5e15d31c, 0),
+		Timestamp:            mstime.UnixMilliseconds(0x173001df3d5),
 		Bits:                 0x207fffff,
-		Nonce:                0x3,
+		Nonce:                0x0,
 	},
 	Transactions: []*wire.MsgTx{simnetGenesisCoinbaseTx},
 }
 
-var testnetGenesisTxIns = []*wire.TxIn{
-	{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  daghash.TxID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{
-			0x00, 0x00, 0x0b, 0x2f, 0x50, 0x32, 0x53, 0x48,
-			0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
 var testnetGenesisTxOuts = []*wire.TxOut{}
 
 var testnetGenesisTxPayload = []byte{
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Blue score
 	0x01,                                                                         // Varint
 	0x00,                                                                         // OP-FALSE
 	0x6b, 0x61, 0x73, 0x70, 0x61, 0x2d, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, // kaspa-testnet
 }
 
 // testnetGenesisCoinbaseTx is the coinbase transaction for the testnet genesis block.
-var testnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, testnetGenesisTxIns, testnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, testnetGenesisTxPayload)
+var testnetGenesisCoinbaseTx = wire.NewSubnetworkMsgTx(1, []*wire.TxIn{}, testnetGenesisTxOuts, subnetworkid.SubnetworkIDCoinbase, 0, testnetGenesisTxPayload)
 
 // testnetGenesisHash is the hash of the first block in the block DAG for the test
 // network (genesis block).
 var testnetGenesisHash = daghash.Hash{
-	0x22, 0x15, 0x34, 0xa9, 0xff, 0x10, 0xdd, 0x47,
-	0xcd, 0x21, 0x11, 0x25, 0xc5, 0x6d, 0x85, 0x9a,
-	0x97, 0xc8, 0x63, 0x63, 0x79, 0x40, 0x80, 0x04,
-	0x74, 0xe6, 0x29, 0x7b, 0xbc, 0x08, 0x00, 0x00,
+	0x34, 0x8c, 0x71, 0x99, 0x70, 0x13, 0x00, 0xe5,
+	0xf5, 0x35, 0x98, 0x45, 0x89, 0xc7, 0xa2, 0xab,
+	0xd0, 0x8f, 0x26, 0x00, 0x9c, 0xc6, 0x6b, 0xa3,
+	0x20, 0x88, 0x86, 0x55, 0x3f, 0x61, 0x00, 0x00,
 }
 
 // testnetGenesisMerkleRoot is the hash of the first transaction in the genesis block
 // for testnet.
 var testnetGenesisMerkleRoot = daghash.Hash{
-	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,
+	0xA0, 0xA1, 0x3D, 0xFD, 0x86, 0x41, 0x35, 0xC8,
+	0xBD, 0xBB, 0xE6, 0x37, 0x35, 0xBB, 0x4C, 0x51,
+	0x11, 0x7B, 0x26, 0x90, 0x15, 0x64, 0x0F, 0x42,
+	0x6D, 0x2B, 0x6F, 0x37, 0x4D, 0xC1, 0xA9, 0x72,
 }
 
 // testnetGenesisBlock defines the genesis block of the block DAG which serves as the
 // public transaction ledger for testnet.
 var testnetGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
-		Version:              1,
+		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &testnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            time.Unix(0x5e15adfe, 0),
+		Timestamp:            mstime.UnixMilliseconds(0x1730a66a9d9),
 		Bits:                 0x1e7fffff,
-		Nonce:                0x20a1,
+		Nonce:                0x162ca,
 	},
 	Transactions: []*wire.MsgTx{testnetGenesisCoinbaseTx},
 }

dagconfig/genesis_test.go

@@ -133,7 +133,7 @@ func TestDevnetGenesisBlock(t *testing.T) {
 		t.Fatalf("TestDevnetGenesisBlock: Genesis block does not "+
 			"appear valid - got %v, want %v",
 			spew.Sdump(buf.Bytes()),
-			spew.Sdump(simnetGenesisBlockBytes))
+			spew.Sdump(devnetGenesisBlockBytes))
 	}
 
 	// Check hash of the block against expected hash.
@@ -148,187 +148,101 @@ func TestDevnetGenesisBlock(t *testing.T) {
 // 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, 0x10, 0x00, 0xca, 0x85, 0x56, 0x27, 0xc7, 0x6a, 0xb5, 0x7a, 0x26, 0x1d, 0x63,
+	0x62, 0x1e, 0x57, 0x21, 0xf0, 0x5e, 0x60, 0x1f, 0xee, 0x1d, 0x4d, 0xaa, 0x53, 0x72, 0xe1, 0x16,
+	0xda, 0x4b, 0xb3, 0xd8, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xb4, 0xbd, 0x81, 0x0a, 0x73, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7f,
+	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 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, 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,
+	0x00, 0x00, 0x00, 0x00, 0xc4, 0x41, 0xe6, 0x78, 0x1d, 0xf7, 0xb3, 0x39, 0x66, 0x4d, 0x1a, 0x03,
+	0x97, 0x63, 0xc7, 0x2c, 0xfc, 0x70, 0xd7, 0x75, 0xb6, 0xd9, 0xfc, 0x1a, 0x96, 0xf0, 0xac, 0x07,
+	0xef, 0xfa, 0x26, 0x38, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0x00, 0x00, 0x00, 0x10, 0x00, 0x1e, 0x08, 0xae, 0x1f, 0x43, 0xf5, 0xfc, 0x24, 0xe6, 0xec, 0x54,
+	0x5b, 0xf7, 0x52, 0x99, 0xe4, 0xcc, 0x4c, 0xa0, 0x79, 0x41, 0xfc, 0xbe, 0x76, 0x72, 0x4c, 0x7e,
+	0xd8, 0xa3, 0x43, 0x65, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x8a, 0x95, 0x0a, 0x73, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7f,
+	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 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, 0xd4, 0xc4, 0x87, 0x77, 0xf2, 0xe7, 0x5d, 0xf7, 0xff, 0x2d, 0xbb, 0xb6,
+	0x2a, 0x73, 0x1f, 0x54, 0x36, 0x33, 0xa7, 0x99, 0xad, 0xb1, 0x09, 0x65, 0xc0, 0xf0, 0xf4, 0x53,
+	0xba, 0xfb, 0x88, 0xae, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0x00, 0x00, 0x00, 0x10, 0x00, 0xa0, 0xa1, 0x3d, 0xfd, 0x86, 0x41, 0x35, 0xc8, 0xbd, 0xbb, 0xe6,
+	0x37, 0x35, 0xbb, 0x4c, 0x51, 0x11, 0x7b, 0x26, 0x90, 0x15, 0x64, 0x0f, 0x42, 0x6d, 0x2b, 0x6f,
+	0x37, 0x4d, 0xc1, 0xa9, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xd9, 0xa9, 0x66, 0x0a, 0x73, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7f,
+	0x1e, 0xca, 0x62, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 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, 0xf5, 0x41, 0x4c, 0xf4, 0xa8, 0xa2, 0x8c, 0x47, 0x9d, 0xb5, 0x75, 0x5e,
+	0x0f, 0x38, 0xd3, 0x27, 0x82, 0xc6, 0xd1, 0x89, 0xc1, 0x60, 0x49, 0xd9, 0x99, 0xc6, 0x2e, 0xbf,
+	0x4b, 0x5a, 0x3a, 0xcf, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0x00, 0x00, 0x00, 0x10, 0x00, 0x47, 0x52, 0xc7, 0x23, 0x70, 0x4d, 0x89, 0x17, 0xbd, 0x44, 0x26,
+	0xfa, 0x82, 0x7e, 0x1b, 0xa9, 0xc6, 0x46, 0x1a, 0x37, 0x5a, 0x73, 0x88, 0x09, 0xe8, 0x17, 0xff,
+	0xb1, 0xdb, 0x1a, 0xb3, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x1d, 0x00, 0x73, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7f,
+	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 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, 0xd9, 0x39, 0x5f, 0x40, 0x2a, 0x5e, 0x24, 0x09, 0x1b, 0x9a, 0x4b, 0xdf,
+	0x7f, 0x0c, 0x03, 0x7f, 0xf1, 0xd2, 0x48, 0x8c, 0x26, 0xb0, 0xa3, 0x74, 0x60, 0xd9, 0x48, 0x18,
+	0x2b, 0x33, 0x22, 0x64, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
+	0x00, 0x00, 0x00, 0x10, 0x00, 0x68, 0x60, 0xe7, 0x77, 0x47, 0x74, 0x7f, 0xd5, 0x55, 0x58, 0x8a,
+	0xb5, 0xc2, 0x29, 0x0c, 0xa6, 0x65, 0x44, 0xb4, 0x4f, 0xfa, 0x31, 0x7a, 0xfa, 0x55, 0xe0, 0xcf,
+	0xac, 0x9c, 0x86, 0x30, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x56, 0xb0, 0x05, 0x73, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7f,
+	0x1e, 0xbb, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 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, 0x1d, 0x1c, 0x05, 0x21, 0x10, 0x45, 0x61, 0xed, 0xc6, 0x0b, 0xdc, 0x85,
+	0xc0, 0x0a, 0x70, 0x2b, 0x15, 0xd5, 0x3c, 0x07, 0xb0, 0x54, 0x4f, 0x5b, 0x1a, 0x04, 0xcd, 0x49,
+	0xf1, 0x7b, 0xd6, 0x27, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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/params.go

@@ -53,7 +53,6 @@ const (
 	timestampDeviationTolerance    = 132
 	finalityDuration               = 24 * time.Hour
 	targetTimePerBlock             = 1 * time.Second
-	finalityInterval               = uint64(finalityDuration / targetTimePerBlock)
 )
 
 // ConsensusDeployment defines details related to a specific consensus rule
@@ -136,8 +135,8 @@ type Params struct {
 	// block.
 	TargetTimePerBlock time.Duration
 
-	// FinalityInterval is the interval that determines the finality window of the DAG.
-	FinalityInterval uint64
+	// FinalityDuration is the duration of the finality window.
+	FinalityDuration time.Duration
 
 	// TimestampDeviationTolerance is the maximum offset a block timestamp
 	// is allowed to be in the future before it gets delayed
@@ -176,6 +175,9 @@ type Params struct {
 
 	// Address encoding magics
 	PrivateKeyID byte // First byte of a WIF private key
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks bool
 }
 
 // NormalizeRPCServerAddress returns addr with the current network default
@@ -200,7 +202,7 @@ var MainnetParams = Params{
 	BlockCoinbaseMaturity:          100,
 	SubsidyReductionInterval:       210000,
 	TargetTimePerBlock:             targetTimePerBlock,
-	FinalityInterval:               finalityInterval,
+	FinalityDuration:               finalityDuration,
 	DifficultyAdjustmentWindowSize: difficultyAdjustmentWindowSize,
 	TimestampDeviationTolerance:    timestampDeviationTolerance,
 
@@ -213,8 +215,8 @@ var MainnetParams = Params{
 	Deployments: [DefinedDeployments]ConsensusDeployment{
 		DeploymentTestDummy: {
 			BitNumber:  28,
-			StartTime:  1199145601, // January 1, 2008 UTC
-			ExpireTime: 1230767999, // December 31, 2008 UTC
+			StartTime:  1199145601000, // January 1, 2008 UTC
+			ExpireTime: 1230767999000, // December 31, 2008 UTC
 		},
 	},
 
@@ -230,6 +232,9 @@ var MainnetParams = Params{
 
 	// Address encoding magics
 	PrivateKeyID: 0x80, // starts with 5 (uncompressed) or K (compressed)
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks: false,
 }
 
 // RegressionNetParams defines the network parameters for the regression test
@@ -250,7 +255,7 @@ var RegressionNetParams = Params{
 	BlockCoinbaseMaturity:          100,
 	SubsidyReductionInterval:       150,
 	TargetTimePerBlock:             targetTimePerBlock,
-	FinalityInterval:               finalityInterval,
+	FinalityDuration:               finalityDuration,
 	DifficultyAdjustmentWindowSize: difficultyAdjustmentWindowSize,
 	TimestampDeviationTolerance:    timestampDeviationTolerance,
 
@@ -280,6 +285,9 @@ var RegressionNetParams = Params{
 
 	// Address encoding magics
 	PrivateKeyID: 0xef, // starts with 9 (uncompressed) or c (compressed)
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks: false,
 }
 
 // TestnetParams defines the network parameters for the test Kaspa network.
@@ -298,7 +306,7 @@ var TestnetParams = Params{
 	BlockCoinbaseMaturity:          100,
 	SubsidyReductionInterval:       210000,
 	TargetTimePerBlock:             targetTimePerBlock,
-	FinalityInterval:               finalityInterval,
+	FinalityDuration:               finalityDuration,
 	DifficultyAdjustmentWindowSize: difficultyAdjustmentWindowSize,
 	TimestampDeviationTolerance:    timestampDeviationTolerance,
 
@@ -311,8 +319,8 @@ var TestnetParams = Params{
 	Deployments: [DefinedDeployments]ConsensusDeployment{
 		DeploymentTestDummy: {
 			BitNumber:  28,
-			StartTime:  1199145601, // January 1, 2008 UTC
-			ExpireTime: 1230767999, // December 31, 2008 UTC
+			StartTime:  1199145601000, // January 1, 2008 UTC
+			ExpireTime: 1230767999000, // December 31, 2008 UTC
 		},
 	},
 
@@ -328,6 +336,9 @@ var TestnetParams = Params{
 
 	// Address encoding magics
 	PrivateKeyID: 0xef, // starts with 9 (uncompressed) or c (compressed)
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks: false,
 }
 
 // SimnetParams defines the network parameters for the simulation test Kaspa
@@ -351,8 +362,8 @@ var SimnetParams = Params{
 	PowMax:                         simnetPowMax,
 	BlockCoinbaseMaturity:          100,
 	SubsidyReductionInterval:       210000,
-	TargetTimePerBlock:             targetTimePerBlock,
-	FinalityInterval:               finalityInterval,
+	TargetTimePerBlock:             time.Millisecond,
+	FinalityDuration:               time.Minute,
 	DifficultyAdjustmentWindowSize: difficultyAdjustmentWindowSize,
 	TimestampDeviationTolerance:    timestampDeviationTolerance,
 
@@ -380,6 +391,9 @@ var SimnetParams = Params{
 	PrivateKeyID: 0x64, // starts with 4 (uncompressed) or F (compressed)
 	// Human-readable part for Bech32 encoded addresses
 	Prefix: util.Bech32PrefixKaspaSim,
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks: false,
 }
 
 // DevnetParams defines the network parameters for the development Kaspa network.
@@ -398,7 +412,7 @@ var DevnetParams = Params{
 	BlockCoinbaseMaturity:          100,
 	SubsidyReductionInterval:       210000,
 	TargetTimePerBlock:             targetTimePerBlock,
-	FinalityInterval:               finalityInterval,
+	FinalityDuration:               finalityDuration,
 	DifficultyAdjustmentWindowSize: difficultyAdjustmentWindowSize,
 	TimestampDeviationTolerance:    timestampDeviationTolerance,
 
@@ -411,8 +425,8 @@ var DevnetParams = Params{
 	Deployments: [DefinedDeployments]ConsensusDeployment{
 		DeploymentTestDummy: {
 			BitNumber:  28,
-			StartTime:  1199145601, // January 1, 2008 UTC
-			ExpireTime: 1230767999, // December 31, 2008 UTC
+			StartTime:  1199145601000, // January 1, 2008 UTC
+			ExpireTime: 1230767999000, // December 31, 2008 UTC
 		},
 	},
 
@@ -428,6 +442,9 @@ var DevnetParams = Params{
 
 	// Address encoding magics
 	PrivateKeyID: 0xef, // starts with 9 (uncompressed) or c (compressed)
+
+	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
+	EnableNonNativeSubnetworks: false,
 }
 
 var (

database/ffldb/ldb/leveldb.go

@@ -15,7 +15,7 @@ type LevelDB struct {
 // NewLevelDB opens a leveldb instance defined by the given path.
 func NewLevelDB(path string) (*LevelDB, error) {
 	// Open leveldb. If it doesn't exist, create it.
-	ldb, err := leveldb.OpenFile(path, nil)
+	ldb, err := leveldb.OpenFile(path, Options())
 
 	// If the database is corrupted, attempt to recover.
 	if _, corrupted := err.(*ldbErrors.ErrCorrupted); corrupted {

database/ffldb/ldb/options.go

@@ -0,0 +1,19 @@
+package ldb
+
+import "github.com/syndtr/goleveldb/leveldb/opt"
+
+var (
+	defaultOptions = opt.Options{
+		Compression:            opt.NoCompression,
+		BlockCacheCapacity:     256 * opt.MiB,
+		WriteBuffer:            128 * opt.MiB,
+		DisableSeeksCompaction: true,
+	}
+
+	// Options is a function that returns a leveldb
+	// opt.Options struct for opening a database.
+	// It's defined as a variable for the sake of testing.
+	Options = func() *opt.Options {
+		return &defaultOptions
+	}
+)

dbaccess/block_test.go

@@ -1,11 +1,12 @@
 package dbaccess
 
 import (
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util"
 	"io/ioutil"
 	"reflect"
 	"testing"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util"
 )
 
 func TestBlockStoreSanity(t *testing.T) {
@@ -15,13 +16,13 @@ func TestBlockStoreSanity(t *testing.T) {
 		t.Fatalf("TestBlockStoreSanity: TempDir unexpectedly "+
 			"failed: %s", err)
 	}
-	err = Open(path)
+	databaseContext, err := New(path)
 	if err != nil {
 		t.Fatalf("TestBlockStoreSanity: Open unexpectedly "+
 			"failed: %s", err)
 	}
 	defer func() {
-		err := Close()
+		err := databaseContext.Close()
 		if err != nil {
 			t.Fatalf("TestBlockStoreSanity: Close unexpectedly "+
 				"failed: %s", err)
@@ -36,7 +37,7 @@ func TestBlockStoreSanity(t *testing.T) {
 		t.Fatalf("TestBlockStoreSanity: util.Block.Bytes unexpectedly "+
 			"failed: %s", err)
 	}
-	dbTx, err := NewTx()
+	dbTx, err := databaseContext.NewTx()
 	if err != nil {
 		t.Fatalf("Failed to open database "+
 			"transaction: %s", err)
@@ -54,7 +55,7 @@ func TestBlockStoreSanity(t *testing.T) {
 	}
 
 	// Make sure the genesis block now exists in the db
-	exists, err := HasBlock(NoTx(), genesisHash)
+	exists, err := HasBlock(databaseContext, genesisHash)
 	if err != nil {
 		t.Fatalf("TestBlockStoreSanity: HasBlock unexpectedly "+
 			"failed: %s", err)
@@ -66,7 +67,7 @@ func TestBlockStoreSanity(t *testing.T) {
 
 	// Fetch the genesis block back from the db and make sure
 	// that it's equal to the original
-	fetchedGenesisBytes, err := FetchBlock(NoTx(), genesisHash)
+	fetchedGenesisBytes, err := FetchBlock(databaseContext, genesisHash)
 	if err != nil {
 		t.Fatalf("TestBlockStoreSanity: FetchBlock unexpectedly "+
 			"failed: %s", err)

dbaccess/context.go

@@ -11,17 +11,12 @@ type Context interface {
 	accessor() (database.DataAccessor, error)
 }
 
-type noTxContext struct{}
-
-var noTxContextSingleton = &noTxContext{}
-
-func (*noTxContext) accessor() (database.DataAccessor, error) {
-	return db()
+type noTxContext struct {
+	backend *DatabaseContext
 }
 
-// NoTx creates and returns an instance of dbaccess.Context without an attached database transaction
-func NoTx() Context {
-	return noTxContextSingleton
+func (ctx *noTxContext) accessor() (database.DataAccessor, error) {
+	return ctx.backend.db, nil
 }
 
 // TxContext represents a database context with an attached database transaction
@@ -29,6 +24,15 @@ type TxContext struct {
 	dbTransaction database.Transaction
 }
 
+// NewTx returns an instance of TxContext with a new database transaction
+func (ctx *DatabaseContext) NewTx() (*TxContext, error) {
+	dbTransaction, err := ctx.db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	return &TxContext{dbTransaction: dbTransaction}, nil
+}
+
 func (ctx *TxContext) accessor() (database.DataAccessor, error) {
 	return ctx.dbTransaction, nil
 }
@@ -48,16 +52,3 @@ func (ctx *TxContext) Rollback() error {
 func (ctx *TxContext) RollbackUnlessClosed() error {
 	return ctx.dbTransaction.RollbackUnlessClosed()
 }
-
-// NewTx returns an instance of TxContext with a new database transaction
-func NewTx() (*TxContext, error) {
-	db, err := db()
-	if err != nil {
-		return nil, err
-	}
-	dbTransaction, err := db.Begin()
-	if err != nil {
-		return nil, err
-	}
-	return &TxContext{dbTransaction: dbTransaction}, nil
-}

dbaccess/db.go

@@ -3,41 +3,28 @@ package dbaccess
 import (
 	"github.com/kaspanet/kaspad/database"
 	"github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/pkg/errors"
 )
 
-// dbSingleton is a handle to an instance of the kaspad database
-var dbSingleton database.Database
-
-// db returns a handle to the database
-func db() (database.Database, error) {
-	if dbSingleton == nil {
-		return nil, errors.New("database is not open")
-	}
-	return dbSingleton, nil
+// DatabaseContext represents a context in which all database queries run
+type DatabaseContext struct {
+	db database.Database
+	*noTxContext
 }
 
-// Open opens the database for given path
-func Open(path string) error {
-	if dbSingleton != nil {
-		return errors.New("database is already open")
-	}
-
+// New creates a new DatabaseContext with database is in the specified `path`
+func New(path string) (*DatabaseContext, error) {
 	db, err := ffldb.Open(path)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	dbSingleton = db
-	return nil
+	databaseContext := &DatabaseContext{db: db}
+	databaseContext.noTxContext = &noTxContext{backend: databaseContext}
+
+	return databaseContext, nil
 }
 
-// Close closes the database, if it's open
-func Close() error {
-	if dbSingleton == nil {
-		return nil
-	}
-	err := dbSingleton.Close()
-	dbSingleton = nil
-	return err
+// Close closes the DatabaseContext's connection, if it's open
+func (ctx *DatabaseContext) Close() error {
+	return ctx.db.Close()
 }

dbaccess/peers.go

@@ -0,0 +1,26 @@
+package dbaccess
+
+import "github.com/kaspanet/kaspad/database"
+
+var (
+	peersKey = database.MakeBucket().Key([]byte("peers"))
+)
+
+// StorePeersState stores the peers state in the database.
+func StorePeersState(context Context, peersState []byte) error {
+	accessor, err := context.accessor()
+	if err != nil {
+		return err
+	}
+	return accessor.Put(peersKey, peersState)
+}
+
+// FetchPeersState retrieves the peers state from the database.
+// Returns ErrNotFound if the state is missing from the database.
+func FetchPeersState(context Context) ([]byte, error) {
+	accessor, err := context.accessor()
+	if err != nil {
+		return nil, err
+	}
+	return accessor.Get(peersKey)
+}

dbaccess/reachability.go

@@ -6,6 +6,7 @@ import (
 )
 
 var reachabilityDataBucket = database.MakeBucket([]byte("reachability"))
+var reachabilityReindexKey = database.MakeBucket().Key([]byte("reachability-reindex-root"))
 
 func reachabilityKey(hash *daghash.Hash) *database.Key {
 	return reachabilityDataBucket.Key(hash[:])
@@ -38,3 +39,26 @@ func StoreReachabilityData(context Context, blockHash *daghash.Hash, reachabilit
 func ClearReachabilityData(dbTx *TxContext) error {
 	return clearBucket(dbTx, reachabilityDataBucket)
 }
+
+// StoreReachabilityReindexRoot stores the reachability reindex root in the database.
+func StoreReachabilityReindexRoot(context Context, reachabilityReindexRoot *daghash.Hash) error {
+	accessor, err := context.accessor()
+	if err != nil {
+		return err
+	}
+	return accessor.Put(reachabilityReindexKey, reachabilityReindexRoot[:])
+}
+
+// FetchReachabilityReindexRoot retrieves the reachability reindex root from the database.
+// Returns ErrNotFound if the state is missing from the database.
+func FetchReachabilityReindexRoot(context Context) (*daghash.Hash, error) {
+	accessor, err := context.accessor()
+	if err != nil {
+		return nil, err
+	}
+	bytes, err := accessor.Get(reachabilityReindexKey)
+	if err != nil {
+		return nil, err
+	}
+	return daghash.NewHash(bytes)
+}

dnsseed/log.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package connmgr
+package dnsseed
 
 import (
 	"github.com/kaspanet/kaspad/logger"

dnsseed/seed.go

@@ -2,16 +2,17 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package connmgr
+package dnsseed
 
 import (
 	"fmt"
-	mrand "math/rand"
+	"math/rand"
 	"net"
 	"strconv"
 	"time"
 
-	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/util/mstime"
+
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 
 	"github.com/kaspanet/kaspad/dagconfig"
@@ -32,20 +33,19 @@ const (
 )
 
 // OnSeed is the signature of the callback function which is invoked when DNS
-// seeding is succesfull.
+// seeding is successful.
 type OnSeed func(addrs []*wire.NetAddress)
 
 // LookupFunc is the signature of the DNS lookup function.
 type LookupFunc func(string) ([]net.IP, error)
 
 // SeedFromDNS uses DNS seeding to populate the address manager with peers.
-func SeedFromDNS(dagParams *dagconfig.Params, reqServices wire.ServiceFlag, includeAllSubnetworks bool,
+func SeedFromDNS(dagParams *dagconfig.Params, customSeed string, reqServices wire.ServiceFlag, includeAllSubnetworks bool,
 	subnetworkID *subnetworkid.SubnetworkID, lookupFn LookupFunc, seedFn OnSeed) {
 
 	var dnsSeeds []string
-	mainConfig := config.ActiveConfig()
-	if mainConfig != nil && mainConfig.DNSSeed != "" {
-		dnsSeeds = []string{mainConfig.DNSSeed}
+	if customSeed != "" {
+		dnsSeeds = []string{customSeed}
 	} else {
 		dnsSeeds = dagParams.DNSSeeds
 	}
@@ -66,29 +66,29 @@ func SeedFromDNS(dagParams *dagconfig.Params, reqServices wire.ServiceFlag, incl
 			}
 		}
 
-		spawn(func() {
-			randSource := mrand.New(mrand.NewSource(time.Now().UnixNano()))
+		spawn("SeedFromDNS", func() {
+			randSource := rand.New(rand.NewSource(time.Now().UnixNano()))
 
-			seedpeers, err := lookupFn(host)
+			seedPeers, err := lookupFn(host)
 			if err != nil {
 				log.Infof("DNS discovery failed on seed %s: %s", host, err)
 				return
 			}
-			numPeers := len(seedpeers)
+			numPeers := len(seedPeers)
 
 			log.Infof("%d addresses found from DNS seed %s", numPeers, host)
 
 			if numPeers == 0 {
 				return
 			}
-			addresses := make([]*wire.NetAddress, len(seedpeers))
+			addresses := make([]*wire.NetAddress, len(seedPeers))
 			// if this errors then we have *real* problems
 			intPort, _ := strconv.Atoi(dagParams.DefaultPort)
-			for i, peer := range seedpeers {
+			for i, peer := range seedPeers {
 				addresses[i] = wire.NewNetAddressTimestamp(
 					// seed with addresses from a time randomly selected
 					// between 3 and 7 days ago.
-					time.Now().Add(-1*time.Second*time.Duration(secondsIn3Days+
+					mstime.Now().Add(-1*time.Second*time.Duration(secondsIn3Days+
 						randSource.Int31n(secondsIn4Days))),
 					0, peer, uint16(intPort))
 			}

doc.go

@@ -6,7 +6,7 @@ Copyright (c) 2013-2014 Conformal Systems LLC.
 Use of this source code is governed by an ISC
 license that can be found in the LICENSE file.
 
-kaspad is a full-node kaspa implementation written in Go.
+Kaspad is a full-node kaspa implementation written in Go.
 
 The default options are sane for most users. This means kaspad will work 'out of
 the box' for most users. However, there are also a wide variety of flags that