[NOD-1238] Fix acceptance index never being initialized. (#859)

README.md

@@ -40,8 +40,10 @@ recommended that `GOPATH` is set to a directory in your home directory such as
 ```bash
 $ git clone https://github.com/kaspanet/kaspad $GOPATH/src/github.com/kaspanet/kaspad
 $ cd $GOPATH/src/github.com/kaspanet/kaspad
+$ ./test.sh
 $ go install . ./cmd/...
 ```
+`./test.sh` tests can be skipped, but some things might not run correctly on your system if tests fail.
 
 - Kaspad (and utilities) should now be installed in `$GOPATH/bin`. If you did
   not already add the bin directory to your system path during Go installation,

addressmanager/addressmanager.go

@@ -9,27 +9,22 @@ import (
 	crand "crypto/rand" // for seeding
 	"encoding/binary"
 	"encoding/gob"
+	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
 	"io"
 	"math/rand"
 	"net"
-	"runtime"
 	"strconv"
-	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
 
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/db/database"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/pkg/errors"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // AddressKey represents a "string" key in the form of ip:port for IPv4 addresses
@@ -41,8 +36,8 @@ type triedAddressBucketArray [TriedBucketCount][]*KnownAddress
 // AddressManager provides a concurrency safe address manager for caching potential
 // peers on the Kaspa network.
 type AddressManager struct {
-	cfg      *config.Config
-	database database.Database
+	cfg             *config.Config
+	databaseContext *dbaccess.DatabaseContext
 
 	mutex              sync.Mutex
 	lookupFunc         func(string) ([]net.IP, error)
@@ -55,16 +50,16 @@ type AddressManager struct {
 	quit               chan struct{}
 	localAddressesLock sync.Mutex
 	localAddresses     map[AddressKey]*localAddress
-	localSubnetworkID  *externalapi.DomainSubnetworkID
+	localSubnetworkID  *subnetworkid.SubnetworkID
 
 	fullNodeNewAddressBucketArray     newAddressBucketArray
 	fullNodeNewAddressCount           int
 	fullNodeTriedAddressBucketArray   triedAddressBucketArray
 	fullNodeTriedAddressCount         int
-	subnetworkNewAddressBucketArrays  map[externalapi.DomainSubnetworkID]*newAddressBucketArray
-	subnetworkNewAddressCounts        map[externalapi.DomainSubnetworkID]int
-	subnetworkTriedAddresBucketArrays map[externalapi.DomainSubnetworkID]*triedAddressBucketArray
-	subnetworkTriedAddressCounts      map[externalapi.DomainSubnetworkID]int
+	subnetworkNewAddressBucketArrays  map[subnetworkid.SubnetworkID]*newAddressBucketArray
+	subnetworkNewAddressCounts        map[subnetworkid.SubnetworkID]int
+	subnetworkTriedAddresBucketArrays map[subnetworkid.SubnetworkID]*triedAddressBucketArray
+	subnetworkTriedAddressCounts      map[subnetworkid.SubnetworkID]int
 }
 
 type serializedKnownAddress struct {
@@ -97,7 +92,7 @@ type PeersStateForSerialization struct {
 }
 
 type localAddress struct {
-	netAddress *appmessage.NetAddress
+	netAddress *domainmessage.NetAddress
 	score      AddressPriority
 }
 
@@ -192,34 +187,28 @@ const (
 	serializationVersion = 1
 )
 
-var peersDBKey = database.MakeBucket().Key([]byte("peers"))
-
 // ErrAddressNotFound is an error returned from some functions when a
 // given address is not found in the address manager
 var ErrAddressNotFound = errors.New("address not found")
 
 // New returns a new Kaspa address manager.
-func New(cfg *config.Config, database database.Database) (*AddressManager, error) {
+func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext) *AddressManager {
 	addressManager := AddressManager{
 		cfg:               cfg,
-		database:          database,
+		databaseContext:   databaseContext,
 		lookupFunc:        cfg.Lookup,
 		random:            rand.New(rand.NewSource(time.Now().UnixNano())),
 		quit:              make(chan struct{}),
 		localAddresses:    make(map[AddressKey]*localAddress),
 		localSubnetworkID: cfg.SubnetworkID,
 	}
-	err := addressManager.initListeners()
-	if err != nil {
-		return nil, err
-	}
 	addressManager.reset()
-	return &addressManager, nil
+	return &addressManager
 }
 
 // updateAddress is a helper function to either update an address already known
 // to the address manager, or to add the address if not already known.
-func (am *AddressManager) updateAddress(netAddress, sourceAddress *appmessage.NetAddress, subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) updateAddress(netAddress, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	// Filter out non-routable addresses. Note that non-routable
 	// also includes invalid and local addresses.
 	if !am.IsRoutable(netAddress) {
@@ -229,6 +218,7 @@ func (am *AddressManager) updateAddress(netAddress, sourceAddress *appmessage.Ne
 	addressKey := NetAddressKey(netAddress)
 	knownAddress := am.knownAddress(netAddress)
 	if knownAddress != nil {
+		// TODO: only update addresses periodically.
 		// Update the last seen time and services.
 		// note that to prevent causing excess garbage on getaddr
 		// messages the netaddresses in addrmaanger are *immutable*,
@@ -326,7 +316,7 @@ func (am *AddressManager) updateAddrTried(bucketIndex int, knownAddress *KnownAd
 
 // expireNew makes space in the new buckets by expiring the really bad entries.
 // If no bad entries are available we look at a few and remove the oldest.
-func (am *AddressManager) expireNew(subnetworkID *externalapi.DomainSubnetworkID, bucketIndex int) {
+func (am *AddressManager) expireNew(subnetworkID *subnetworkid.SubnetworkID, bucketIndex int) {
 	// First see if there are any entries that are so bad we can just throw
 	// them away. otherwise we throw away the oldest entry in the cache.
 	// We keep track of oldest in the initial traversal and use that
@@ -366,7 +356,7 @@ func (am *AddressManager) expireNew(subnetworkID *externalapi.DomainSubnetworkID
 
 // pickTried selects an address from the tried bucket to be evicted.
 // We just choose the eldest.
-func (am *AddressManager) pickTried(subnetworkID *externalapi.DomainSubnetworkID, bucketIndex int) (
+func (am *AddressManager) pickTried(subnetworkID *subnetworkid.SubnetworkID, bucketIndex int) (
 	knownAddress *KnownAddress, knownAddressIndex int) {
 
 	var oldest *KnownAddress
@@ -381,15 +371,15 @@ func (am *AddressManager) pickTried(subnetworkID *externalapi.DomainSubnetworkID
 	return oldest, oldestIndex
 }
 
-func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *appmessage.NetAddress) int {
+func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *domainmessage.NetAddress) int {
 	// doublesha256(key + sourcegroup + int64(doublesha256(key + group + sourcegroup))%bucket_per_source_group) % num_new_buckets
 
 	data1 := []byte{}
 	data1 = append(data1, am.key[:]...)
 	data1 = append(data1, []byte(am.GroupKey(netAddress))...)
 	data1 = append(data1, []byte(am.GroupKey(srcAddress))...)
-	hash1 := hashes.HashData(data1)
-	hash64 := binary.LittleEndian.Uint64(hash1[:])
+	hash1 := daghash.DoubleHashB(data1)
+	hash64 := binary.LittleEndian.Uint64(hash1)
 	hash64 %= newBucketsPerGroup
 	var hashbuf [8]byte
 	binary.LittleEndian.PutUint64(hashbuf[:], hash64)
@@ -398,17 +388,17 @@ func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *appmessa
 	data2 = append(data2, am.GroupKey(srcAddress)...)
 	data2 = append(data2, hashbuf[:]...)
 
-	hash2 := hashes.HashData(data2)
-	return int(binary.LittleEndian.Uint64(hash2[:]) % NewBucketCount)
+	hash2 := daghash.DoubleHashB(data2)
+	return int(binary.LittleEndian.Uint64(hash2) % NewBucketCount)
 }
 
-func (am *AddressManager) triedAddressBucketIndex(netAddress *appmessage.NetAddress) int {
+func (am *AddressManager) triedAddressBucketIndex(netAddress *domainmessage.NetAddress) int {
 	// doublesha256(key + group + truncate_to_64bits(doublesha256(key)) % buckets_per_group) % num_buckets
 	data1 := []byte{}
 	data1 = append(data1, am.key[:]...)
 	data1 = append(data1, []byte(NetAddressKey(netAddress))...)
-	hash1 := hashes.HashData(data1)
-	hash64 := binary.LittleEndian.Uint64(hash1[:])
+	hash1 := daghash.DoubleHashB(data1)
+	hash64 := binary.LittleEndian.Uint64(hash1)
 	hash64 %= triedBucketsPerGroup
 	var hashbuf [8]byte
 	binary.LittleEndian.PutUint64(hashbuf[:], hash64)
@@ -417,8 +407,8 @@ func (am *AddressManager) triedAddressBucketIndex(netAddress *appmessage.NetAddr
 	data2 = append(data2, am.GroupKey(netAddress)...)
 	data2 = append(data2, hashbuf[:]...)
 
-	hash2 := hashes.HashData(data2)
-	return int(binary.LittleEndian.Uint64(hash2[:]) % TriedBucketCount)
+	hash2 := daghash.DoubleHashB(data2)
+	return int(binary.LittleEndian.Uint64(hash2) % TriedBucketCount)
 }
 
 // addressHandler is the main handler for the address manager. It must be run
@@ -456,7 +446,7 @@ func (am *AddressManager) savePeers() error {
 		return err
 	}
 
-	return am.database.Put(peersDBKey, serializedPeersState)
+	return dbaccess.StorePeersState(am.databaseContext, serializedPeersState)
 }
 
 func (am *AddressManager) serializePeersState() ([]byte, error) {
@@ -566,8 +556,8 @@ func (am *AddressManager) loadPeers() error {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
-	serializedPeerState, err := am.database.Get(peersDBKey)
-	if database.IsNotFoundError(err) {
+	serializedPeerState, err := dbaccess.FetchPeersState(am.databaseContext)
+	if dbaccess.IsNotFoundError(err) {
 		am.reset()
 		log.Info("No peers state was found in the database. Created a new one", am.totalNumAddresses())
 		return nil
@@ -613,7 +603,7 @@ func (am *AddressManager) deserializePeersState(serializedPeerState []byte) erro
 				"%s: %s", serializedKnownAddress.SourceAddress, err)
 		}
 		if serializedKnownAddress.SubnetworkID != "" {
-			knownAddress.subnetworkID, err = subnetworks.FromString(serializedKnownAddress.SubnetworkID)
+			knownAddress.subnetworkID, err = subnetworkid.NewFromStr(serializedKnownAddress.SubnetworkID)
 			if err != nil {
 				return errors.Errorf("failed to deserialize subnetwork id "+
 					"%s: %s", serializedKnownAddress.SubnetworkID, err)
@@ -628,7 +618,7 @@ func (am *AddressManager) deserializePeersState(serializedPeerState []byte) erro
 	}
 
 	for subnetworkIDStr := range peersState.SubnetworkNewAddressBucketArrays {
-		subnetworkID, err := subnetworks.FromString(subnetworkIDStr)
+		subnetworkID, err := subnetworkid.NewFromStr(subnetworkIDStr)
 		if err != nil {
 			return err
 		}
@@ -666,7 +656,7 @@ func (am *AddressManager) deserializePeersState(serializedPeerState []byte) erro
 	}
 
 	for subnetworkIDString := range peersState.SubnetworkTriedAddressBucketArrays {
-		subnetworkID, err := subnetworks.FromString(subnetworkIDString)
+		subnetworkID, err := subnetworkid.NewFromStr(subnetworkIDString)
 		if err != nil {
 			return err
 		}
@@ -715,8 +705,8 @@ func (am *AddressManager) deserializePeersState(serializedPeerState []byte) erro
 	return nil
 }
 
-// DeserializeNetAddress converts a given address string to a *appmessage.NetAddress
-func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*appmessage.NetAddress, error) {
+// DeserializeNetAddress converts a given address string to a *domainmessage.NetAddress
+func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*domainmessage.NetAddress, error) {
 	host, portString, err := net.SplitHostPort(string(addressKey))
 	if err != nil {
 		return nil, err
@@ -726,7 +716,7 @@ func (am *AddressManager) DeserializeNetAddress(addressKey AddressKey) (*appmess
 		return nil, err
 	}
 
-	return am.HostToNetAddress(host, uint16(port), appmessage.SFNodeNetwork)
+	return am.HostToNetAddress(host, uint16(port), domainmessage.SFNodeNetwork)
 }
 
 // Start begins the core address handler which manages a pool of known
@@ -768,7 +758,7 @@ func (am *AddressManager) Stop() error {
 // AddAddresses adds new addresses to the address manager. It enforces a max
 // number of addresses and silently ignores duplicate addresses. It is
 // safe for concurrent access.
-func (am *AddressManager) AddAddresses(addresses []*appmessage.NetAddress, sourceAddress *appmessage.NetAddress, subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) AddAddresses(addresses []*domainmessage.NetAddress, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -780,16 +770,38 @@ func (am *AddressManager) AddAddresses(addresses []*appmessage.NetAddress, sourc
 // AddAddress adds a new address to the address manager. It enforces a max
 // number of addresses and silently ignores duplicate addresses. It is
 // safe for concurrent access.
-func (am *AddressManager) AddAddress(address, sourceAddress *appmessage.NetAddress, subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) AddAddress(address, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
 	am.updateAddress(address, sourceAddress, subnetworkID)
 }
 
+// AddAddressByIP adds an address where we are given an ip:port and not a
+// domainmessage.NetAddress.
+func (am *AddressManager) AddAddressByIP(addressIP string, subnetworkID *subnetworkid.SubnetworkID) error {
+	// Split IP and port
+	ipString, portString, err := net.SplitHostPort(addressIP)
+	if err != nil {
+		return err
+	}
+	// Put it in domainmessage.Netaddress
+	ip := net.ParseIP(ipString)
+	if ip == nil {
+		return errors.Errorf("invalid ip %s", ipString)
+	}
+	port, err := strconv.ParseUint(portString, 10, 0)
+	if err != nil {
+		return errors.Errorf("invalid port %s: %s", portString, err)
+	}
+	netAddress := domainmessage.NewNetAddressIPPort(ip, uint16(port), 0)
+	am.AddAddress(netAddress, netAddress, subnetworkID) // XXX use correct src address
+	return nil
+}
+
 // numAddresses returns the number of addresses that belongs to a specific subnetwork id
 // which are known to the address manager.
-func (am *AddressManager) numAddresses(subnetworkID *externalapi.DomainSubnetworkID) int {
+func (am *AddressManager) numAddresses(subnetworkID *subnetworkid.SubnetworkID) int {
 	if subnetworkID == nil {
 		return am.fullNodeNewAddressCount + am.fullNodeTriedAddressCount
 	}
@@ -831,7 +843,7 @@ func (am *AddressManager) NeedMoreAddresses() bool {
 
 // AddressCache returns the current address cache. It must be treated as
 // read-only (but since it is a copy now, this is not as dangerous).
-func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) []*appmessage.NetAddress {
+func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) []*domainmessage.NetAddress {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -839,10 +851,10 @@ func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID
 		return nil
 	}
 
-	allAddresses := []*appmessage.NetAddress{}
+	allAddresses := []*domainmessage.NetAddress{}
 	// Iteration order is undefined here, but we randomise it anyway.
 	for _, v := range am.addressIndex {
-		if includeAllSubnetworks || *v.SubnetworkID() == *subnetworkID {
+		if includeAllSubnetworks || v.SubnetworkID().IsEqual(subnetworkID) {
 			allAddresses = append(allAddresses, v.netAddress)
 		}
 	}
@@ -877,11 +889,11 @@ func (am *AddressManager) reset() {
 
 	// fill key with bytes from a good random source.
 	io.ReadFull(crand.Reader, am.key[:])
-	am.subnetworkNewAddressBucketArrays = make(map[externalapi.DomainSubnetworkID]*newAddressBucketArray)
-	am.subnetworkTriedAddresBucketArrays = make(map[externalapi.DomainSubnetworkID]*triedAddressBucketArray)
+	am.subnetworkNewAddressBucketArrays = make(map[subnetworkid.SubnetworkID]*newAddressBucketArray)
+	am.subnetworkTriedAddresBucketArrays = make(map[subnetworkid.SubnetworkID]*triedAddressBucketArray)
 
-	am.subnetworkNewAddressCounts = make(map[externalapi.DomainSubnetworkID]int)
-	am.subnetworkTriedAddressCounts = make(map[externalapi.DomainSubnetworkID]int)
+	am.subnetworkNewAddressCounts = make(map[subnetworkid.SubnetworkID]int)
+	am.subnetworkTriedAddressCounts = make(map[subnetworkid.SubnetworkID]int)
 
 	for i := range am.fullNodeNewAddressBucketArray {
 		am.fullNodeNewAddressBucketArray[i] = make(map[AddressKey]*KnownAddress)
@@ -895,7 +907,7 @@ func (am *AddressManager) reset() {
 
 // HostToNetAddress returns a netaddress given a host address. If
 // the host is not an IP address it will be resolved.
-func (am *AddressManager) HostToNetAddress(host string, port uint16, services appmessage.ServiceFlag) (*appmessage.NetAddress, error) {
+func (am *AddressManager) HostToNetAddress(host string, port uint16, services domainmessage.ServiceFlag) (*domainmessage.NetAddress, error) {
 	ip := net.ParseIP(host)
 	if ip == nil {
 		ips, err := am.lookupFunc(host)
@@ -908,12 +920,12 @@ func (am *AddressManager) HostToNetAddress(host string, port uint16, services ap
 		ip = ips[0]
 	}
 
-	return appmessage.NewNetAddressIPPort(ip, port, services), nil
+	return domainmessage.NewNetAddressIPPort(ip, port, services), nil
 }
 
 // NetAddressKey returns a key in the form of ip:port for IPv4 addresses
 // or [ip]:port for IPv6 addresses for use as keys in maps.
-func NetAddressKey(netAddress *appmessage.NetAddress) AddressKey {
+func NetAddressKey(netAddress *domainmessage.NetAddress) AddressKey {
 	port := strconv.FormatUint(uint64(netAddress.Port), 10)
 
 	return AddressKey(net.JoinHostPort(netAddress.IP.String(), port))
@@ -1019,13 +1031,13 @@ func (tb *triedAddressBucketArray) name() string {
 	return "tried"
 }
 
-func (am *AddressManager) knownAddress(address *appmessage.NetAddress) *KnownAddress {
+func (am *AddressManager) knownAddress(address *domainmessage.NetAddress) *KnownAddress {
 	return am.addressIndex[NetAddressKey(address)]
 }
 
 // Attempt increases the given address' attempt counter and updates
 // the last attempt time.
-func (am *AddressManager) Attempt(address *appmessage.NetAddress) {
+func (am *AddressManager) Attempt(address *domainmessage.NetAddress) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -1043,7 +1055,7 @@ func (am *AddressManager) Attempt(address *appmessage.NetAddress) {
 // Connected Marks the given address as currently connected and working at the
 // current time. The address must already be known to AddressManager else it will
 // be ignored.
-func (am *AddressManager) Connected(address *appmessage.NetAddress) {
+func (am *AddressManager) Connected(address *domainmessage.NetAddress) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -1066,7 +1078,7 @@ func (am *AddressManager) Connected(address *appmessage.NetAddress) {
 // Good marks the given address as good. To be called after a successful
 // connection and version exchange. If the address is unknown to the address
 // manager it will be ignored.
-func (am *AddressManager) Good(address *appmessage.NetAddress, subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) Good(address *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -1089,7 +1101,7 @@ func (am *AddressManager) Good(address *appmessage.NetAddress, subnetworkID *ext
 
 	if knownAddress.tried {
 		// If this address was already tried, and subnetworkID didn't change - don't do anything
-		if *subnetworkID == *oldSubnetworkID {
+		if subnetworkID.IsEqual(oldSubnetworkID) {
 			return
 		}
 
@@ -1188,21 +1200,21 @@ func (am *AddressManager) Good(address *appmessage.NetAddress, subnetworkID *ext
 	newAddressBucketArray[newAddressBucketIndex][knownAddressToRemoveKey] = knownAddressToRemove
 }
 
-func (am *AddressManager) newAddressBucketArray(subnetworkID *externalapi.DomainSubnetworkID) *newAddressBucketArray {
+func (am *AddressManager) newAddressBucketArray(subnetworkID *subnetworkid.SubnetworkID) *newAddressBucketArray {
 	if subnetworkID == nil {
 		return &am.fullNodeNewAddressBucketArray
 	}
 	return am.subnetworkNewAddressBucketArrays[*subnetworkID]
 }
 
-func (am *AddressManager) triedAddressBucketArray(subnetworkID *externalapi.DomainSubnetworkID) *triedAddressBucketArray {
+func (am *AddressManager) triedAddressBucketArray(subnetworkID *subnetworkid.SubnetworkID) *triedAddressBucketArray {
 	if subnetworkID == nil {
 		return &am.fullNodeTriedAddressBucketArray
 	}
 	return am.subnetworkTriedAddresBucketArrays[*subnetworkID]
 }
 
-func (am *AddressManager) incrementNewAddressCount(subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) incrementNewAddressCount(subnetworkID *subnetworkid.SubnetworkID) {
 	if subnetworkID == nil {
 		am.fullNodeNewAddressCount++
 		return
@@ -1210,7 +1222,7 @@ func (am *AddressManager) incrementNewAddressCount(subnetworkID *externalapi.Dom
 	am.subnetworkNewAddressCounts[*subnetworkID]++
 }
 
-func (am *AddressManager) decrementNewAddressCount(subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) decrementNewAddressCount(subnetworkID *subnetworkid.SubnetworkID) {
 	if subnetworkID == nil {
 		am.fullNodeNewAddressCount--
 		return
@@ -1218,21 +1230,21 @@ func (am *AddressManager) decrementNewAddressCount(subnetworkID *externalapi.Dom
 	am.subnetworkNewAddressCounts[*subnetworkID]--
 }
 
-func (am *AddressManager) triedAddressCount(subnetworkID *externalapi.DomainSubnetworkID) int {
+func (am *AddressManager) triedAddressCount(subnetworkID *subnetworkid.SubnetworkID) int {
 	if subnetworkID == nil {
 		return am.fullNodeTriedAddressCount
 	}
 	return am.subnetworkTriedAddressCounts[*subnetworkID]
 }
 
-func (am *AddressManager) newAddressCount(subnetworkID *externalapi.DomainSubnetworkID) int {
+func (am *AddressManager) newAddressCount(subnetworkID *subnetworkid.SubnetworkID) int {
 	if subnetworkID == nil {
 		return am.fullNodeNewAddressCount
 	}
 	return am.subnetworkNewAddressCounts[*subnetworkID]
 }
 
-func (am *AddressManager) incrementTriedAddressCount(subnetworkID *externalapi.DomainSubnetworkID) {
+func (am *AddressManager) incrementTriedAddressCount(subnetworkID *subnetworkid.SubnetworkID) {
 	if subnetworkID == nil {
 		am.fullNodeTriedAddressCount++
 		return
@@ -1242,7 +1254,7 @@ func (am *AddressManager) incrementTriedAddressCount(subnetworkID *externalapi.D
 
 // AddLocalAddress adds netAddress to the list of known local addresses to advertise
 // with the given priority.
-func (am *AddressManager) AddLocalAddress(netAddress *appmessage.NetAddress, priority AddressPriority) error {
+func (am *AddressManager) AddLocalAddress(netAddress *domainmessage.NetAddress, priority AddressPriority) error {
 	if !am.IsRoutable(netAddress) {
 		return errors.Errorf("address %s is not routable", netAddress.IP)
 	}
@@ -1267,7 +1279,7 @@ func (am *AddressManager) AddLocalAddress(netAddress *appmessage.NetAddress, pri
 
 // getReachabilityFrom returns the relative reachability of the provided local
 // address to the provided remote address.
-func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *appmessage.NetAddress) int {
+func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *domainmessage.NetAddress) int {
 	const (
 		Unreachable = 0
 		Default     = iota
@@ -1334,13 +1346,13 @@ func (am *AddressManager) getReachabilityFrom(localAddress, remoteAddress *appme
 
 // GetBestLocalAddress returns the most appropriate local address to use
 // for the given remote address.
-func (am *AddressManager) GetBestLocalAddress(remoteAddress *appmessage.NetAddress) *appmessage.NetAddress {
+func (am *AddressManager) GetBestLocalAddress(remoteAddress *domainmessage.NetAddress) *domainmessage.NetAddress {
 	am.localAddressesLock.Lock()
 	defer am.localAddressesLock.Unlock()
 
 	bestReach := 0
 	var bestScore AddressPriority
-	var bestAddress *appmessage.NetAddress
+	var bestAddress *domainmessage.NetAddress
 	for _, localAddress := range am.localAddresses {
 		reach := am.getReachabilityFrom(localAddress.netAddress, remoteAddress)
 		if reach > bestReach ||
@@ -1364,24 +1376,24 @@ func (am *AddressManager) GetBestLocalAddress(remoteAddress *appmessage.NetAddre
 		} else {
 			ip = net.IPv4zero
 		}
-		services := appmessage.SFNodeNetwork | appmessage.SFNodeBloom
-		bestAddress = appmessage.NewNetAddressIPPort(ip, 0, services)
+		services := domainmessage.SFNodeNetwork | domainmessage.SFNodeBloom
+		bestAddress = domainmessage.NewNetAddressIPPort(ip, 0, services)
 	}
 
 	return bestAddress
 }
 
 // Ban marks the given address as banned
-func (am *AddressManager) Ban(address *appmessage.NetAddress) error {
+func (am *AddressManager) Ban(address *domainmessage.NetAddress) error {
 	return am.setBanned(address, true, mstime.Now())
 }
 
 // Unban marks the given address as not banned
-func (am *AddressManager) Unban(address *appmessage.NetAddress) error {
+func (am *AddressManager) Unban(address *domainmessage.NetAddress) error {
 	return am.setBanned(address, false, mstime.Time{})
 }
 
-func (am *AddressManager) setBanned(address *appmessage.NetAddress, isBanned bool, bannedTime mstime.Time) error {
+func (am *AddressManager) setBanned(address *domainmessage.NetAddress, isBanned bool, bannedTime mstime.Time) error {
 	am.localAddressesLock.Lock()
 	defer am.localAddressesLock.Unlock()
 
@@ -1396,7 +1408,7 @@ func (am *AddressManager) setBanned(address *appmessage.NetAddress, isBanned boo
 }
 
 // IsBanned returns whether the given address is banned
-func (am *AddressManager) IsBanned(address *appmessage.NetAddress) (bool, error) {
+func (am *AddressManager) IsBanned(address *domainmessage.NetAddress) (bool, error) {
 	am.localAddressesLock.Lock()
 	defer am.localAddressesLock.Unlock()
 
@@ -1407,188 +1419,3 @@ func (am *AddressManager) IsBanned(address *appmessage.NetAddress) (bool, error)
 	}
 	return knownAddress.isBanned, nil
 }
-
-// initListeners initializes the configured net listeners and adds any bound
-// addresses to the address manager
-func (am *AddressManager) initListeners() error {
-	if len(am.cfg.ExternalIPs) != 0 {
-		defaultPort, err := strconv.ParseUint(am.cfg.NetParams().DefaultPort, 10, 16)
-		if err != nil {
-			log.Errorf("Can not parse default port %s for active DAG: %s",
-				am.cfg.NetParams().DefaultPort, err)
-			return err
-		}
-
-		for _, sip := range am.cfg.ExternalIPs {
-			eport := uint16(defaultPort)
-			host, portstr, err := net.SplitHostPort(sip)
-			if err != nil {
-				// no port, use default.
-				host = sip
-			} else {
-				port, err := strconv.ParseUint(portstr, 10, 16)
-				if err != nil {
-					log.Warnf("Can not parse port from %s for "+
-						"externalip: %s", sip, err)
-					continue
-				}
-				eport = uint16(port)
-			}
-			na, err := am.HostToNetAddress(host, eport, appmessage.DefaultServices)
-			if err != nil {
-				log.Warnf("Not adding %s as externalip: %s", sip, err)
-				continue
-			}
-
-			err = am.AddLocalAddress(na, ManualPrio)
-			if err != nil {
-				log.Warnf("Skipping specified external IP: %s", err)
-			}
-		}
-	} else {
-		// Listen for TCP connections at the configured addresses
-		netAddrs, err := parseListeners(am.cfg.Listeners)
-		if err != nil {
-			return err
-		}
-
-		// Add bound addresses to address manager to be advertised to peers.
-		for _, addr := range netAddrs {
-			listener, err := net.Listen(addr.Network(), addr.String())
-			if err != nil {
-				log.Warnf("Can't listen on %s: %s", addr, err)
-				continue
-			}
-			addr := listener.Addr().String()
-			err = listener.Close()
-			if err != nil {
-				return err
-			}
-			err = am.addLocalAddress(addr)
-			if err != nil {
-				log.Warnf("Skipping bound address %s: %s", addr, err)
-			}
-		}
-	}
-
-	return nil
-}
-
-// parseListeners determines whether each listen address is IPv4 and IPv6 and
-// returns a slice of appropriate net.Addrs to listen on with TCP. It also
-// properly detects addresses which apply to "all interfaces" and adds the
-// address as both IPv4 and IPv6.
-func parseListeners(addrs []string) ([]net.Addr, error) {
-	netAddrs := make([]net.Addr, 0, len(addrs)*2)
-	for _, addr := range addrs {
-		host, _, err := net.SplitHostPort(addr)
-		if err != nil {
-			// Shouldn't happen due to already being normalized.
-			return nil, err
-		}
-
-		// Empty host or host of * on plan9 is both IPv4 and IPv6.
-		if host == "" || (host == "*" && runtime.GOOS == "plan9") {
-			netAddrs = append(netAddrs, simpleAddr{net: "tcp4", addr: addr})
-			netAddrs = append(netAddrs, simpleAddr{net: "tcp6", addr: addr})
-			continue
-		}
-
-		// Strip IPv6 zone id if present since net.ParseIP does not
-		// handle it.
-		zoneIndex := strings.LastIndex(host, "%")
-		if zoneIndex > 0 {
-			host = host[:zoneIndex]
-		}
-
-		// Parse the IP.
-		ip := net.ParseIP(host)
-		if ip == nil {
-			hostAddrs, err := net.LookupHost(host)
-			if err != nil {
-				return nil, err
-			}
-			ip = net.ParseIP(hostAddrs[0])
-			if ip == nil {
-				return nil, errors.Errorf("Cannot resolve IP address for host '%s'", host)
-			}
-		}
-
-		// To4 returns nil when the IP is not an IPv4 address, so use
-		// this determine the address type.
-		if ip.To4() == nil {
-			netAddrs = append(netAddrs, simpleAddr{net: "tcp6", addr: addr})
-		} else {
-			netAddrs = append(netAddrs, simpleAddr{net: "tcp4", addr: addr})
-		}
-	}
-	return netAddrs, nil
-}
-
-// addLocalAddress adds an address that this node is listening on to the
-// address manager so that it may be relayed to peers.
-func (am *AddressManager) addLocalAddress(addr string) error {
-	host, portStr, err := net.SplitHostPort(addr)
-	if err != nil {
-		return err
-	}
-	port, err := strconv.ParseUint(portStr, 10, 16)
-	if err != nil {
-		return err
-	}
-
-	if ip := net.ParseIP(host); ip != nil && ip.IsUnspecified() {
-		// If bound to unspecified address, advertise all local interfaces
-		addrs, err := net.InterfaceAddrs()
-		if err != nil {
-			return err
-		}
-
-		for _, addr := range addrs {
-			ifaceIP, _, err := net.ParseCIDR(addr.String())
-			if err != nil {
-				continue
-			}
-
-			// If bound to 0.0.0.0, do not add IPv6 interfaces and if bound to
-			// ::, do not add IPv4 interfaces.
-			if (ip.To4() == nil) != (ifaceIP.To4() == nil) {
-				continue
-			}
-
-			netAddr := appmessage.NewNetAddressIPPort(ifaceIP, uint16(port), appmessage.DefaultServices)
-			am.AddLocalAddress(netAddr, BoundPrio)
-		}
-	} else {
-		netAddr, err := am.HostToNetAddress(host, uint16(port), appmessage.DefaultServices)
-		if err != nil {
-			return err
-		}
-
-		am.AddLocalAddress(netAddr, BoundPrio)
-	}
-
-	return nil
-}
-
-// simpleAddr implements the net.Addr interface with two struct fields
-type simpleAddr struct {
-	net, addr string
-}
-
-// String returns the address.
-//
-// This is part of the net.Addr interface.
-func (a simpleAddr) String() string {
-	return a.addr
-}
-
-// Network returns the network.
-//
-// This is part of the net.Addr interface.
-func (a simpleAddr) Network() string {
-	return a.net
-}
-
-// Ensure simpleAddr implements the net.Addr interface.
-var _ net.Addr = simpleAddr{}

addressmanager/addressmanager_test.go

@@ -12,24 +12,20 @@ import (
 	"testing"
 	"time"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
-	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-
-	"github.com/kaspanet/kaspad/infrastructure/config"
+	"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/domainmessage"
 )
 
 // naTest is used to describe a test to be performed against the NetAddressKey
 // method.
 type naTest struct {
-	in   appmessage.NetAddress
+	in   domainmessage.NetAddress
 	want AddressKey
 }
 
@@ -103,7 +99,7 @@ func addNaTests() {
 
 func addNaTest(ip string, port uint16, want AddressKey) {
 	nip := net.ParseIP(ip)
-	na := *appmessage.NewNetAddressIPPort(nip, port, appmessage.SFNodeNetwork)
+	na := *domainmessage.NewNetAddressIPPort(nip, port, domainmessage.SFNodeNetwork)
 	test := naTest{na, want}
 	naTests = append(naTests, test)
 }
@@ -113,7 +109,7 @@ func lookupFuncForTest(host string) ([]net.IP, error) {
 }
 
 func newAddrManagerForTest(t *testing.T, testName string,
-	localSubnetworkID *externalapi.DomainSubnetworkID) (addressManager *AddressManager, teardown func()) {
+	localSubnetworkID *subnetworkid.SubnetworkID) (addressManager *AddressManager, teardown func()) {
 
 	cfg := config.DefaultConfig()
 	cfg.SubnetworkID = localSubnetworkID
@@ -123,15 +119,12 @@ func newAddrManagerForTest(t *testing.T, testName string,
 		t.Fatalf("Error creating temporary directory: %s", err)
 	}
 
-	databaseContext, err := ldb.NewLevelDB(dbPath)
+	databaseContext, err := dbaccess.New(dbPath)
 	if err != nil {
 		t.Fatalf("error creating db: %s", err)
 	}
 
-	addressManager, err = New(cfg, databaseContext)
-	if err != nil {
-		t.Fatalf("error creating address manager: %s", err)
-	}
+	addressManager = New(cfg, databaseContext)
 
 	return addressManager, func() {
 		err := databaseContext.Close()
@@ -182,7 +175,7 @@ func TestAddAddressByIP(t *testing.T) {
 	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
 	defer teardown()
 	for i, test := range tests {
-		err := AddAddressByIP(amgr, test.addrIP, nil)
+		err := amgr.AddAddressByIP(test.addrIP, nil)
 		if test.err != nil && err == nil {
 			t.Errorf("TestAddAddressByIP test %d failed expected an error and got none", i)
 			continue
@@ -201,37 +194,37 @@ func TestAddAddressByIP(t *testing.T) {
 
 func TestAddLocalAddress(t *testing.T) {
 	var tests = []struct {
-		address  appmessage.NetAddress
+		address  domainmessage.NetAddress
 		priority AddressPriority
 		valid    bool
 	}{
 		{
-			appmessage.NetAddress{IP: net.ParseIP("192.168.0.100")},
+			domainmessage.NetAddress{IP: net.ParseIP("192.168.0.100")},
 			InterfacePrio,
 			false,
 		},
 		{
-			appmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
+			domainmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
 			InterfacePrio,
 			true,
 		},
 		{
-			appmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
+			domainmessage.NetAddress{IP: net.ParseIP("204.124.1.1")},
 			BoundPrio,
 			true,
 		},
 		{
-			appmessage.NetAddress{IP: net.ParseIP("::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("::1")},
 			InterfacePrio,
 			false,
 		},
 		{
-			appmessage.NetAddress{IP: net.ParseIP("fe80::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("fe80::1")},
 			InterfacePrio,
 			false,
 		},
 		{
-			appmessage.NetAddress{IP: net.ParseIP("2620:100::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("2620:100::1")},
 			InterfacePrio,
 			true,
 		},
@@ -258,7 +251,7 @@ func TestAttempt(t *testing.T) {
 	defer teardown()
 
 	// Add a new address and get it
-	err := AddAddressByIP(amgr, someIP+":8333", nil)
+	err := amgr.AddAddressByIP(someIP+":8333", nil)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
@@ -281,7 +274,7 @@ func TestConnected(t *testing.T) {
 	defer teardown()
 
 	// Add a new address and get it
-	err := AddAddressByIP(amgr, someIP+":8333", nil)
+	err := amgr.AddAddressByIP(someIP+":8333", nil)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
@@ -305,7 +298,7 @@ func TestNeedMoreAddresses(t *testing.T) {
 	if !b {
 		t.Errorf("Expected that we need more addresses")
 	}
-	addrs := make([]*appmessage.NetAddress, addrsToAdd)
+	addrs := make([]*domainmessage.NetAddress, addrsToAdd)
 
 	var err error
 	for i := 0; i < addrsToAdd; i++ {
@@ -316,7 +309,7 @@ func TestNeedMoreAddresses(t *testing.T) {
 		}
 	}
 
-	srcAddr := appmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+	srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
 	amgr.AddAddresses(addrs, srcAddr, nil)
 	numAddrs := amgr.TotalNumAddresses()
@@ -334,9 +327,9 @@ func TestGood(t *testing.T) {
 	amgr, teardown := newAddrManagerForTest(t, "TestGood", nil)
 	defer teardown()
 	addrsToAdd := 64 * 64
-	addrs := make([]*appmessage.NetAddress, addrsToAdd)
+	addrs := make([]*domainmessage.NetAddress, addrsToAdd)
 	subnetworkCount := 32
-	subnetworkIDs := make([]*externalapi.DomainSubnetworkID, subnetworkCount)
+	subnetworkIDs := make([]*subnetworkid.SubnetworkID, subnetworkCount)
 
 	var err error
 	for i := 0; i < addrsToAdd; i++ {
@@ -348,10 +341,10 @@ func TestGood(t *testing.T) {
 	}
 
 	for i := 0; i < subnetworkCount; i++ {
-		subnetworkIDs[i] = &externalapi.DomainSubnetworkID{0xff - byte(i)}
+		subnetworkIDs[i] = &subnetworkid.SubnetworkID{0xff - byte(i)}
 	}
 
-	srcAddr := appmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+	srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
 	amgr.AddAddresses(addrs, srcAddr, nil)
 	for i, addr := range addrs {
@@ -381,11 +374,11 @@ func TestGood(t *testing.T) {
 func TestGoodChangeSubnetworkID(t *testing.T) {
 	amgr, teardown := newAddrManagerForTest(t, "TestGoodChangeSubnetworkID", nil)
 	defer teardown()
-	addr := appmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+	addr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 	addrKey := NetAddressKey(addr)
-	srcAddr := appmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+	srcAddr := domainmessage.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
 
-	oldSubnetwork := &subnetworks.SubnetworkIDNative
+	oldSubnetwork := subnetworkid.SubnetworkIDNative
 	amgr.AddAddress(addr, srcAddr, oldSubnetwork)
 	amgr.Good(addr, oldSubnetwork)
 
@@ -394,7 +387,7 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	if ka == nil {
 		t.Fatalf("Address was not found after first time .Good called")
 	}
-	if *ka.SubnetworkID() != *oldSubnetwork {
+	if !ka.SubnetworkID().IsEqual(oldSubnetwork) {
 		t.Fatalf("Address index did not point to oldSubnetwork")
 	}
 
@@ -411,7 +404,7 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	}
 
 	// now call .Good again with a different subnetwork
-	newSubnetwork := &subnetworks.SubnetworkIDRegistry
+	newSubnetwork := subnetworkid.SubnetworkIDRegistry
 	amgr.Good(addr, newSubnetwork)
 
 	// make sure address was updated in addressIndex under newSubnetwork
@@ -419,7 +412,7 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 	if ka == nil {
 		t.Fatalf("Address was not found after second time .Good called")
 	}
-	if *ka.SubnetworkID() != *newSubnetwork {
+	if !ka.SubnetworkID().IsEqual(newSubnetwork) {
 		t.Fatalf("Address index did not point to newSubnetwork")
 	}
 
@@ -449,7 +442,7 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 }
 
 func TestGetAddress(t *testing.T) {
-	localSubnetworkID := &externalapi.DomainSubnetworkID{0xff}
+	localSubnetworkID := &subnetworkid.SubnetworkID{0xff}
 	amgr, teardown := newAddrManagerForTest(t, "TestGetAddress", localSubnetworkID)
 	defer teardown()
 
@@ -459,7 +452,7 @@ func TestGetAddress(t *testing.T) {
 	}
 
 	// Add a new address and get it
-	err := AddAddressByIP(amgr, someIP+":8332", localSubnetworkID)
+	err := amgr.AddAddressByIP(someIP+":8332", localSubnetworkID)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
@@ -470,7 +463,7 @@ func TestGetAddress(t *testing.T) {
 	amgr.Attempt(ka.NetAddress())
 
 	// Checks that we don't get it if we find that it has other subnetwork ID than expected.
-	actualSubnetworkID := &externalapi.DomainSubnetworkID{0xfe}
+	actualSubnetworkID := &subnetworkid.SubnetworkID{0xfe}
 	amgr.Good(ka.NetAddress(), actualSubnetworkID)
 	ka = amgr.GetAddress()
 	if ka != nil {
@@ -486,7 +479,7 @@ 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 = AddAddressByIP(amgr, someIP+":8333", localSubnetworkID)
+	err = amgr.AddAddressByIP(someIP+":8333", localSubnetworkID)
 	if err != nil {
 		t.Fatalf("Adding address failed: %v", err)
 	}
@@ -497,7 +490,7 @@ func TestGetAddress(t *testing.T) {
 	if ka.NetAddress().IP.String() != someIP {
 		t.Errorf("Wrong IP: got %v, want %v", ka.NetAddress().IP.String(), someIP)
 	}
-	if *ka.SubnetworkID() != *localSubnetworkID {
+	if !ka.SubnetworkID().IsEqual(localSubnetworkID) {
 		t.Errorf("Wrong Subnetwork ID: got %v, want %v", *ka.SubnetworkID(), localSubnetworkID)
 	}
 	amgr.Attempt(ka.NetAddress())
@@ -522,7 +515,7 @@ func TestGetAddress(t *testing.T) {
 }
 
 func TestGetBestLocalAddress(t *testing.T) {
-	localAddrs := []appmessage.NetAddress{
+	localAddrs := []domainmessage.NetAddress{
 		{IP: net.ParseIP("192.168.0.100")},
 		{IP: net.ParseIP("::1")},
 		{IP: net.ParseIP("fe80::1")},
@@ -530,36 +523,45 @@ func TestGetBestLocalAddress(t *testing.T) {
 	}
 
 	var tests = []struct {
-		remoteAddr appmessage.NetAddress
-		want0      appmessage.NetAddress
-		want1      appmessage.NetAddress
-		want2      appmessage.NetAddress
-		want3      appmessage.NetAddress
+		remoteAddr domainmessage.NetAddress
+		want0      domainmessage.NetAddress
+		want1      domainmessage.NetAddress
+		want2      domainmessage.NetAddress
+		want3      domainmessage.NetAddress
 	}{
 		{
 			// Remote connection from public IPv4
-			appmessage.NetAddress{IP: net.ParseIP("204.124.8.1")},
-			appmessage.NetAddress{IP: net.IPv4zero},
-			appmessage.NetAddress{IP: net.IPv4zero},
-			appmessage.NetAddress{IP: net.ParseIP("204.124.8.100")},
-			appmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("204.124.8.1")},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")},
+			domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
 		},
 		{
 			// Remote connection from private IPv4
-			appmessage.NetAddress{IP: net.ParseIP("172.16.0.254")},
-			appmessage.NetAddress{IP: net.IPv4zero},
-			appmessage.NetAddress{IP: net.IPv4zero},
-			appmessage.NetAddress{IP: net.IPv4zero},
-			appmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.ParseIP("172.16.0.254")},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.IPv4zero},
 		},
 		{
 			// Remote connection from public IPv6
-			appmessage.NetAddress{IP: net.ParseIP("2602:100:abcd::102")},
-			appmessage.NetAddress{IP: net.IPv6zero},
-			appmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
-			appmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
-			appmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("2602:100:abcd::102")},
+			domainmessage.NetAddress{IP: net.IPv6zero},
+			domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
+			domainmessage.NetAddress{IP: net.ParseIP("2001:470::1")},
 		},
+		/* XXX
+		{
+			// Remote connection from Tor
+			domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43::100")},
+			domainmessage.NetAddress{IP: net.IPv4zero},
+			domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")},
+			domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
+		},
+		*/
 	}
 
 	amgr, teardown := newAddrManagerForTest(t, "TestGetBestLocalAddress", nil)
@@ -590,7 +592,7 @@ func TestGetBestLocalAddress(t *testing.T) {
 	}
 
 	// Add a public IP to the list of local addresses.
-	localAddr := appmessage.NetAddress{IP: net.ParseIP("204.124.8.100")}
+	localAddr := domainmessage.NetAddress{IP: net.ParseIP("204.124.8.100")}
 	amgr.AddLocalAddress(&localAddr, InterfacePrio)
 
 	// Test against want2
@@ -604,7 +606,7 @@ func TestGetBestLocalAddress(t *testing.T) {
 	}
 	/*
 		// Add a Tor generated IP address
-		localAddr = appmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
+		localAddr = domainmessage.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
 		amgr.AddLocalAddress(&localAddr, ManualPrio)
 		// Test against want3
 		for x, test := range tests {
@@ -629,4 +631,5 @@ func TestNetAddressKey(t *testing.T) {
 			continue
 		}
 	}
+
 }

addressmanager/internal_test.go

@@ -5,7 +5,7 @@
 package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/mstime"
 )
 
@@ -17,7 +17,7 @@ func TstKnownAddressChance(ka *KnownAddress) float64 {
 	return ka.chance()
 }
 
-func TstNewKnownAddress(na *appmessage.NetAddress, attempts int,
+func TstNewKnownAddress(na *domainmessage.NetAddress, attempts int,
 	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

@@ -5,36 +5,37 @@
 package addressmanager
 
 import (
+	"github.com/kaspanet/kaspad/util/mstime"
 	"time"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
 // KnownAddress tracks information about a known network address that is used
 // to determine how viable an address is.
 type KnownAddress struct {
-	netAddress     *appmessage.NetAddress
-	sourceAddress  *appmessage.NetAddress
+	netAddress     *domainmessage.NetAddress
+	sourceAddress  *domainmessage.NetAddress
 	attempts       int
 	lastAttempt    mstime.Time
 	lastSuccess    mstime.Time
 	tried          bool
 	referenceCount int // reference count of new buckets
-	subnetworkID   *externalapi.DomainSubnetworkID
+	subnetworkID   *subnetworkid.SubnetworkID
 	isBanned       bool
 	bannedTime     mstime.Time
 }
 
-// NetAddress returns the underlying appmessage.NetAddress associated with the
+// NetAddress returns the underlying domainmessage.NetAddress associated with the
 // known address.
-func (ka *KnownAddress) NetAddress() *appmessage.NetAddress {
+func (ka *KnownAddress) NetAddress() *domainmessage.NetAddress {
 	return ka.netAddress
 }
 
 // SubnetworkID returns the subnetwork ID of the known address.
-func (ka *KnownAddress) SubnetworkID() *externalapi.DomainSubnetworkID {
+func (ka *KnownAddress) SubnetworkID() *subnetworkid.SubnetworkID {
 	return ka.subnetworkID
 }
 

addressmanager/knownaddress_test.go

@@ -5,13 +5,13 @@
 package addressmanager_test
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"math"
 	"testing"
 	"time"
 
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/addressmanager"
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
 func TestChance(t *testing.T) {
@@ -22,27 +22,27 @@ func TestChance(t *testing.T) {
 	}{
 		{
 			//Test normal case
-			addressmanager.TstNewKnownAddress(&appmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+			addressmanager.TstNewKnownAddress(&domainmessage.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(&appmessage.NetAddress{Timestamp: now.Add(20 * time.Second)},
+			addressmanager.TstNewKnownAddress(&domainmessage.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(&appmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+			addressmanager.TstNewKnownAddress(&domainmessage.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(&appmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+			addressmanager.TstNewKnownAddress(&domainmessage.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(&appmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
+			addressmanager.TstNewKnownAddress(&domainmessage.NetAddress{Timestamp: now.Add(-35 * time.Second)},
 				2, mstime.Now().Add(-30*time.Minute), mstime.Now(), false, 0),
 			1 / 1.5 / 1.5,
 		},
@@ -66,10 +66,10 @@ func TestIsBad(t *testing.T) {
 	hoursOld := now.Add(-5 * time.Hour)
 	zeroTime := mstime.Time{}
 
-	futureNa := &appmessage.NetAddress{Timestamp: future}
-	minutesOldNa := &appmessage.NetAddress{Timestamp: minutesOld}
-	monthOldNa := &appmessage.NetAddress{Timestamp: monthOld}
-	currentNa := &appmessage.NetAddress{Timestamp: secondsOld}
+	futureNa := &domainmessage.NetAddress{Timestamp: future}
+	minutesOldNa := &domainmessage.NetAddress{Timestamp: minutesOld}
+	monthOldNa := &domainmessage.NetAddress{Timestamp: monthOld}
+	currentNa := &domainmessage.NetAddress{Timestamp: secondsOld}
 
 	//Test addresses that have been tried in the last minute.
 	if addressmanager.TstKnownAddressIsBad(addressmanager.TstNewKnownAddress(futureNa, 3, secondsOld, zeroTime, false, 0)) {

addressmanager/log.go

@@ -5,7 +5,7 @@
 package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/logger"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 

addressmanager/network.go

@@ -5,8 +5,9 @@
 package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
 	"net"
+
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
 var (
@@ -85,19 +86,19 @@ func ipNet(ip string, ones, bits int) net.IPNet {
 }
 
 // IsIPv4 returns whether or not the given address is an IPv4 address.
-func IsIPv4(na *appmessage.NetAddress) bool {
+func IsIPv4(na *domainmessage.NetAddress) bool {
 	return na.IP.To4() != nil
 }
 
 // IsLocal returns whether or not the given address is a local address.
-func IsLocal(na *appmessage.NetAddress) bool {
+func IsLocal(na *domainmessage.NetAddress) bool {
 	return na.IP.IsLoopback() || zero4Net.Contains(na.IP)
 }
 
 // IsRFC1918 returns whether or not the passed address is part of the IPv4
 // private network address space as defined by RFC1918 (10.0.0.0/8,
 // 172.16.0.0/12, or 192.168.0.0/16).
-func IsRFC1918(na *appmessage.NetAddress) bool {
+func IsRFC1918(na *domainmessage.NetAddress) bool {
 	for _, rfc := range rfc1918Nets {
 		if rfc.Contains(na.IP) {
 			return true
@@ -108,56 +109,56 @@ func IsRFC1918(na *appmessage.NetAddress) bool {
 
 // IsRFC2544 returns whether or not the passed address is part of the IPv4
 // address space as defined by RFC2544 (198.18.0.0/15)
-func IsRFC2544(na *appmessage.NetAddress) bool {
+func IsRFC2544(na *domainmessage.NetAddress) bool {
 	return rfc2544Net.Contains(na.IP)
 }
 
 // IsRFC3849 returns whether or not the passed address is part of the IPv6
 // documentation range as defined by RFC3849 (2001:DB8::/32).
-func IsRFC3849(na *appmessage.NetAddress) bool {
+func IsRFC3849(na *domainmessage.NetAddress) bool {
 	return rfc3849Net.Contains(na.IP)
 }
 
 // IsRFC3927 returns whether or not the passed address is part of the IPv4
 // autoconfiguration range as defined by RFC3927 (169.254.0.0/16).
-func IsRFC3927(na *appmessage.NetAddress) bool {
+func IsRFC3927(na *domainmessage.NetAddress) bool {
 	return rfc3927Net.Contains(na.IP)
 }
 
 // IsRFC3964 returns whether or not the passed address is part of the IPv6 to
 // IPv4 encapsulation range as defined by RFC3964 (2002::/16).
-func IsRFC3964(na *appmessage.NetAddress) bool {
+func IsRFC3964(na *domainmessage.NetAddress) bool {
 	return rfc3964Net.Contains(na.IP)
 }
 
 // IsRFC4193 returns whether or not the passed address is part of the IPv6
 // unique local range as defined by RFC4193 (FC00::/7).
-func IsRFC4193(na *appmessage.NetAddress) bool {
+func IsRFC4193(na *domainmessage.NetAddress) bool {
 	return rfc4193Net.Contains(na.IP)
 }
 
 // IsRFC4380 returns whether or not the passed address is part of the IPv6
 // teredo tunneling over UDP range as defined by RFC4380 (2001::/32).
-func IsRFC4380(na *appmessage.NetAddress) bool {
+func IsRFC4380(na *domainmessage.NetAddress) bool {
 	return rfc4380Net.Contains(na.IP)
 }
 
 // IsRFC4843 returns whether or not the passed address is part of the IPv6
 // ORCHID range as defined by RFC4843 (2001:10::/28).
-func IsRFC4843(na *appmessage.NetAddress) bool {
+func IsRFC4843(na *domainmessage.NetAddress) bool {
 	return rfc4843Net.Contains(na.IP)
 }
 
 // IsRFC4862 returns whether or not the passed address is part of the IPv6
 // stateless address autoconfiguration range as defined by RFC4862 (FE80::/64).
-func IsRFC4862(na *appmessage.NetAddress) bool {
+func IsRFC4862(na *domainmessage.NetAddress) bool {
 	return rfc4862Net.Contains(na.IP)
 }
 
 // IsRFC5737 returns whether or not the passed address is part of the IPv4
 // documentation address space as defined by RFC5737 (192.0.2.0/24,
 // 198.51.100.0/24, 203.0.113.0/24)
-func IsRFC5737(na *appmessage.NetAddress) bool {
+func IsRFC5737(na *domainmessage.NetAddress) bool {
 	for _, rfc := range rfc5737Net {
 		if rfc.Contains(na.IP) {
 			return true
@@ -169,19 +170,19 @@ func IsRFC5737(na *appmessage.NetAddress) bool {
 
 // IsRFC6052 returns whether or not the passed address is part of the IPv6
 // well-known prefix range as defined by RFC6052 (64:FF9B::/96).
-func IsRFC6052(na *appmessage.NetAddress) bool {
+func IsRFC6052(na *domainmessage.NetAddress) bool {
 	return rfc6052Net.Contains(na.IP)
 }
 
 // IsRFC6145 returns whether or not the passed address is part of the IPv6 to
 // IPv4 translated address range as defined by RFC6145 (::FFFF:0:0:0/96).
-func IsRFC6145(na *appmessage.NetAddress) bool {
+func IsRFC6145(na *domainmessage.NetAddress) bool {
 	return rfc6145Net.Contains(na.IP)
 }
 
 // IsRFC6598 returns whether or not the passed address is part of the IPv4
 // shared address space specified by RFC6598 (100.64.0.0/10)
-func IsRFC6598(na *appmessage.NetAddress) bool {
+func IsRFC6598(na *domainmessage.NetAddress) bool {
 	return rfc6598Net.Contains(na.IP)
 }
 
@@ -189,7 +190,7 @@ func IsRFC6598(na *appmessage.NetAddress) bool {
 // considered invalid under the following circumstances:
 // IPv4: It is either a zero or all bits set address.
 // IPv6: It is either a zero or RFC3849 documentation address.
-func IsValid(na *appmessage.NetAddress) bool {
+func IsValid(na *domainmessage.NetAddress) bool {
 	// IsUnspecified returns if address is 0, so only all bits set, and
 	// RFC3849 need to be explicitly checked.
 	return na.IP != nil && !(na.IP.IsUnspecified() ||
@@ -199,7 +200,7 @@ func IsValid(na *appmessage.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 (am *AddressManager) IsRoutable(na *appmessage.NetAddress) bool {
+func (am *AddressManager) IsRoutable(na *domainmessage.NetAddress) bool {
 	if am.cfg.NetParams().AcceptUnroutable {
 		return !IsLocal(na)
 	}
@@ -214,7 +215,7 @@ func (am *AddressManager) IsRoutable(na *appmessage.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 (am *AddressManager) GroupKey(na *appmessage.NetAddress) string {
+func (am *AddressManager) GroupKey(na *domainmessage.NetAddress) string {
 	if IsLocal(na) {
 		return "local"
 	}

addressmanager/network_test.go

@@ -5,9 +5,10 @@
 package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
 	"net"
 	"testing"
+
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
 // TestIPTypes ensures the various functions which determine the type of an IP
@@ -16,7 +17,7 @@ func TestIPTypes(t *testing.T) {
 	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
 	defer teardown()
 	type ipTest struct {
-		in       appmessage.NetAddress
+		in       domainmessage.NetAddress
 		rfc1918  bool
 		rfc2544  bool
 		rfc3849  bool
@@ -39,7 +40,7 @@ func TestIPTypes(t *testing.T) {
 		rfc4193, rfc4380, rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598,
 		local, valid, routable bool) ipTest {
 		nip := net.ParseIP(ip)
-		na := *appmessage.NewNetAddressIPPort(nip, 16111, appmessage.SFNodeNetwork)
+		na := *domainmessage.NewNetAddressIPPort(nip, 16111, domainmessage.SFNodeNetwork)
 		test := ipTest{na, rfc1918, rfc2544, rfc3849, rfc3927, rfc3964, rfc4193, rfc4380,
 			rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598, local, valid, routable}
 		return test
@@ -195,7 +196,7 @@ func TestGroupKey(t *testing.T) {
 
 	for i, test := range tests {
 		nip := net.ParseIP(test.ip)
-		na := *appmessage.NewNetAddressIPPort(nip, 8333, appmessage.SFNodeNetwork)
+		na := *domainmessage.NewNetAddressIPPort(nip, 8333, domainmessage.SFNodeNetwork)
 		if key := amgr.GroupKey(&na); key != test.expected {
 			t.Errorf("TestGroupKey #%d (%s): unexpected group key "+
 				"- got '%s', want '%s'", i, test.name,

app/app.go

@@ -2,184 +2,248 @@ package app
 
 import (
 	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
+	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/infrastructure/db/database"
-	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
+	"github.com/kaspanet/kaspad/addressmanager"
 
-	"github.com/kaspanet/kaspad/infrastructure/os/signal"
-	"github.com/kaspanet/kaspad/util/profiling"
-	"github.com/kaspanet/kaspad/version"
+	"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/domainmessage"
+	"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/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
-	"github.com/kaspanet/kaspad/infrastructure/os/limits"
-	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
 )
 
-var desiredLimits = &limits.DesiredLimits{
-	FileLimitWant: 2048,
-	FileLimitMin:  1024,
+// 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
 }
 
-var serviceDescription = &winservice.ServiceDescription{
-	Name:        "kaspadsvc",
-	DisplayName: "Kaspad Service",
-	Description: "Downloads and stays synchronized with the Kaspa blockDAG and " +
-		"provides DAG services to applications.",
-}
+// Start launches all the kaspad services.
+func (a *App) Start() {
+	// Already started?
+	if atomic.AddInt32(&a.started, 1) != 1 {
+		return
+	}
 
-type kaspadApp struct {
-	cfg *config.Config
-}
+	log.Trace("Starting kaspad")
 
-// StartApp starts the kaspad app, and blocks until it finishes running
-func StartApp() error {
-	execenv.Initialize(desiredLimits)
-
-	// Load configuration and parse command line. This function also
-	// initializes logging and configures it accordingly.
-	cfg, err := config.LoadConfig()
+	err := a.protocolManager.Start()
 	if err != nil {
-		fmt.Fprint(os.Stderr, err)
-		return err
-	}
-	defer panics.HandlePanic(log, "MAIN", nil)
-
-	app := &kaspadApp{cfg: cfg}
-
-	// Call serviceMain on Windows to handle running as a service. When
-	// the return isService flag is true, exit now since we ran as a
-	// service. Otherwise, just fall through to normal operation.
-	if runtime.GOOS == "windows" {
-		isService, err := winservice.WinServiceMain(app.main, serviceDescription, cfg)
-		if err != nil {
-			return err
-		}
-		if isService {
-			return nil
-		}
+		panics.Exit(log, fmt.Sprintf("Error starting the p2p protocol: %+v", err))
 	}
 
-	return app.main(nil)
+	a.maybeSeedFromDNS()
+
+	a.connectionManager.Start()
+
+	if !a.cfg.DisableRPC {
+		a.rpcServer.Start()
+	}
 }
 
-func (app *kaspadApp) main(startedChan chan<- struct{}) error {
-	// Get a channel that will be closed when a shutdown signal has been
-	// triggered either from an OS signal such as SIGINT (Ctrl+C) or from
-	// another subsystem such as the RPC server.
-	interrupt := signal.InterruptListener()
-	defer log.Info("Shutdown complete")
-
-	// Show version at startup.
-	log.Infof("Version %s", version.Version())
-
-	// Enable http profiling server if requested.
-	if app.cfg.Profile != "" {
-		profiling.Start(app.cfg.Profile, log)
-	}
-
-	// Perform upgrades to kaspad as new versions require it.
-	if err := doUpgrades(); err != nil {
-		log.Error(err)
-		return err
-	}
-
-	// Return now if an interrupt signal was triggered.
-	if signal.InterruptRequested(interrupt) {
+// 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
 	}
 
-	if app.cfg.ResetDatabase {
-		err := removeDatabase(app.cfg)
-		if err != nil {
-			log.Error(err)
-			return err
-		}
-	}
+	log.Warnf("Kaspad shutting down")
 
-	// Open the database
-	databaseContext, err := openDB(app.cfg)
+	a.connectionManager.Stop()
+
+	err := a.protocolManager.Stop()
 	if err != nil {
-		log.Error(err)
-		return err
+		log.Errorf("Error stopping the p2p protocol: %+v", err)
 	}
 
-	defer func() {
-		log.Infof("Gracefully shutting down the database...")
-		err := databaseContext.Close()
+	// Shutdown the RPC server if it's not disabled.
+	if !a.cfg.DisableRPC {
+		err := a.rpcServer.Stop()
 		if err != nil {
-			log.Errorf("Failed to close the database: %s", err)
+			log.Errorf("Error stopping rpcServer: %+v", err)
 		}
-	}()
-
-	// Return now if an interrupt signal was triggered.
-	if signal.InterruptRequested(interrupt) {
-		return nil
 	}
 
-	// Create componentManager and start it.
-	componentManager, err := NewComponentManager(app.cfg, databaseContext, interrupt)
-	if err != nil {
-		log.Errorf("Unable to start kaspad: %+v", err)
-		return err
-	}
-
-	defer func() {
-		log.Infof("Gracefully shutting down kaspad...")
-
-		shutdownDone := make(chan struct{})
-		go func() {
-			componentManager.Stop()
-			shutdownDone <- struct{}{}
-		}()
-
-		const shutdownTimeout = 2 * time.Minute
-
-		select {
-		case <-shutdownDone:
-		case <-time.After(shutdownTimeout):
-			log.Criticalf("Graceful shutdown timed out %s. Terminating...", shutdownTimeout)
-		}
-		log.Infof("Kaspad shutdown complete")
-	}()
-
-	componentManager.Start()
-
-	if startedChan != nil {
-		startedChan <- struct{}{}
-	}
-
-	// Wait until the interrupt signal is received from an OS signal or
-	// shutdown is requested through one of the subsystems such as the RPC
-	// server.
-	<-interrupt
 	return nil
 }
 
-// doUpgrades performs upgrades to kaspad as new versions require it.
-// currently it's a placeholder we got from kaspad upstream, that does nothing
-func doUpgrades() error {
-	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
 }
 
-// dbPath returns the path to the block database given a database type.
-func databasePath(cfg *config.Config) string {
-	return filepath.Join(cfg.DataDir, "db")
+func (a *App) maybeSeedFromDNS() {
+	if !a.cfg.DisableDNSSeed {
+		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, domainmessage.SFNodeNetwork, false, nil,
+			a.cfg.Lookup, func(addresses []*domainmessage.NetAddress) {
+				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
+				// IPs of nodes and not its own IP, we can not know real IP of
+				// source. So we'll take first returned address as source.
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
+			})
+	}
+}
+func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{},
+	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
+
+	dag, err := blockdag.New(&blockdag.Config{
+		Interrupt:       interrupt,
+		DatabaseContext: databaseContext,
+		DAGParams:       cfg.NetParams(),
+		TimeSource:      blockdag.NewTimeSource(),
+		SigCache:        sigCache,
+		IndexManager:    indexManager,
+		SubnetworkID:    cfg.SubnetworkID,
+	})
+	return dag, err
 }
 
-func removeDatabase(cfg *config.Config) error {
-	dbPath := databasePath(cfg)
-	return os.RemoveAll(dbPath)
+func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.AcceptanceIndex) {
+	// Create indexes if needed.
+	var indexes []indexers.Indexer
+	var acceptanceIndex *indexers.AcceptanceIndex
+	if cfg.AcceptanceIndex {
+		log.Info("acceptance index is enabled")
+		acceptanceIndex = indexers.NewAcceptanceIndex()
+		indexes = append(indexes, acceptanceIndex)
+	}
+
+	// Create an index manager if any of the optional indexes are enabled.
+	if len(indexes) < 0 {
+		return nil, nil
+	}
+	indexManager := indexers.NewManager(indexes)
+	return indexManager, acceptanceIndex
 }
 
-func openDB(cfg *config.Config) (database.Database, error) {
-	dbPath := databasePath(cfg)
-	log.Infof("Loading database from '%s'", dbPath)
-	return ldb.NewLevelDB(dbPath)
+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/appmessage/base_message.go

@@ -1,24 +0,0 @@
-package appmessage
-
-import "time"
-
-type baseMessage struct {
-	messageNumber uint64
-	receivedAt    time.Time
-}
-
-func (b *baseMessage) MessageNumber() uint64 {
-	return b.messageNumber
-}
-
-func (b *baseMessage) SetMessageNumber(messageNumber uint64) {
-	b.messageNumber = messageNumber
-}
-
-func (b *baseMessage) ReceivedAt() time.Time {
-	return b.receivedAt
-}
-
-func (b *baseMessage) SetReceivedAt(receivedAt time.Time) {
-	b.receivedAt = receivedAt
-}

app/appmessage/domainconverters.go

@@ -1,149 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-// DomainBlockToMsgBlock converts an externalapi.DomainBlock to MsgBlock
-func DomainBlockToMsgBlock(domainBlock *externalapi.DomainBlock) *MsgBlock {
-	msgTxs := make([]*MsgTx, 0, len(domainBlock.Transactions))
-	for _, domainTransaction := range domainBlock.Transactions {
-		msgTxs = append(msgTxs, DomainTransactionToMsgTx(domainTransaction))
-	}
-	return &MsgBlock{
-		Header:       *DomainBlockHeaderToBlockHeader(domainBlock.Header),
-		Transactions: msgTxs,
-	}
-}
-
-// DomainBlockHeaderToBlockHeader converts an externalapi.DomainBlockHeader to BlockHeader
-func DomainBlockHeaderToBlockHeader(domainBlockHeader *externalapi.DomainBlockHeader) *BlockHeader {
-	return &BlockHeader{
-		Version:              domainBlockHeader.Version,
-		ParentHashes:         domainBlockHeader.ParentHashes,
-		HashMerkleRoot:       &domainBlockHeader.HashMerkleRoot,
-		AcceptedIDMerkleRoot: &domainBlockHeader.AcceptedIDMerkleRoot,
-		UTXOCommitment:       &domainBlockHeader.UTXOCommitment,
-		Timestamp:            mstime.UnixMilliseconds(domainBlockHeader.TimeInMilliseconds),
-		Bits:                 domainBlockHeader.Bits,
-		Nonce:                domainBlockHeader.Nonce,
-	}
-}
-
-// MsgBlockToDomainBlock converts a MsgBlock to externalapi.DomainBlock
-func MsgBlockToDomainBlock(msgBlock *MsgBlock) *externalapi.DomainBlock {
-	transactions := make([]*externalapi.DomainTransaction, 0, len(msgBlock.Transactions))
-	for _, msgTx := range msgBlock.Transactions {
-		transactions = append(transactions, MsgTxToDomainTransaction(msgTx))
-	}
-
-	return &externalapi.DomainBlock{
-		Header:       BlockHeaderToDomainBlockHeader(&msgBlock.Header),
-		Transactions: transactions,
-	}
-}
-
-// BlockHeaderToDomainBlockHeader converts a BlockHeader to externalapi.DomainBlockHeader
-func BlockHeaderToDomainBlockHeader(blockHeader *BlockHeader) *externalapi.DomainBlockHeader {
-	return &externalapi.DomainBlockHeader{
-		Version:              blockHeader.Version,
-		ParentHashes:         blockHeader.ParentHashes,
-		HashMerkleRoot:       *blockHeader.HashMerkleRoot,
-		AcceptedIDMerkleRoot: *blockHeader.AcceptedIDMerkleRoot,
-		UTXOCommitment:       *blockHeader.UTXOCommitment,
-		TimeInMilliseconds:   blockHeader.Timestamp.UnixMilliseconds(),
-		Bits:                 blockHeader.Bits,
-		Nonce:                blockHeader.Nonce,
-	}
-}
-
-// DomainTransactionToMsgTx converts an externalapi.DomainTransaction into an MsgTx
-func DomainTransactionToMsgTx(domainTransaction *externalapi.DomainTransaction) *MsgTx {
-	txIns := make([]*TxIn, 0, len(domainTransaction.Inputs))
-	for _, input := range domainTransaction.Inputs {
-		txIns = append(txIns, domainTransactionInputToTxIn(input))
-	}
-
-	txOuts := make([]*TxOut, 0, len(domainTransaction.Outputs))
-	for _, output := range domainTransaction.Outputs {
-		txOuts = append(txOuts, domainTransactionOutputToTxOut(output))
-	}
-
-	return &MsgTx{
-		Version:      domainTransaction.Version,
-		TxIn:         txIns,
-		TxOut:        txOuts,
-		LockTime:     domainTransaction.LockTime,
-		SubnetworkID: domainTransaction.SubnetworkID,
-		Gas:          domainTransaction.Gas,
-		PayloadHash:  &domainTransaction.PayloadHash,
-		Payload:      domainTransaction.Payload,
-	}
-}
-
-func domainTransactionOutputToTxOut(domainTransactionOutput *externalapi.DomainTransactionOutput) *TxOut {
-	return &TxOut{
-		Value:        domainTransactionOutput.Value,
-		ScriptPubKey: domainTransactionOutput.ScriptPublicKey,
-	}
-}
-
-func domainTransactionInputToTxIn(domainTransactionInput *externalapi.DomainTransactionInput) *TxIn {
-	return &TxIn{
-		PreviousOutpoint: *domainOutpointToOutpoint(domainTransactionInput.PreviousOutpoint),
-		SignatureScript:  domainTransactionInput.SignatureScript,
-		Sequence:         domainTransactionInput.Sequence,
-	}
-}
-
-func domainOutpointToOutpoint(domainOutpoint externalapi.DomainOutpoint) *Outpoint {
-	return NewOutpoint(
-		&domainOutpoint.TransactionID,
-		domainOutpoint.Index)
-}
-
-// MsgTxToDomainTransaction converts an MsgTx into externalapi.DomainTransaction
-func MsgTxToDomainTransaction(msgTx *MsgTx) *externalapi.DomainTransaction {
-	transactionInputs := make([]*externalapi.DomainTransactionInput, 0, len(msgTx.TxIn))
-	for _, txIn := range msgTx.TxIn {
-		transactionInputs = append(transactionInputs, txInToDomainTransactionInput(txIn))
-	}
-
-	transactionOutputs := make([]*externalapi.DomainTransactionOutput, 0, len(msgTx.TxOut))
-	for _, txOut := range msgTx.TxOut {
-		transactionOutputs = append(transactionOutputs, txOutToDomainTransactionOutput(txOut))
-	}
-	return &externalapi.DomainTransaction{
-		Version:      msgTx.Version,
-		Inputs:       transactionInputs,
-		Outputs:      transactionOutputs,
-		LockTime:     msgTx.LockTime,
-		SubnetworkID: msgTx.SubnetworkID,
-		Gas:          msgTx.Gas,
-		PayloadHash:  *msgTx.PayloadHash,
-		Payload:      msgTx.Payload,
-	}
-}
-
-func txOutToDomainTransactionOutput(txOut *TxOut) *externalapi.DomainTransactionOutput {
-	return &externalapi.DomainTransactionOutput{
-		Value:           txOut.Value,
-		ScriptPublicKey: txOut.ScriptPubKey,
-	}
-}
-
-func txInToDomainTransactionInput(txIn *TxIn) *externalapi.DomainTransactionInput {
-	return &externalapi.DomainTransactionInput{
-		PreviousOutpoint: *outpointToDomainOutpoint(&txIn.PreviousOutpoint), //TODO
-		SignatureScript:  txIn.SignatureScript,
-		Sequence:         txIn.Sequence,
-	}
-}
-
-func outpointToDomainOutpoint(outpoint *Outpoint) *externalapi.DomainOutpoint {
-	return &externalapi.DomainOutpoint{
-		TransactionID: outpoint.TxID,
-		Index:         outpoint.Index,
-	}
-}

app/appmessage/message.go

@@ -1,195 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"fmt"
-	"time"
-)
-
-// MaxMessagePayload is the maximum bytes a message can be regardless of other
-// individual limits imposed by messages themselves.
-const MaxMessagePayload = 1024 * 1024 * 32 // 32MB
-
-// MessageCommand is a number in the header of a message that represents its type.
-type MessageCommand uint32
-
-func (cmd MessageCommand) String() string {
-	cmdString, ok := ProtocolMessageCommandToString[cmd]
-	if !ok {
-		cmdString, ok = RPCMessageCommandToString[cmd]
-	}
-	if !ok {
-		cmdString = "unknown command"
-	}
-	return fmt.Sprintf("%s [code %d]", cmdString, uint8(cmd))
-}
-
-// Commands used in kaspa message headers which describe the type of message.
-const (
-	// protocol
-	CmdVersion MessageCommand = iota
-	CmdVerAck
-	CmdRequestAddresses
-	CmdAddresses
-	CmdRequestIBDBlocks
-	CmdBlock
-	CmdTx
-	CmdPing
-	CmdPong
-	CmdRequestBlockLocator
-	CmdBlockLocator
-	CmdSelectedTip
-	CmdRequestSelectedTip
-	CmdInvRelayBlock
-	CmdRequestRelayBlocks
-	CmdInvTransaction
-	CmdRequestTransactions
-	CmdIBDBlock
-	CmdRequestNextIBDBlocks
-	CmdDoneIBDBlocks
-	CmdTransactionNotFound
-	CmdReject
-
-	// rpc
-	CmdGetCurrentNetworkRequestMessage
-	CmdGetCurrentNetworkResponseMessage
-	CmdSubmitBlockRequestMessage
-	CmdSubmitBlockResponseMessage
-	CmdGetBlockTemplateRequestMessage
-	CmdGetBlockTemplateResponseMessage
-	CmdGetBlockTemplateTransactionMessage
-	CmdNotifyBlockAddedRequestMessage
-	CmdNotifyBlockAddedResponseMessage
-	CmdBlockAddedNotificationMessage
-	CmdGetPeerAddressesRequestMessage
-	CmdGetPeerAddressesResponseMessage
-	CmdGetSelectedTipHashRequestMessage
-	CmdGetSelectedTipHashResponseMessage
-	CmdGetMempoolEntryRequestMessage
-	CmdGetMempoolEntryResponseMessage
-	CmdGetConnectedPeerInfoRequestMessage
-	CmdGetConnectedPeerInfoResponseMessage
-	CmdAddPeerRequestMessage
-	CmdAddPeerResponseMessage
-	CmdSubmitTransactionRequestMessage
-	CmdSubmitTransactionResponseMessage
-	CmdNotifyChainChangedRequestMessage
-	CmdNotifyChainChangedResponseMessage
-	CmdChainChangedNotificationMessage
-	CmdGetBlockRequestMessage
-	CmdGetBlockResponseMessage
-	CmdGetSubnetworkRequestMessage
-	CmdGetSubnetworkResponseMessage
-	CmdGetChainFromBlockRequestMessage
-	CmdGetChainFromBlockResponseMessage
-	CmdGetBlocksRequestMessage
-	CmdGetBlocksResponseMessage
-	CmdGetBlockCountRequestMessage
-	CmdGetBlockCountResponseMessage
-	CmdGetBlockDAGInfoRequestMessage
-	CmdGetBlockDAGInfoResponseMessage
-	CmdResolveFinalityConflictRequestMessage
-	CmdResolveFinalityConflictResponseMessage
-	CmdNotifyFinalityConflictsRequestMessage
-	CmdNotifyFinalityConflictsResponseMessage
-	CmdFinalityConflictNotificationMessage
-	CmdFinalityConflictResolvedNotificationMessage
-	CmdGetMempoolEntriesRequestMessage
-	CmdGetMempoolEntriesResponseMessage
-	CmdShutDownRequestMessage
-	CmdShutDownResponseMessage
-	CmdGetHeadersRequestMessage
-	CmdGetHeadersResponseMessage
-)
-
-// ProtocolMessageCommandToString maps all MessageCommands to their string representation
-var ProtocolMessageCommandToString = map[MessageCommand]string{
-	CmdVersion:              "Version",
-	CmdVerAck:               "VerAck",
-	CmdRequestAddresses:     "RequestAddresses",
-	CmdAddresses:            "Addresses",
-	CmdRequestIBDBlocks:     "RequestBlocks",
-	CmdBlock:                "Block",
-	CmdTx:                   "Tx",
-	CmdPing:                 "Ping",
-	CmdPong:                 "Pong",
-	CmdRequestBlockLocator:  "RequestBlockLocator",
-	CmdBlockLocator:         "BlockLocator",
-	CmdSelectedTip:          "SelectedTip",
-	CmdRequestSelectedTip:   "RequestSelectedTip",
-	CmdInvRelayBlock:        "InvRelayBlock",
-	CmdRequestRelayBlocks:   "RequestRelayBlocks",
-	CmdInvTransaction:       "InvTransaction",
-	CmdRequestTransactions:  "RequestTransactions",
-	CmdIBDBlock:             "IBDBlock",
-	CmdRequestNextIBDBlocks: "RequestNextIBDBlocks",
-	CmdDoneIBDBlocks:        "DoneIBDBlocks",
-	CmdTransactionNotFound:  "TransactionNotFound",
-	CmdReject:               "Reject",
-}
-
-// RPCMessageCommandToString maps all MessageCommands to their string representation
-var RPCMessageCommandToString = map[MessageCommand]string{
-	CmdGetCurrentNetworkRequestMessage:             "GetCurrentNetworkRequest",
-	CmdGetCurrentNetworkResponseMessage:            "GetCurrentNetworkResponse",
-	CmdSubmitBlockRequestMessage:                   "SubmitBlockRequest",
-	CmdSubmitBlockResponseMessage:                  "SubmitBlockResponse",
-	CmdGetBlockTemplateRequestMessage:              "GetBlockTemplateRequest",
-	CmdGetBlockTemplateResponseMessage:             "GetBlockTemplateResponse",
-	CmdGetBlockTemplateTransactionMessage:          "CmdGetBlockTemplateTransaction",
-	CmdNotifyBlockAddedRequestMessage:              "NotifyBlockAddedRequest",
-	CmdNotifyBlockAddedResponseMessage:             "NotifyBlockAddedResponse",
-	CmdBlockAddedNotificationMessage:               "BlockAddedNotification",
-	CmdGetPeerAddressesRequestMessage:              "GetPeerAddressesRequest",
-	CmdGetPeerAddressesResponseMessage:             "GetPeerAddressesResponse",
-	CmdGetSelectedTipHashRequestMessage:            "GetSelectedTipHashRequest",
-	CmdGetSelectedTipHashResponseMessage:           "GetSelectedTipHashResponse",
-	CmdGetMempoolEntryRequestMessage:               "GetMempoolEntryRequest",
-	CmdGetMempoolEntryResponseMessage:              "GetMempoolEntryResponse",
-	CmdGetConnectedPeerInfoRequestMessage:          "GetConnectedPeerInfoRequest",
-	CmdGetConnectedPeerInfoResponseMessage:         "GetConnectedPeerInfoResponse",
-	CmdAddPeerRequestMessage:                       "AddPeerRequest",
-	CmdAddPeerResponseMessage:                      "AddPeerResponse",
-	CmdSubmitTransactionRequestMessage:             "SubmitTransactionRequest",
-	CmdSubmitTransactionResponseMessage:            "SubmitTransactionResponse",
-	CmdNotifyChainChangedRequestMessage:            "NotifyChainChangedRequest",
-	CmdNotifyChainChangedResponseMessage:           "NotifyChainChangedResponse",
-	CmdChainChangedNotificationMessage:             "ChainChangedNotification",
-	CmdGetBlockRequestMessage:                      "GetBlockRequest",
-	CmdGetBlockResponseMessage:                     "GetBlockResponse",
-	CmdGetSubnetworkRequestMessage:                 "GetSubnetworkRequest",
-	CmdGetSubnetworkResponseMessage:                "GetSubnetworkResponse",
-	CmdGetChainFromBlockRequestMessage:             "GetChainFromBlockRequest",
-	CmdGetChainFromBlockResponseMessage:            "GetChainFromBlockResponse",
-	CmdGetBlocksRequestMessage:                     "GetBlocksRequest",
-	CmdGetBlocksResponseMessage:                    "GetBlocksResponse",
-	CmdGetBlockCountRequestMessage:                 "GetBlockCountRequest",
-	CmdGetBlockCountResponseMessage:                "GetBlockCountResponse",
-	CmdGetBlockDAGInfoRequestMessage:               "GetBlockDAGInfoRequest",
-	CmdGetBlockDAGInfoResponseMessage:              "GetBlockDAGInfoResponse",
-	CmdResolveFinalityConflictRequestMessage:       "ResolveFinalityConflictRequest",
-	CmdResolveFinalityConflictResponseMessage:      "ResolveFinalityConflictResponse",
-	CmdNotifyFinalityConflictsRequestMessage:       "NotifyFinalityConflictsRequest",
-	CmdNotifyFinalityConflictsResponseMessage:      "NotifyFinalityConflictsResponse",
-	CmdFinalityConflictNotificationMessage:         "FinalityConflictNotification",
-	CmdFinalityConflictResolvedNotificationMessage: "FinalityConflictResolvedNotification",
-	CmdGetMempoolEntriesRequestMessage:             "GetMempoolEntriesRequestMessage",
-	CmdGetMempoolEntriesResponseMessage:            "GetMempoolEntriesResponseMessage",
-	CmdGetHeadersRequestMessage:                    "GetHeadersRequest",
-	CmdGetHeadersResponseMessage:                   "GetHeadersResponse",
-}
-
-// Message is an interface that describes a kaspa message. A type that
-// implements Message has complete control over the representation of its data
-// and may therefore contain additional or fewer fields than those which
-// are used directly in the protocol encoded message.
-type Message interface {
-	Command() MessageCommand
-	MessageNumber() uint64
-	SetMessageNumber(index uint64)
-	ReceivedAt() time.Time
-	SetReceivedAt(receivedAt time.Time)
-}

app/appmessage/p2p_blockheader.go

@@ -1,100 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"math"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/pkg/errors"
-)
-
-// BaseBlockHeaderPayload is the base number of bytes a block header can be,
-// not including the list of parent block headers.
-// Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes +
-// + NumParentBlocks 1 byte + HashMerkleRoot hash +
-// + AcceptedIDMerkleRoot hash + UTXOCommitment hash.
-// To get total size of block header len(ParentHashes) * externalapi.DomainHashSize should be
-// added to this value
-const BaseBlockHeaderPayload = 25 + 3*(externalapi.DomainHashSize)
-
-// MaxNumParentBlocks is the maximum number of parent blocks a block can reference.
-// Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte
-const MaxNumParentBlocks = 255
-
-// MaxBlockHeaderPayload is the maximum number of bytes a block header can be.
-// BaseBlockHeaderPayload + up to MaxNumParentBlocks hashes of parent blocks
-const MaxBlockHeaderPayload = BaseBlockHeaderPayload + (MaxNumParentBlocks * externalapi.DomainHashSize)
-
-// BlockHeader defines information about a block and is used in the kaspa
-// block (MsgBlock) and headers (MsgHeader) messages.
-type BlockHeader struct {
-	// Version of the block. This is not the same as the protocol version.
-	Version int32
-
-	// Hashes of the parent block headers in the blockDAG.
-	ParentHashes []*externalapi.DomainHash
-
-	// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
-	HashMerkleRoot *externalapi.DomainHash
-
-	// AcceptedIDMerkleRoot is merkle tree reference to hash all transactions
-	// accepted form the block.Blues
-	AcceptedIDMerkleRoot *externalapi.DomainHash
-
-	// UTXOCommitment is an ECMH UTXO commitment to the block UTXO.
-	UTXOCommitment *externalapi.DomainHash
-
-	// Time the block was created.
-	Timestamp mstime.Time
-
-	// Difficulty target for the block.
-	Bits uint32
-
-	// Nonce used to generate the block.
-	Nonce uint64
-}
-
-// NumParentBlocks return the number of entries in ParentHashes
-func (h *BlockHeader) NumParentBlocks() byte {
-	numParents := len(h.ParentHashes)
-	if numParents > math.MaxUint8 {
-		panic(errors.Errorf("number of parents is %d, which is more than one byte can fit", numParents))
-	}
-	return byte(numParents)
-}
-
-// BlockHash computes the block identifier hash for the given block header.
-func (h *BlockHeader) BlockHash() *externalapi.DomainHash {
-	return consensusserialization.HeaderHash(BlockHeaderToDomainBlockHeader(h))
-}
-
-// IsGenesis returns true iff this block is a genesis block
-func (h *BlockHeader) IsGenesis() bool {
-	return h.NumParentBlocks() == 0
-}
-
-// NewBlockHeader returns a new BlockHeader using the provided version, previous
-// block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
-// block with defaults or calclulated values for the remaining fields.
-func NewBlockHeader(version int32, parentHashes []*externalapi.DomainHash, hashMerkleRoot *externalapi.DomainHash,
-	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce uint64) *BlockHeader {
-
-	// Limit the timestamp to one millisecond precision since the protocol
-	// doesn't support better.
-	return &BlockHeader{
-		Version:              version,
-		ParentHashes:         parentHashes,
-		HashMerkleRoot:       hashMerkleRoot,
-		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
-		UTXOCommitment:       utxoCommitment,
-		Timestamp:            mstime.Now(),
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-}

app/appmessage/p2p_blockheader_test.go

@@ -1,88 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/random"
-)
-
-// TestBlockHeader tests the BlockHeader API.
-func TestBlockHeader(t *testing.T) {
-	nonce, err := random.Uint64()
-	if err != nil {
-		t.Errorf("random.Uint64: Error generating nonce: %v", err)
-	}
-
-	hashes := []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash}
-
-	merkleHash := mainnetGenesisMerkleRoot
-	acceptedIDMerkleRoot := exampleAcceptedIDMerkleRoot
-	bits := uint32(0x1d00ffff)
-	bh := NewBlockHeader(1, hashes, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)
-
-	// Ensure we get the same data back out.
-	if !reflect.DeepEqual(bh.ParentHashes, hashes) {
-		t.Errorf("NewBlockHeader: wrong prev hashes - got %v, want %v",
-			spew.Sprint(bh.ParentHashes), spew.Sprint(hashes))
-	}
-	if bh.HashMerkleRoot != merkleHash {
-		t.Errorf("NewBlockHeader: wrong merkle root - got %v, want %v",
-			spew.Sprint(bh.HashMerkleRoot), spew.Sprint(merkleHash))
-	}
-	if bh.Bits != bits {
-		t.Errorf("NewBlockHeader: wrong bits - got %v, want %v",
-			bh.Bits, bits)
-	}
-	if bh.Nonce != nonce {
-		t.Errorf("NewBlockHeader: wrong nonce - got %v, want %v",
-			bh.Nonce, nonce)
-	}
-}
-
-func TestIsGenesis(t *testing.T) {
-	nonce := uint64(123123) // 0x1e0f3
-	bits := uint32(0x1d00ffff)
-	timestamp := mstime.UnixMilliseconds(0x495fab29000)
-
-	baseBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot: mainnetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
-	}
-	genesisBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*externalapi.DomainHash{},
-		HashMerkleRoot: mainnetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
-	}
-
-	tests := []struct {
-		in        *BlockHeader // Block header to encode
-		isGenesis bool         // Expected result for call of .IsGenesis
-	}{
-		{genesisBlockHdr, true},
-		{baseBlockHdr, false},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		isGenesis := test.in.IsGenesis()
-		if isGenesis != test.isGenesis {
-			t.Errorf("BlockHeader.IsGenesis: #%d got: %t, want: %t",
-				i, isGenesis, test.isGenesis)
-		}
-	}
-}

app/appmessage/p2p_msgblock.go

@@ -1,87 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// defaultTransactionAlloc is the default size used for the backing array
-// for transactions. The transaction array will dynamically grow as needed, but
-// this figure is intended to provide enough space for the number of
-// transactions in the vast majority of blocks without needing to grow the
-// backing array multiple times.
-const defaultTransactionAlloc = 2048
-
-// MaxMassAcceptedByBlock is the maximum total transaction mass a block may accept.
-const MaxMassAcceptedByBlock = 10000000
-
-// MaxMassPerTx is the maximum total mass a transaction may have.
-const MaxMassPerTx = MaxMassAcceptedByBlock / 2
-
-// MaxTxPerBlock is the maximum number of transactions that could
-// possibly fit into a block.
-const MaxTxPerBlock = (MaxMassAcceptedByBlock / minTxPayload) + 1
-
-// MaxBlockParents is the maximum allowed number of parents for block.
-const MaxBlockParents = 10
-
-// TxLoc holds locator data for the offset and length of where a transaction is
-// located within a MsgBlock data buffer.
-type TxLoc struct {
-	TxStart int
-	TxLen   int
-}
-
-// MsgBlock implements the Message interface and represents a kaspa
-// block message. It is used to deliver block and transaction information in
-// response to a getdata message (MsgGetData) for a given block hash.
-type MsgBlock struct {
-	baseMessage
-	Header       BlockHeader
-	Transactions []*MsgTx
-}
-
-// AddTransaction adds a transaction to the message.
-func (msg *MsgBlock) AddTransaction(tx *MsgTx) {
-	msg.Transactions = append(msg.Transactions, tx)
-}
-
-// ClearTransactions removes all transactions from the message.
-func (msg *MsgBlock) ClearTransactions() {
-	msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgBlock) Command() MessageCommand {
-	return CmdBlock
-}
-
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
-	return MaxMessagePayload
-}
-
-// ConvertToPartial clears out all the payloads of the subnetworks that are
-// incompatible with the given subnetwork ID.
-// Note: this operation modifies the block in place.
-func (msg *MsgBlock) ConvertToPartial(subnetworkID *externalapi.DomainSubnetworkID) {
-	for _, tx := range msg.Transactions {
-		if tx.SubnetworkID != *subnetworkID {
-			tx.Payload = []byte{}
-		}
-	}
-}
-
-// NewMsgBlock returns a new kaspa block message that conforms to the
-// Message interface. See MsgBlock for details.
-func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
-	return &MsgBlock{
-		Header:       *blockHeader,
-		Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),
-	}
-}

app/appmessage/p2p_msgblock_test.go

@@ -1,238 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"math"
-	"reflect"
-	"testing"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-// TestBlock tests the MsgBlock API.
-func TestBlock(t *testing.T) {
-	pver := ProtocolVersion
-
-	// Block 1 header.
-	parentHashes := blockOne.Header.ParentHashes
-	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
-	utxoCommitment := blockOne.Header.UTXOCommitment
-	bits := blockOne.Header.Bits
-	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(5)
-	msg := NewMsgBlock(bh)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgBlock: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure max payload is expected value for latest protocol version.
-	wantPayload := uint32(1024 * 1024 * 32)
-	maxPayload := msg.MaxPayloadLength(pver)
-	if maxPayload != wantPayload {
-		t.Errorf("MaxPayloadLength: wrong max payload length for "+
-			"protocol version %d - got %v, want %v", pver,
-			maxPayload, wantPayload)
-	}
-
-	// Ensure we get the same block header data back out.
-	if !reflect.DeepEqual(&msg.Header, bh) {
-		t.Errorf("NewMsgBlock: wrong block header - got %v, want %v",
-			spew.Sdump(&msg.Header), spew.Sdump(bh))
-	}
-
-	// Ensure transactions are added properly.
-	tx := blockOne.Transactions[0].Copy()
-	msg.AddTransaction(tx)
-	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
-		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
-			spew.Sdump(msg.Transactions),
-			spew.Sdump(blockOne.Transactions))
-	}
-
-	// Ensure transactions are properly cleared.
-	msg.ClearTransactions()
-	if len(msg.Transactions) != 0 {
-		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
-			len(msg.Transactions), 0)
-	}
-}
-
-func TestConvertToPartial(t *testing.T) {
-	localSubnetworkID := &externalapi.DomainSubnetworkID{0x12}
-
-	transactions := []struct {
-		subnetworkID          *externalapi.DomainSubnetworkID
-		payload               []byte
-		expectedPayloadLength int
-	}{
-		{
-			subnetworkID:          &subnetworks.SubnetworkIDNative,
-			payload:               []byte{},
-			expectedPayloadLength: 0,
-		},
-		{
-			subnetworkID:          &subnetworks.SubnetworkIDRegistry,
-			payload:               []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
-			expectedPayloadLength: 0,
-		},
-		{
-			subnetworkID:          localSubnetworkID,
-			payload:               []byte{0x01},
-			expectedPayloadLength: 1,
-		},
-		{
-			subnetworkID:          &externalapi.DomainSubnetworkID{0x34},
-			payload:               []byte{0x02},
-			expectedPayloadLength: 0,
-		},
-	}
-
-	block := MsgBlock{}
-	payload := []byte{1}
-	for _, transaction := range transactions {
-		block.Transactions = append(block.Transactions, NewSubnetworkMsgTx(1, nil, nil, transaction.subnetworkID, 0, payload))
-	}
-
-	block.ConvertToPartial(localSubnetworkID)
-
-	for _, testTransaction := range transactions {
-		var subnetworkTx *MsgTx
-		for _, blockTransaction := range block.Transactions {
-			if blockTransaction.SubnetworkID == *testTransaction.subnetworkID {
-				subnetworkTx = blockTransaction
-			}
-		}
-		if subnetworkTx == nil {
-			t.Errorf("ConvertToPartial: subnetworkID '%s' not found in block!", testTransaction.subnetworkID)
-			continue
-		}
-
-		payloadLength := len(subnetworkTx.Payload)
-		if payloadLength != testTransaction.expectedPayloadLength {
-			t.Errorf("ConvertToPartial: unexpected payload length for subnetwork '%s': expected: %d, got: %d",
-				testTransaction.subnetworkID, testTransaction.expectedPayloadLength, payloadLength)
-		}
-	}
-}
-
-// blockOne is the first block in the mainnet block DAG.
-var blockOne = MsgBlock{
-	Header: BlockHeader{
-		Version:              1,
-		ParentHashes:         []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot:       mainnetGenesisMerkleRoot,
-		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
-		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
-		Bits:                 0x1d00ffff, // 486604799
-		Nonce:                0x9962e301, // 2573394689
-	},
-	Transactions: []*MsgTx{
-		NewNativeMsgTx(1,
-			[]*TxIn{
-				{
-					PreviousOutpoint: Outpoint{
-						TxID:  externalapi.DomainTransactionID{},
-						Index: 0xffffffff,
-					},
-					SignatureScript: []byte{
-						0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04,
-					},
-					Sequence: math.MaxUint64,
-				},
-			},
-			[]*TxOut{
-				{
-					Value: 0x12a05f200,
-					ScriptPubKey: []byte{
-						0x41, // OP_DATA_65
-						0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
-						0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
-						0x00, 0xae, 0x13, 0x90, 0x81, 0x3a, 0x62, 0x7c,
-						0x66, 0xfb, 0x8b, 0xe7, 0x94, 0x7b, 0xe6, 0x3c,
-						0x52, 0xda, 0x75, 0x89, 0x37, 0x95, 0x15, 0xd4,
-						0xe0, 0xa6, 0x04, 0xf8, 0x14, 0x17, 0x81, 0xe6,
-						0x22, 0x94, 0x72, 0x11, 0x66, 0xbf, 0x62, 0x1e,
-						0x73, 0xa8, 0x2c, 0xbf, 0x23, 0x42, 0xc8, 0x58,
-						0xee, // 65-byte signature
-						0xac, // OP_CHECKSIG
-					},
-				},
-			}),
-	},
-}
-
-// Block one serialized bytes.
-var blockOneBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, // Version 1
-	0x02,                                           // NumParentBlocks
-	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
-	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
-	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
-	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
-	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simnetGenesisHash
-	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
-	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
-	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // HashMerkleRoot
-	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
-	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
-	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
-	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // UTXOCommitment
-	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
-	0xff, 0xff, 0x00, 0x1d, // Bits
-	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
-	0x01,                   // TxnCount
-	0x01, 0x00, 0x00, 0x00, // Version
-	0x01, // Varint for number of transaction inputs
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Previous output hash
-	0xff, 0xff, 0xff, 0xff, // Prevous output index
-	0x07,                                     // Varint for length of signature script
-	0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, // Signature script (coinbase)
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
-	0x01,                                           // Varint for number of transaction outputs
-	0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of scriptPubKey
-	0x41, // OP_DATA_65
-	0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
-	0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
-	0x00, 0xae, 0x13, 0x90, 0x81, 0x3a, 0x62, 0x7c,
-	0x66, 0xfb, 0x8b, 0xe7, 0x94, 0x7b, 0xe6, 0x3c,
-	0x52, 0xda, 0x75, 0x89, 0x37, 0x95, 0x15, 0xd4,
-	0xe0, 0xa6, 0x04, 0xf8, 0x14, 0x17, 0x81, 0xe6,
-	0x22, 0x94, 0x72, 0x11, 0x66, 0xbf, 0x62, 0x1e,
-	0x73, 0xa8, 0x2c, 0xbf, 0x23, 0x42, 0xc8, 0x58,
-	0xee,                                           // 65-byte uncompressed public key
-	0xac,                                           // OP_CHECKSIG
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, // SubnetworkID
-}
-
-// Transaction location information for block one transactions.
-var blockOneTxLocs = []TxLoc{
-	{TxStart: 186, TxLen: 162},
-}

app/appmessage/p2p_msgreject.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgReject implements the Message interface and represents a kaspa
-// Reject message. It is used to notify peers why they are banned.
-type MsgReject struct {
-	baseMessage
-	Reason string
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgReject) Command() MessageCommand {
-	return CmdReject
-}
-
-// NewMsgReject returns a new kaspa Reject message that conforms to the
-// Message interface.
-func NewMsgReject(reason string) *MsgReject {
-	return &MsgReject{
-		Reason: reason,
-	}
-}

app/appmessage/p2p_msgtx.go

@@ -1,355 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"encoding/binary"
-	"math"
-	"strconv"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-const (
-	// TxVersion is the current latest supported transaction version.
-	TxVersion = 1
-
-	// MaxTxInSequenceNum is the maximum sequence number the sequence field
-	// of a transaction input can be.
-	MaxTxInSequenceNum uint64 = math.MaxUint64
-
-	// MaxPrevOutIndex is the maximum index the index field of a previous
-	// outpoint can be.
-	MaxPrevOutIndex uint32 = 0xffffffff
-
-	// SequenceLockTimeDisabled is a flag that if set on a transaction
-	// input's sequence number, the sequence number will not be interpreted
-	// as a relative locktime.
-	SequenceLockTimeDisabled = 1 << 31
-
-	// SequenceLockTimeIsSeconds is a flag that if set on a transaction
-	// input's sequence number, the relative locktime has units of 512
-	// seconds.
-	SequenceLockTimeIsSeconds = 1 << 22
-
-	// SequenceLockTimeMask is a mask that extracts the relative locktime
-	// when masked against the transaction input sequence number.
-	SequenceLockTimeMask = 0x0000ffff
-
-	// SequenceLockTimeGranularity is the defined time based granularity
-	// for milliseconds-based relative time locks. When converting from milliseconds
-	// to a sequence number, the value is right shifted by this amount,
-	// therefore the granularity of relative time locks in 524288 or 2^19
-	// seconds. Enforced relative lock times are multiples of 524288 milliseconds.
-	SequenceLockTimeGranularity = 19
-
-	// defaultTxInOutAlloc is the default size used for the backing array for
-	// transaction inputs and outputs. The array will dynamically grow as needed,
-	// but this figure is intended to provide enough space for the number of
-	// inputs and outputs in a typical transaction without needing to grow the
-	// backing array multiple times.
-	defaultTxInOutAlloc = 15
-
-	// minTxInPayload is the minimum payload size for a transaction input.
-	// PreviousOutpoint.TxID + PreviousOutpoint.Index 4 bytes + Varint for
-	// SignatureScript length 1 byte + Sequence 4 bytes.
-	minTxInPayload = 9 + externalapi.DomainHashSize
-
-	// maxTxInPerMessage is the maximum number of transactions inputs that
-	// a transaction which fits into a message could possibly have.
-	maxTxInPerMessage = (MaxMessagePayload / minTxInPayload) + 1
-
-	// MinTxOutPayload is the minimum payload size for a transaction output.
-	// Value 8 bytes + Varint for ScriptPubKey length 1 byte.
-	MinTxOutPayload = 9
-
-	// maxTxOutPerMessage is the maximum number of transactions outputs that
-	// a transaction which fits into a message could possibly have.
-	maxTxOutPerMessage = (MaxMessagePayload / MinTxOutPayload) + 1
-
-	// minTxPayload is the minimum payload size for a transaction. Note
-	// that any realistically usable transaction must have at least one
-	// input or output, but that is a rule enforced at a higher layer, so
-	// it is intentionally not included here.
-	// Version 4 bytes + Varint number of transaction inputs 1 byte + Varint
-	// number of transaction outputs 1 byte + LockTime 4 bytes + min input
-	// payload + min output payload.
-	minTxPayload = 10
-)
-
-// Outpoint defines a kaspa data type that is used to track previous
-// transaction outputs.
-type Outpoint struct {
-	TxID  externalapi.DomainTransactionID
-	Index uint32
-}
-
-// NewOutpoint returns a new kaspa transaction outpoint point with the
-// provided hash and index.
-func NewOutpoint(txID *externalapi.DomainTransactionID, index uint32) *Outpoint {
-	return &Outpoint{
-		TxID:  *txID,
-		Index: index,
-	}
-}
-
-// String returns the Outpoint in the human-readable form "txID:index".
-func (o Outpoint) String() string {
-	// Allocate enough for ID string, colon, and 10 digits. Although
-	// at the time of writing, the number of digits can be no greater than
-	// the length of the decimal representation of maxTxOutPerMessage, the
-	// maximum message payload may increase in the future and this
-	// optimization may go unnoticed, so allocate space for 10 decimal
-	// digits, which will fit any uint32.
-	buf := make([]byte, 2*externalapi.DomainHashSize+1, 2*externalapi.DomainHashSize+1+10)
-	copy(buf, o.TxID.String())
-	buf[2*externalapi.DomainHashSize] = ':'
-	buf = strconv.AppendUint(buf, uint64(o.Index), 10)
-	return string(buf)
-}
-
-// TxIn defines a kaspa transaction input.
-type TxIn struct {
-	PreviousOutpoint Outpoint
-	SignatureScript  []byte
-	Sequence         uint64
-}
-
-// NewTxIn returns a new kaspa transaction input with the provided
-// previous outpoint point and signature script with a default sequence of
-// MaxTxInSequenceNum.
-func NewTxIn(prevOut *Outpoint, signatureScript []byte) *TxIn {
-	return &TxIn{
-		PreviousOutpoint: *prevOut,
-		SignatureScript:  signatureScript,
-		Sequence:         MaxTxInSequenceNum,
-	}
-}
-
-// TxOut defines a kaspa transaction output.
-type TxOut struct {
-	Value        uint64
-	ScriptPubKey []byte
-}
-
-// NewTxOut returns a new kaspa transaction output with the provided
-// transaction value and public key script.
-func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
-	return &TxOut{
-		Value:        value,
-		ScriptPubKey: scriptPubKey,
-	}
-}
-
-// MsgTx implements the Message interface and represents a kaspa tx message.
-// It is used to deliver transaction information in response to a getdata
-// message (MsgGetData) for a given transaction.
-//
-// Use the AddTxIn and AddTxOut functions to build up the list of transaction
-// inputs and outputs.
-type MsgTx struct {
-	baseMessage
-	Version      int32
-	TxIn         []*TxIn
-	TxOut        []*TxOut
-	LockTime     uint64
-	SubnetworkID externalapi.DomainSubnetworkID
-	Gas          uint64
-	PayloadHash  *externalapi.DomainHash
-	Payload      []byte
-}
-
-// AddTxIn adds a transaction input to the message.
-func (msg *MsgTx) AddTxIn(ti *TxIn) {
-	msg.TxIn = append(msg.TxIn, ti)
-}
-
-// AddTxOut adds a transaction output to the message.
-func (msg *MsgTx) AddTxOut(to *TxOut) {
-	msg.TxOut = append(msg.TxOut, to)
-}
-
-// IsCoinBase determines whether or not a transaction is a coinbase transaction. A coinbase
-// transaction is a special transaction created by miners that distributes fees and block subsidy
-// to the previous blocks' miners, and to specify the scriptPubKey that will be used to pay the current
-// miner in future blocks. Each input of the coinbase transaction should set index to maximum
-// value and reference the relevant block id, instead of previous transaction id.
-func (msg *MsgTx) IsCoinBase() bool {
-	// A coinbase transaction must have subnetwork id SubnetworkIDCoinbase
-	return msg.SubnetworkID == subnetworks.SubnetworkIDCoinbase
-}
-
-// TxHash generates the Hash for the transaction.
-func (msg *MsgTx) TxHash() *externalapi.DomainHash {
-	return consensusserialization.TransactionHash(MsgTxToDomainTransaction(msg))
-}
-
-// TxID generates the Hash for the transaction without the signature script, gas and payload fields.
-func (msg *MsgTx) TxID() *externalapi.DomainTransactionID {
-	return consensusserialization.TransactionID(MsgTxToDomainTransaction(msg))
-}
-
-// Copy creates a deep copy of a transaction so that the original does not get
-// modified when the copy is manipulated.
-func (msg *MsgTx) Copy() *MsgTx {
-	// Create new tx and start by copying primitive values and making space
-	// for the transaction inputs and outputs.
-	newTx := MsgTx{
-		Version:      msg.Version,
-		TxIn:         make([]*TxIn, 0, len(msg.TxIn)),
-		TxOut:        make([]*TxOut, 0, len(msg.TxOut)),
-		LockTime:     msg.LockTime,
-		SubnetworkID: msg.SubnetworkID,
-		Gas:          msg.Gas,
-		PayloadHash:  msg.PayloadHash,
-	}
-
-	if msg.Payload != nil {
-		newTx.Payload = make([]byte, len(msg.Payload))
-		copy(newTx.Payload, msg.Payload)
-	}
-
-	// Deep copy the old TxIn data.
-	for _, oldTxIn := range msg.TxIn {
-		// Deep copy the old previous outpoint.
-		oldOutpoint := oldTxIn.PreviousOutpoint
-		newOutpoint := Outpoint{}
-		newOutpoint.TxID = oldOutpoint.TxID
-		newOutpoint.Index = oldOutpoint.Index
-
-		// Deep copy the old signature script.
-		var newScript []byte
-		oldScript := oldTxIn.SignatureScript
-		oldScriptLen := len(oldScript)
-		if oldScriptLen > 0 {
-			newScript = make([]byte, oldScriptLen)
-			copy(newScript, oldScript[:oldScriptLen])
-		}
-
-		// Create new txIn with the deep copied data.
-		newTxIn := TxIn{
-			PreviousOutpoint: newOutpoint,
-			SignatureScript:  newScript,
-			Sequence:         oldTxIn.Sequence,
-		}
-
-		// Finally, append this fully copied txin.
-		newTx.TxIn = append(newTx.TxIn, &newTxIn)
-	}
-
-	// Deep copy the old TxOut data.
-	for _, oldTxOut := range msg.TxOut {
-		// Deep copy the old ScriptPubKey
-		var newScript []byte
-		oldScript := oldTxOut.ScriptPubKey
-		oldScriptLen := len(oldScript)
-		if oldScriptLen > 0 {
-			newScript = make([]byte, oldScriptLen)
-			copy(newScript, oldScript[:oldScriptLen])
-		}
-
-		// Create new txOut with the deep copied data and append it to
-		// new Tx.
-		newTxOut := TxOut{
-			Value:        oldTxOut.Value,
-			ScriptPubKey: newScript,
-		}
-		newTx.TxOut = append(newTx.TxOut, &newTxOut)
-	}
-
-	return &newTx
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgTx) Command() MessageCommand {
-	return CmdTx
-}
-
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
-	return MaxMessagePayload
-}
-
-// IsSubnetworkCompatible return true iff subnetworkID is one or more of the following:
-// 1. The SupportsAll subnetwork (full node)
-// 2. The native subnetwork
-// 3. The transaction's subnetwork
-func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *externalapi.DomainSubnetworkID) bool {
-	return subnetworkID == nil ||
-		*subnetworkID == subnetworks.SubnetworkIDNative ||
-		*subnetworkID == msg.SubnetworkID
-}
-
-// newMsgTx returns a new tx message that conforms to the Message interface.
-//
-// All fields except version and gas has default values if nil is passed:
-// txIn, txOut - empty arrays
-// payload - an empty payload
-//
-// The payload hash is calculated automatically according to provided payload.
-// Also, the lock time is set to zero to indicate the transaction is valid
-// immediately as opposed to some time in future.
-func newMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
-	gas uint64, payload []byte, lockTime uint64) *MsgTx {
-
-	if txIn == nil {
-		txIn = make([]*TxIn, 0, defaultTxInOutAlloc)
-	}
-
-	if txOut == nil {
-		txOut = make([]*TxOut, 0, defaultTxInOutAlloc)
-	}
-
-	var payloadHash *externalapi.DomainHash
-	if *subnetworkID != subnetworks.SubnetworkIDNative {
-		payloadHash = hashes.HashData(payload)
-	}
-
-	return &MsgTx{
-		Version:      version,
-		TxIn:         txIn,
-		TxOut:        txOut,
-		SubnetworkID: *subnetworkID,
-		Gas:          gas,
-		PayloadHash:  payloadHash,
-		Payload:      payload,
-		LockTime:     lockTime,
-	}
-}
-
-// NewNativeMsgTx returns a new tx message in the native subnetwork
-func NewNativeMsgTx(version int32, txIn []*TxIn, txOut []*TxOut) *MsgTx {
-	return newMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDNative, 0, nil, 0)
-}
-
-// NewSubnetworkMsgTx returns a new tx message in the specified subnetwork with specified gas and payload
-func NewSubnetworkMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
-	gas uint64, payload []byte) *MsgTx {
-
-	return newMsgTx(version, txIn, txOut, subnetworkID, gas, payload, 0)
-}
-
-// NewNativeMsgTxWithLocktime returns a new tx message in the native subnetwork with a locktime.
-//
-// See newMsgTx for further documntation of the parameters
-func NewNativeMsgTxWithLocktime(version int32, txIn []*TxIn, txOut []*TxOut, locktime uint64) *MsgTx {
-	return newMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDNative, 0, nil, locktime)
-}
-
-// NewRegistryMsgTx creates a new MsgTx that registers a new subnetwork
-func NewRegistryMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, gasLimit uint64) *MsgTx {
-	payload := make([]byte, 8)
-	binary.LittleEndian.PutUint64(payload, gasLimit)
-
-	return NewSubnetworkMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDRegistry, 0, payload)
-}

app/appmessage/p2p_msgtx_test.go

@@ -1,255 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"bytes"
-	"fmt"
-	"math"
-	"reflect"
-	"testing"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// TestTx tests the MsgTx API.
-func TestTx(t *testing.T) {
-	pver := ProtocolVersion
-
-	txIDStr := "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	txID, err := transactionid.FromString(txIDStr)
-	if err != nil {
-		t.Errorf("NewTxIDFromStr: %v", err)
-	}
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(6)
-	msg := NewNativeMsgTx(1, nil, nil)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure max payload is expected value for latest protocol version.
-	wantPayload := uint32(1024 * 1024 * 32)
-	maxPayload := msg.MaxPayloadLength(pver)
-	if maxPayload != wantPayload {
-		t.Errorf("MaxPayloadLength: wrong max payload length for "+
-			"protocol version %d - got %v, want %v", pver,
-			maxPayload, wantPayload)
-	}
-
-	// Ensure we get the same transaction outpoint data back out.
-	// NOTE: This is a block hash and made up index, but we're only
-	// testing package functionality.
-	prevOutIndex := uint32(1)
-	prevOut := NewOutpoint(txID, prevOutIndex)
-	if prevOut.TxID != *txID {
-		t.Errorf("NewOutpoint: wrong ID - got %v, want %v",
-			spew.Sprint(&prevOut.TxID), spew.Sprint(txID))
-	}
-	if prevOut.Index != prevOutIndex {
-		t.Errorf("NewOutpoint: wrong index - got %v, want %v",
-			prevOut.Index, prevOutIndex)
-	}
-	prevOutStr := fmt.Sprintf("%s:%d", txID.String(), prevOutIndex)
-	if s := prevOut.String(); s != prevOutStr {
-		t.Errorf("Outpoint.String: unexpected result - got %v, "+
-			"want %v", s, prevOutStr)
-	}
-
-	// Ensure we get the same transaction input back out.
-	sigScript := []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}
-	txIn := NewTxIn(prevOut, sigScript)
-	if !reflect.DeepEqual(&txIn.PreviousOutpoint, prevOut) {
-		t.Errorf("NewTxIn: wrong prev outpoint - got %v, want %v",
-			spew.Sprint(&txIn.PreviousOutpoint),
-			spew.Sprint(prevOut))
-	}
-	if !bytes.Equal(txIn.SignatureScript, sigScript) {
-		t.Errorf("NewTxIn: wrong signature script - got %v, want %v",
-			spew.Sdump(txIn.SignatureScript),
-			spew.Sdump(sigScript))
-	}
-
-	// Ensure we get the same transaction output back out.
-	txValue := uint64(5000000000)
-	scriptPubKey := []byte{
-		0x41, // OP_DATA_65
-		0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
-		0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
-		0x81, 0xbe, 0x98, 0x8e, 0x2d, 0xa0, 0xb6, 0xc1,
-		0xc6, 0xa5, 0x9d, 0xc2, 0x26, 0xc2, 0x86, 0x24,
-		0xe1, 0x81, 0x75, 0xe8, 0x51, 0xc9, 0x6b, 0x97,
-		0x3d, 0x81, 0xb0, 0x1c, 0xc3, 0x1f, 0x04, 0x78,
-		0x34, 0xbc, 0x06, 0xd6, 0xd6, 0xed, 0xf6, 0x20,
-		0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
-		0xa6, // 65-byte signature
-		0xac, // OP_CHECKSIG
-	}
-	txOut := NewTxOut(txValue, scriptPubKey)
-	if txOut.Value != txValue {
-		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
-			txOut.Value, txValue)
-
-	}
-	if !bytes.Equal(txOut.ScriptPubKey, scriptPubKey) {
-		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
-			spew.Sdump(txOut.ScriptPubKey),
-			spew.Sdump(scriptPubKey))
-	}
-
-	// Ensure transaction inputs are added properly.
-	msg.AddTxIn(txIn)
-	if !reflect.DeepEqual(msg.TxIn[0], txIn) {
-		t.Errorf("AddTxIn: wrong transaction input added - got %v, want %v",
-			spew.Sprint(msg.TxIn[0]), spew.Sprint(txIn))
-	}
-
-	// Ensure transaction outputs are added properly.
-	msg.AddTxOut(txOut)
-	if !reflect.DeepEqual(msg.TxOut[0], txOut) {
-		t.Errorf("AddTxIn: wrong transaction output added - got %v, want %v",
-			spew.Sprint(msg.TxOut[0]), spew.Sprint(txOut))
-	}
-
-	// Ensure the copy produced an identical transaction message.
-	newMsg := msg.Copy()
-	if !reflect.DeepEqual(newMsg, msg) {
-		t.Errorf("Copy: mismatched tx messages - got %v, want %v",
-			spew.Sdump(newMsg), spew.Sdump(msg))
-	}
-}
-
-// TestTxHash tests the ability to generate the hash of a transaction accurately.
-func TestTxHashAndID(t *testing.T) {
-	txID1Str := "a3d29c39bfb578235e4813cc8138a9ba10def63acad193a7a880159624840d7f"
-	wantTxID1, err := transactionid.FromString(txID1Str)
-	if err != nil {
-		t.Errorf("NewTxIDFromStr: %v", err)
-		return
-	}
-
-	// A coinbase transaction
-	txIn := &TxIn{
-		PreviousOutpoint: Outpoint{
-			TxID:  externalapi.DomainTransactionID{},
-			Index: math.MaxUint32,
-		},
-		SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
-		Sequence:        math.MaxUint64,
-	}
-	txOut := &TxOut{
-		Value: 5000000000,
-		ScriptPubKey: []byte{
-			0x41, // OP_DATA_65
-			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
-			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
-			0x81, 0xbe, 0x98, 0x8e, 0x2d, 0xa0, 0xb6, 0xc1,
-			0xc6, 0xa5, 0x9d, 0xc2, 0x26, 0xc2, 0x86, 0x24,
-			0xe1, 0x81, 0x75, 0xe8, 0x51, 0xc9, 0x6b, 0x97,
-			0x3d, 0x81, 0xb0, 0x1c, 0xc3, 0x1f, 0x04, 0x78,
-			0x34, 0xbc, 0x06, 0xd6, 0xd6, 0xed, 0xf6, 0x20,
-			0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
-			0xa6, // 65-byte signature
-			0xac, // OP_CHECKSIG
-		},
-	}
-	tx1 := NewSubnetworkMsgTx(1, []*TxIn{txIn}, []*TxOut{txOut}, &subnetworks.SubnetworkIDCoinbase, 0, nil)
-
-	// Ensure the hash produced is expected.
-	tx1Hash := tx1.TxHash()
-	if *tx1Hash != (externalapi.DomainHash)(*wantTxID1) {
-		t.Errorf("TxHash: wrong hash - got %v, want %v",
-			spew.Sprint(tx1Hash), spew.Sprint(wantTxID1))
-	}
-
-	// Ensure the TxID for coinbase transaction is the same as TxHash.
-	tx1ID := tx1.TxID()
-	if *tx1ID != *wantTxID1 {
-		t.Errorf("TxID: wrong ID - got %v, want %v",
-			spew.Sprint(tx1ID), spew.Sprint(wantTxID1))
-	}
-
-	hash2Str := "c84f3009b337aaa3adeb2ffd41010d5f62dd773ca25b39c908a77da91f87b729"
-	wantHash2, err := hashes.FromString(hash2Str)
-	if err != nil {
-		t.Errorf("NewTxIDFromStr: %v", err)
-		return
-	}
-
-	id2Str := "7c919f676109743a1271a88beeb43849a6f9cc653f6082e59a7266f3df4802b9"
-	wantID2, err := transactionid.FromString(id2Str)
-	if err != nil {
-		t.Errorf("NewTxIDFromStr: %v", err)
-		return
-	}
-	payload := []byte{1, 2, 3}
-	txIns := []*TxIn{{
-		PreviousOutpoint: Outpoint{
-			Index: 0,
-			TxID:  externalapi.DomainTransactionID{1, 2, 3},
-		},
-		SignatureScript: []byte{
-			0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF,
-			0x05, 0x77, 0x37, 0x57, 0xDE, 0xB1, 0x68, 0x82, 0x09, 0x30, 0xE3, 0xB0, 0xD0, 0x3F, 0x46, 0xF5,
-			0xFC, 0xF1, 0x50, 0xBF, 0x99, 0x0C, 0x02, 0x21, 0x00, 0xD2, 0x5B, 0x5C, 0x87, 0x04, 0x00, 0x76,
-			0xE4, 0xF2, 0x53, 0xF8, 0x26, 0x2E, 0x76, 0x3E, 0x2D, 0xD5, 0x1E, 0x7F, 0xF0, 0xBE, 0x15, 0x77,
-			0x27, 0xC4, 0xBC, 0x42, 0x80, 0x7F, 0x17, 0xBD, 0x39, 0x01, 0x41, 0x04, 0xE6, 0xC2, 0x6E, 0xF6,
-			0x7D, 0xC6, 0x10, 0xD2, 0xCD, 0x19, 0x24, 0x84, 0x78, 0x9A, 0x6C, 0xF9, 0xAE, 0xA9, 0x93, 0x0B,
-			0x94, 0x4B, 0x7E, 0x2D, 0xB5, 0x34, 0x2B, 0x9D, 0x9E, 0x5B, 0x9F, 0xF7, 0x9A, 0xFF, 0x9A, 0x2E,
-			0xE1, 0x97, 0x8D, 0xD7, 0xFD, 0x01, 0xDF, 0xC5, 0x22, 0xEE, 0x02, 0x28, 0x3D, 0x3B, 0x06, 0xA9,
-			0xD0, 0x3A, 0xCF, 0x80, 0x96, 0x96, 0x8D, 0x7D, 0xBB, 0x0F, 0x91, 0x78,
-		},
-		Sequence: math.MaxUint64,
-	}}
-	txOuts := []*TxOut{
-		{
-			Value: 244623243,
-			ScriptPubKey: []byte{
-				0x76, 0xA9, 0x14, 0xBA, 0xDE, 0xEC, 0xFD, 0xEF, 0x05, 0x07, 0x24, 0x7F, 0xC8, 0xF7, 0x42, 0x41,
-				0xD7, 0x3B, 0xC0, 0x39, 0x97, 0x2D, 0x7B, 0x88, 0xAC,
-			},
-		},
-		{
-			Value: 44602432,
-			ScriptPubKey: []byte{
-				0x76, 0xA9, 0x14, 0xC1, 0x09, 0x32, 0x48, 0x3F, 0xEC, 0x93, 0xED, 0x51, 0xF5, 0xFE, 0x95, 0xE7,
-				0x25, 0x59, 0xF2, 0xCC, 0x70, 0x43, 0xF9, 0x88, 0xAC,
-			},
-		},
-	}
-	tx2 := NewSubnetworkMsgTx(1, txIns, txOuts, &externalapi.DomainSubnetworkID{1, 2, 3}, 0, payload)
-
-	// Ensure the hash produced is expected.
-	tx2Hash := tx2.TxHash()
-	if *tx2Hash != *wantHash2 {
-		t.Errorf("TxHash: wrong hash - got %v, want %v",
-			spew.Sprint(tx2Hash), spew.Sprint(wantHash2))
-	}
-
-	// Ensure the TxID for coinbase transaction is the same as TxHash.
-	tx2ID := tx2.TxID()
-	if *tx2ID != *wantID2 {
-		t.Errorf("TxID: wrong ID - got %v, want %v",
-			spew.Sprint(tx2ID), spew.Sprint(wantID2))
-	}
-
-	if *tx2ID == (externalapi.DomainTransactionID)(*tx2Hash) {
-		t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload")
-	}
-
-	tx2.TxIn[0].SignatureScript = []byte{}
-	newTx2Hash := tx2.TxHash()
-	if *tx2ID != (externalapi.DomainTransactionID)(*newTx2Hash) {
-		t.Errorf("tx2ID and newTx2Hash should be the same for transaction with an empty signature")
-	}
-}

app/appmessage/rpc_add_peer.go

@@ -1,39 +0,0 @@
-package appmessage
-
-// AddPeerRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type AddPeerRequestMessage struct {
-	baseMessage
-	Address     string
-	IsPermanent bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *AddPeerRequestMessage) Command() MessageCommand {
-	return CmdAddPeerRequestMessage
-}
-
-// NewAddPeerRequestMessage returns a instance of the message
-func NewAddPeerRequestMessage(address string, isPermanent bool) *AddPeerRequestMessage {
-	return &AddPeerRequestMessage{
-		Address:     address,
-		IsPermanent: isPermanent,
-	}
-}
-
-// AddPeerResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type AddPeerResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *AddPeerResponseMessage) Command() MessageCommand {
-	return CmdAddPeerResponseMessage
-}
-
-// NewAddPeerResponseMessage returns a instance of the message
-func NewAddPeerResponseMessage() *AddPeerResponseMessage {
-	return &AddPeerResponseMessage{}
-}

app/appmessage/rpc_get_block.go

@@ -1,108 +0,0 @@
-package appmessage
-
-// GetBlockRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockRequestMessage struct {
-	baseMessage
-	Hash                          string
-	SubnetworkID                  string
-	IncludeTransactionVerboseData bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockRequestMessage) Command() MessageCommand {
-	return CmdGetBlockRequestMessage
-}
-
-// NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
-	return &GetBlockRequestMessage{
-		Hash:                          hash,
-		SubnetworkID:                  subnetworkID,
-		IncludeTransactionVerboseData: includeTransactionVerboseData,
-	}
-}
-
-// GetBlockResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockResponseMessage struct {
-	baseMessage
-	BlockVerboseData *BlockVerboseData
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockResponseMessage) Command() MessageCommand {
-	return CmdGetBlockResponseMessage
-}
-
-// NewGetBlockResponseMessage returns a instance of the message
-func NewGetBlockResponseMessage() *GetBlockResponseMessage {
-	return &GetBlockResponseMessage{}
-}
-
-// BlockVerboseData holds verbose data about a block
-type BlockVerboseData struct {
-	Hash                   string
-	Version                int32
-	VersionHex             string
-	HashMerkleRoot         string
-	AcceptedIDMerkleRoot   string
-	UTXOCommitment         string
-	TxIDs                  []string
-	TransactionVerboseData []*TransactionVerboseData
-	Time                   int64
-	Nonce                  uint64
-	Bits                   string
-	Difficulty             float64
-	ParentHashes           []string
-	SelectedParentHash     string
-}
-
-// TransactionVerboseData holds verbose data about a transaction
-type TransactionVerboseData struct {
-	TxID                      string
-	Hash                      string
-	Size                      uint64
-	Version                   int32
-	LockTime                  uint64
-	SubnetworkID              string
-	Gas                       uint64
-	PayloadHash               string
-	Payload                   string
-	TransactionVerboseInputs  []*TransactionVerboseInput
-	TransactionVerboseOutputs []*TransactionVerboseOutput
-	BlockHash                 string
-	Time                      uint64
-	BlockTime                 uint64
-}
-
-// TransactionVerboseInput holds data about a transaction input
-type TransactionVerboseInput struct {
-	TxID        string
-	OutputIndex uint32
-	ScriptSig   *ScriptSig
-	Sequence    uint64
-}
-
-// ScriptSig holds data about a script signature
-type ScriptSig struct {
-	Asm string
-	Hex string
-}
-
-// TransactionVerboseOutput holds data about a transaction output
-type TransactionVerboseOutput struct {
-	Value        uint64
-	Index        uint32
-	ScriptPubKey *ScriptPubKeyResult
-}
-
-// ScriptPubKeyResult holds data about a script public key
-type ScriptPubKeyResult struct {
-	Asm     string
-	Hex     string
-	Type    string
-	Address string
-}

app/appmessage/rpc_get_block_count.go

@@ -1,38 +0,0 @@
-package appmessage
-
-// GetBlockCountRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockCountRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockCountRequestMessage) Command() MessageCommand {
-	return CmdGetBlockCountRequestMessage
-}
-
-// NewGetBlockCountRequestMessage returns a instance of the message
-func NewGetBlockCountRequestMessage() *GetBlockCountRequestMessage {
-	return &GetBlockCountRequestMessage{}
-}
-
-// GetBlockCountResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockCountResponseMessage struct {
-	baseMessage
-	BlockCount uint64
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockCountResponseMessage) Command() MessageCommand {
-	return CmdGetBlockCountResponseMessage
-}
-
-// NewGetBlockCountResponseMessage returns a instance of the message
-func NewGetBlockCountResponseMessage(blockCount uint64) *GetBlockCountResponseMessage {
-	return &GetBlockCountResponseMessage{
-		BlockCount: blockCount,
-	}
-}

app/appmessage/rpc_get_block_dag_info.go

@@ -1,41 +0,0 @@
-package appmessage
-
-// GetBlockDAGInfoRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockDAGInfoRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockDAGInfoRequestMessage) Command() MessageCommand {
-	return CmdGetBlockDAGInfoRequestMessage
-}
-
-// NewGetBlockDAGInfoRequestMessage returns a instance of the message
-func NewGetBlockDAGInfoRequestMessage() *GetBlockDAGInfoRequestMessage {
-	return &GetBlockDAGInfoRequestMessage{}
-}
-
-// GetBlockDAGInfoResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockDAGInfoResponseMessage struct {
-	baseMessage
-	NetworkName         string
-	BlockCount          uint64
-	TipHashes           []string
-	VirtualParentHashes []string
-	Difficulty          float64
-	PastMedianTime      int64
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockDAGInfoResponseMessage) Command() MessageCommand {
-	return CmdGetBlockDAGInfoResponseMessage
-}
-
-// NewGetBlockDAGInfoResponseMessage returns a instance of the message
-func NewGetBlockDAGInfoResponseMessage() *GetBlockDAGInfoResponseMessage {
-	return &GetBlockDAGInfoResponseMessage{}
-}

app/appmessage/rpc_get_block_template.go

@@ -1,39 +0,0 @@
-package appmessage
-
-// GetBlockTemplateRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockTemplateRequestMessage struct {
-	baseMessage
-	PayAddress string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockTemplateRequestMessage) Command() MessageCommand {
-	return CmdGetBlockTemplateRequestMessage
-}
-
-// NewGetBlockTemplateRequestMessage returns a instance of the message
-func NewGetBlockTemplateRequestMessage(payAddress string) *GetBlockTemplateRequestMessage {
-	return &GetBlockTemplateRequestMessage{
-		PayAddress: payAddress,
-	}
-}
-
-// GetBlockTemplateResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockTemplateResponseMessage struct {
-	baseMessage
-	MsgBlock *MsgBlock
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockTemplateResponseMessage) Command() MessageCommand {
-	return CmdGetBlockTemplateResponseMessage
-}
-
-// NewGetBlockTemplateResponseMessage returns a instance of the message
-func NewGetBlockTemplateResponseMessage(msgBlock *MsgBlock) *GetBlockTemplateResponseMessage {
-	return &GetBlockTemplateResponseMessage{MsgBlock: msgBlock}
-}

app/appmessage/rpc_get_blocks.go

@@ -1,51 +0,0 @@
-package appmessage
-
-// GetBlocksRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlocksRequestMessage struct {
-	baseMessage
-	LowHash                 string
-	IncludeBlockHexes       bool
-	IncludeBlockVerboseData bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlocksRequestMessage) Command() MessageCommand {
-	return CmdGetBlocksRequestMessage
-}
-
-// NewGetBlocksRequestMessage returns a instance of the message
-func NewGetBlocksRequestMessage(lowHash string, includeBlockHexes bool, includeBlockVerboseData bool) *GetBlocksRequestMessage {
-	return &GetBlocksRequestMessage{
-		LowHash:                 lowHash,
-		IncludeBlockHexes:       includeBlockHexes,
-		IncludeBlockVerboseData: includeBlockVerboseData,
-	}
-}
-
-// GetBlocksResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlocksResponseMessage struct {
-	baseMessage
-	BlockHashes      []string
-	BlockHexes       []string
-	BlockVerboseData []*BlockVerboseData
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlocksResponseMessage) Command() MessageCommand {
-	return CmdGetBlocksResponseMessage
-}
-
-// NewGetBlocksResponseMessage returns a instance of the message
-func NewGetBlocksResponseMessage(blockHashes []string, blockHexes []string,
-	blockVerboseData []*BlockVerboseData) *GetBlocksResponseMessage {
-
-	return &GetBlocksResponseMessage{
-		BlockHashes:      blockHashes,
-		BlockHexes:       blockHexes,
-		BlockVerboseData: blockVerboseData,
-	}
-}

app/appmessage/rpc_get_chain_from_block.go

@@ -1,49 +0,0 @@
-package appmessage
-
-// GetChainFromBlockRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetChainFromBlockRequestMessage struct {
-	baseMessage
-	StartHash               string
-	IncludeBlockVerboseData bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetChainFromBlockRequestMessage) Command() MessageCommand {
-	return CmdGetChainFromBlockRequestMessage
-}
-
-// NewGetChainFromBlockRequestMessage returns a instance of the message
-func NewGetChainFromBlockRequestMessage(startHash string, includeBlockVerboseData bool) *GetChainFromBlockRequestMessage {
-	return &GetChainFromBlockRequestMessage{
-		StartHash:               startHash,
-		IncludeBlockVerboseData: includeBlockVerboseData,
-	}
-}
-
-// GetChainFromBlockResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetChainFromBlockResponseMessage struct {
-	baseMessage
-	RemovedChainBlockHashes []string
-	AddedChainBlocks        []*ChainBlock
-	BlockVerboseData        []*BlockVerboseData
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetChainFromBlockResponseMessage) Command() MessageCommand {
-	return CmdGetChainFromBlockResponseMessage
-}
-
-// NewGetChainFromBlockResponseMessage returns a instance of the message
-func NewGetChainFromBlockResponseMessage(removedChainBlockHashes []string,
-	addedChainBlocks []*ChainBlock, blockVerboseData []*BlockVerboseData) *GetChainFromBlockResponseMessage {
-
-	return &GetChainFromBlockResponseMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlocks:        addedChainBlocks,
-		BlockVerboseData:        blockVerboseData,
-	}
-}

app/appmessage/rpc_get_connected_peer_info.go

@@ -1,51 +0,0 @@
-package appmessage
-
-// GetConnectedPeerInfoRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetConnectedPeerInfoRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetConnectedPeerInfoRequestMessage) Command() MessageCommand {
-	return CmdGetConnectedPeerInfoRequestMessage
-}
-
-// NewGetConnectedPeerInfoRequestMessage returns a instance of the message
-func NewGetConnectedPeerInfoRequestMessage() *GetConnectedPeerInfoRequestMessage {
-	return &GetConnectedPeerInfoRequestMessage{}
-}
-
-// GetConnectedPeerInfoResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetConnectedPeerInfoResponseMessage struct {
-	baseMessage
-	Infos []*GetConnectedPeerInfoMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetConnectedPeerInfoResponseMessage) Command() MessageCommand {
-	return CmdGetConnectedPeerInfoResponseMessage
-}
-
-// NewGetConnectedPeerInfoResponseMessage returns a instance of the message
-func NewGetConnectedPeerInfoResponseMessage(infos []*GetConnectedPeerInfoMessage) *GetConnectedPeerInfoResponseMessage {
-	return &GetConnectedPeerInfoResponseMessage{
-		Infos: infos,
-	}
-}
-
-// GetConnectedPeerInfoMessage holds information about a connected peer
-type GetConnectedPeerInfoMessage struct {
-	ID                        string
-	Address                   string
-	LastPingDuration          int64
-	SelectedTipHash           string
-	IsSyncNode                bool
-	IsOutbound                bool
-	TimeOffset                int64
-	UserAgent                 string
-	AdvertisedProtocolVersion uint32
-	TimeConnected             int64
-}

app/appmessage/rpc_get_current_network.go

@@ -1,38 +0,0 @@
-package appmessage
-
-// GetCurrentNetworkRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetCurrentNetworkRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetCurrentNetworkRequestMessage) Command() MessageCommand {
-	return CmdGetCurrentNetworkRequestMessage
-}
-
-// NewGetCurrentNetworkRequestMessage returns a instance of the message
-func NewGetCurrentNetworkRequestMessage() *GetCurrentNetworkRequestMessage {
-	return &GetCurrentNetworkRequestMessage{}
-}
-
-// GetCurrentNetworkResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetCurrentNetworkResponseMessage struct {
-	baseMessage
-	CurrentNetwork string
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetCurrentNetworkResponseMessage) Command() MessageCommand {
-	return CmdGetCurrentNetworkResponseMessage
-}
-
-// NewGetCurrentNetworkResponseMessage returns a instance of the message
-func NewGetCurrentNetworkResponseMessage(currentNetwork string) *GetCurrentNetworkResponseMessage {
-	return &GetCurrentNetworkResponseMessage{
-		CurrentNetwork: currentNetwork,
-	}
-}

app/appmessage/rpc_get_headers.go

@@ -1,45 +0,0 @@
-package appmessage
-
-// GetHeadersRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetHeadersRequestMessage struct {
-	baseMessage
-	StartHash   string
-	Limit       uint64
-	IsAscending bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetHeadersRequestMessage) Command() MessageCommand {
-	return CmdGetHeadersRequestMessage
-}
-
-// NewGetHeadersRequestMessage returns a instance of the message
-func NewGetHeadersRequestMessage(startHash string, limit uint64, isAscending bool) *GetHeadersRequestMessage {
-	return &GetHeadersRequestMessage{
-		StartHash:   startHash,
-		Limit:       limit,
-		IsAscending: isAscending,
-	}
-}
-
-// GetHeadersResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetHeadersResponseMessage struct {
-	baseMessage
-	Headers []string
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetHeadersResponseMessage) Command() MessageCommand {
-	return CmdGetHeadersResponseMessage
-}
-
-// NewGetHeadersResponseMessage returns a instance of the message
-func NewGetHeadersResponseMessage(headers []string) *GetHeadersResponseMessage {
-	return &GetHeadersResponseMessage{
-		Headers: headers,
-	}
-}

app/appmessage/rpc_get_mempool_entries.go

@@ -1,38 +0,0 @@
-package appmessage
-
-// GetMempoolEntriesRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntriesRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntriesRequestMessage) Command() MessageCommand {
-	return CmdGetMempoolEntriesRequestMessage
-}
-
-// NewGetMempoolEntriesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesRequestMessage() *GetMempoolEntriesRequestMessage {
-	return &GetMempoolEntriesRequestMessage{}
-}
-
-// GetMempoolEntriesResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntriesResponseMessage struct {
-	baseMessage
-	Entries []*MempoolEntry
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntriesResponseMessage) Command() MessageCommand {
-	return CmdGetMempoolEntriesResponseMessage
-}
-
-// NewGetMempoolEntriesResponseMessage returns a instance of the message
-func NewGetMempoolEntriesResponseMessage(entries []*MempoolEntry) *GetMempoolEntriesResponseMessage {
-	return &GetMempoolEntriesResponseMessage{
-		Entries: entries,
-	}
-}

app/appmessage/rpc_get_mempool_entry.go

@@ -1,48 +0,0 @@
-package appmessage
-
-// GetMempoolEntryRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntryRequestMessage struct {
-	baseMessage
-	TxID string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntryRequestMessage) Command() MessageCommand {
-	return CmdGetMempoolEntryRequestMessage
-}
-
-// NewGetMempoolEntryRequestMessage returns a instance of the message
-func NewGetMempoolEntryRequestMessage(txID string) *GetMempoolEntryRequestMessage {
-	return &GetMempoolEntryRequestMessage{TxID: txID}
-}
-
-// GetMempoolEntryResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetMempoolEntryResponseMessage struct {
-	baseMessage
-	Entry *MempoolEntry
-
-	Error *RPCError
-}
-
-// MempoolEntry represents a transaction in the mempool.
-type MempoolEntry struct {
-	Fee                    uint64
-	TransactionVerboseData *TransactionVerboseData
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
-	return CmdGetMempoolEntryResponseMessage
-}
-
-// NewGetMempoolEntryResponseMessage returns a instance of the message
-func NewGetMempoolEntryResponseMessage(fee uint64, transactionVerboseData *TransactionVerboseData) *GetMempoolEntryResponseMessage {
-	return &GetMempoolEntryResponseMessage{
-		Entry: &MempoolEntry{
-			Fee:                    fee,
-			TransactionVerboseData: transactionVerboseData,
-		},
-	}
-}

app/appmessage/rpc_get_peer_addresses.go

@@ -1,44 +0,0 @@
-package appmessage
-
-// GetPeerAddressesRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetPeerAddressesRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetPeerAddressesRequestMessage) Command() MessageCommand {
-	return CmdGetPeerAddressesRequestMessage
-}
-
-// NewGetPeerAddressesRequestMessage returns a instance of the message
-func NewGetPeerAddressesRequestMessage() *GetPeerAddressesRequestMessage {
-	return &GetPeerAddressesRequestMessage{}
-}
-
-// GetPeerAddressesResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetPeerAddressesResponseMessage struct {
-	baseMessage
-	Addresses []*GetPeerAddressesKnownAddressMessage
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetPeerAddressesResponseMessage) Command() MessageCommand {
-	return CmdGetPeerAddressesResponseMessage
-}
-
-// NewGetPeerAddressesResponseMessage returns a instance of the message
-func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
-	return &GetPeerAddressesResponseMessage{
-		Addresses: addresses,
-	}
-}
-
-// GetPeerAddressesKnownAddressMessage is an appmessage corresponding to
-// its respective RPC message
-type GetPeerAddressesKnownAddressMessage struct {
-	Addr string
-}

app/appmessage/rpc_get_selected_tip_hash.go

@@ -1,38 +0,0 @@
-package appmessage
-
-// GetSelectedTipHashRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetSelectedTipHashRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetSelectedTipHashRequestMessage) Command() MessageCommand {
-	return CmdGetSelectedTipHashRequestMessage
-}
-
-// NewGetSelectedTipHashRequestMessage returns a instance of the message
-func NewGetSelectedTipHashRequestMessage() *GetSelectedTipHashRequestMessage {
-	return &GetSelectedTipHashRequestMessage{}
-}
-
-// GetSelectedTipHashResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetSelectedTipHashResponseMessage struct {
-	baseMessage
-	SelectedTipHash string
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetSelectedTipHashResponseMessage) Command() MessageCommand {
-	return CmdGetSelectedTipHashResponseMessage
-}
-
-// NewGetSelectedTipHashResponseMessage returns a instance of the message
-func NewGetSelectedTipHashResponseMessage(selectedTipHash string) *GetSelectedTipHashResponseMessage {
-	return &GetSelectedTipHashResponseMessage{
-		SelectedTipHash: selectedTipHash,
-	}
-}

app/appmessage/rpc_get_subnetwork.go

@@ -1,41 +0,0 @@
-package appmessage
-
-// GetSubnetworkRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetSubnetworkRequestMessage struct {
-	baseMessage
-	SubnetworkID string
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetSubnetworkRequestMessage) Command() MessageCommand {
-	return CmdGetSubnetworkRequestMessage
-}
-
-// NewGetSubnetworkRequestMessage returns a instance of the message
-func NewGetSubnetworkRequestMessage(subnetworkID string) *GetSubnetworkRequestMessage {
-	return &GetSubnetworkRequestMessage{
-		SubnetworkID: subnetworkID,
-	}
-}
-
-// GetSubnetworkResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetSubnetworkResponseMessage struct {
-	baseMessage
-	GasLimit uint64
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetSubnetworkResponseMessage) Command() MessageCommand {
-	return CmdGetSubnetworkResponseMessage
-}
-
-// NewGetSubnetworkResponseMessage returns a instance of the message
-func NewGetSubnetworkResponseMessage(gasLimit uint64) *GetSubnetworkResponseMessage {
-	return &GetSubnetworkResponseMessage{
-		GasLimit: gasLimit,
-	}
-}

app/appmessage/rpc_notify_block_added.go

@@ -1,53 +0,0 @@
-package appmessage
-
-// NotifyBlockAddedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyBlockAddedRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyBlockAddedRequestMessage) Command() MessageCommand {
-	return CmdNotifyBlockAddedRequestMessage
-}
-
-// NewNotifyBlockAddedRequestMessage returns a instance of the message
-func NewNotifyBlockAddedRequestMessage() *NotifyBlockAddedRequestMessage {
-	return &NotifyBlockAddedRequestMessage{}
-}
-
-// NotifyBlockAddedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyBlockAddedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyBlockAddedResponseMessage) Command() MessageCommand {
-	return CmdNotifyBlockAddedResponseMessage
-}
-
-// NewNotifyBlockAddedResponseMessage returns a instance of the message
-func NewNotifyBlockAddedResponseMessage() *NotifyBlockAddedResponseMessage {
-	return &NotifyBlockAddedResponseMessage{}
-}
-
-// BlockAddedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type BlockAddedNotificationMessage struct {
-	baseMessage
-	Block *MsgBlock
-}
-
-// Command returns the protocol command string for the message
-func (msg *BlockAddedNotificationMessage) Command() MessageCommand {
-	return CmdBlockAddedNotificationMessage
-}
-
-// NewBlockAddedNotificationMessage returns a instance of the message
-func NewBlockAddedNotificationMessage(block *MsgBlock) *BlockAddedNotificationMessage {
-	return &BlockAddedNotificationMessage{
-		Block: block,
-	}
-}

app/appmessage/rpc_notify_chain_changed.go

@@ -1,69 +0,0 @@
-package appmessage
-
-// NotifyChainChangedRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyChainChangedRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyChainChangedRequestMessage) Command() MessageCommand {
-	return CmdNotifyChainChangedRequestMessage
-}
-
-// NewNotifyChainChangedRequestMessage returns a instance of the message
-func NewNotifyChainChangedRequestMessage() *NotifyChainChangedRequestMessage {
-	return &NotifyChainChangedRequestMessage{}
-}
-
-// NotifyChainChangedResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyChainChangedResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyChainChangedResponseMessage) Command() MessageCommand {
-	return CmdNotifyChainChangedResponseMessage
-}
-
-// NewNotifyChainChangedResponseMessage returns a instance of the message
-func NewNotifyChainChangedResponseMessage() *NotifyChainChangedResponseMessage {
-	return &NotifyChainChangedResponseMessage{}
-}
-
-// ChainChangedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type ChainChangedNotificationMessage struct {
-	baseMessage
-	RemovedChainBlockHashes []string
-	AddedChainBlocks        []*ChainBlock
-}
-
-// ChainBlock represents a DAG chain-block
-type ChainBlock struct {
-	Hash           string
-	AcceptedBlocks []*AcceptedBlock
-}
-
-// AcceptedBlock represents a block accepted into the DAG
-type AcceptedBlock struct {
-	Hash          string
-	AcceptedTxIDs []string
-}
-
-// Command returns the protocol command string for the message
-func (msg *ChainChangedNotificationMessage) Command() MessageCommand {
-	return CmdChainChangedNotificationMessage
-}
-
-// NewChainChangedNotificationMessage returns a instance of the message
-func NewChainChangedNotificationMessage(removedChainBlockHashes []string,
-	addedChainBlocks []*ChainBlock) *ChainChangedNotificationMessage {
-
-	return &ChainChangedNotificationMessage{
-		RemovedChainBlockHashes: removedChainBlockHashes,
-		AddedChainBlocks:        addedChainBlocks,
-	}
-}

app/appmessage/rpc_notify_finality_conflicts.go

@@ -1,72 +0,0 @@
-package appmessage
-
-// NotifyFinalityConflictsRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyFinalityConflictsRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyFinalityConflictsRequestMessage) Command() MessageCommand {
-	return CmdNotifyFinalityConflictsRequestMessage
-}
-
-// NewNotifyFinalityConflictsRequestMessage returns a instance of the message
-func NewNotifyFinalityConflictsRequestMessage() *NotifyFinalityConflictsRequestMessage {
-	return &NotifyFinalityConflictsRequestMessage{}
-}
-
-// NotifyFinalityConflictsResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type NotifyFinalityConflictsResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *NotifyFinalityConflictsResponseMessage) Command() MessageCommand {
-	return CmdNotifyFinalityConflictsResponseMessage
-}
-
-// NewNotifyFinalityConflictsResponseMessage returns a instance of the message
-func NewNotifyFinalityConflictsResponseMessage() *NotifyFinalityConflictsResponseMessage {
-	return &NotifyFinalityConflictsResponseMessage{}
-}
-
-// FinalityConflictNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type FinalityConflictNotificationMessage struct {
-	baseMessage
-	ViolatingBlockHash string
-}
-
-// Command returns the protocol command string for the message
-func (msg *FinalityConflictNotificationMessage) Command() MessageCommand {
-	return CmdFinalityConflictNotificationMessage
-}
-
-// NewFinalityConflictNotificationMessage returns a instance of the message
-func NewFinalityConflictNotificationMessage(violatingBlockHash string) *FinalityConflictNotificationMessage {
-	return &FinalityConflictNotificationMessage{
-		ViolatingBlockHash: violatingBlockHash,
-	}
-}
-
-// FinalityConflictResolvedNotificationMessage is an appmessage corresponding to
-// its respective RPC message
-type FinalityConflictResolvedNotificationMessage struct {
-	baseMessage
-	FinalityBlockHash string
-}
-
-// Command returns the protocol command string for the message
-func (msg *FinalityConflictResolvedNotificationMessage) Command() MessageCommand {
-	return CmdFinalityConflictResolvedNotificationMessage
-}
-
-// NewFinalityConflictResolvedNotificationMessage returns a instance of the message
-func NewFinalityConflictResolvedNotificationMessage(finalityBlockHash string) *FinalityConflictResolvedNotificationMessage {
-	return &FinalityConflictResolvedNotificationMessage{
-		FinalityBlockHash: finalityBlockHash,
-	}
-}

app/appmessage/rpc_resolve_finality_conflict.go

@@ -1,37 +0,0 @@
-package appmessage
-
-// ResolveFinalityConflictRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type ResolveFinalityConflictRequestMessage struct {
-	baseMessage
-	FinalityBlockHash string
-}
-
-// Command returns the protocol command string for the message
-func (msg *ResolveFinalityConflictRequestMessage) Command() MessageCommand {
-	return CmdResolveFinalityConflictRequestMessage
-}
-
-// NewResolveFinalityConflictRequestMessage returns a instance of the message
-func NewResolveFinalityConflictRequestMessage(finalityBlockHash string) *ResolveFinalityConflictRequestMessage {
-	return &ResolveFinalityConflictRequestMessage{
-		FinalityBlockHash: finalityBlockHash,
-	}
-}
-
-// ResolveFinalityConflictResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type ResolveFinalityConflictResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *ResolveFinalityConflictResponseMessage) Command() MessageCommand {
-	return CmdResolveFinalityConflictResponseMessage
-}
-
-// NewResolveFinalityConflictResponseMessage returns a instance of the message
-func NewResolveFinalityConflictResponseMessage() *ResolveFinalityConflictResponseMessage {
-	return &ResolveFinalityConflictResponseMessage{}
-}

app/appmessage/rpc_shut_down.go

@@ -1,34 +0,0 @@
-package appmessage
-
-// ShutDownRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type ShutDownRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *ShutDownRequestMessage) Command() MessageCommand {
-	return CmdShutDownRequestMessage
-}
-
-// NewShutDownRequestMessage returns a instance of the message
-func NewShutDownRequestMessage() *ShutDownRequestMessage {
-	return &ShutDownRequestMessage{}
-}
-
-// ShutDownResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type ShutDownResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *ShutDownResponseMessage) Command() MessageCommand {
-	return CmdShutDownResponseMessage
-}
-
-// NewShutDownResponseMessage returns a instance of the message
-func NewShutDownResponseMessage() *ShutDownResponseMessage {
-	return &ShutDownResponseMessage{}
-}

app/appmessage/rpc_submit_block.go

@@ -1,37 +0,0 @@
-package appmessage
-
-// SubmitBlockRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitBlockRequestMessage struct {
-	baseMessage
-	Block *MsgBlock
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitBlockRequestMessage) Command() MessageCommand {
-	return CmdSubmitBlockRequestMessage
-}
-
-// NewSubmitBlockRequestMessage returns a instance of the message
-func NewSubmitBlockRequestMessage(block *MsgBlock) *SubmitBlockRequestMessage {
-	return &SubmitBlockRequestMessage{
-		Block: block,
-	}
-}
-
-// SubmitBlockResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitBlockResponseMessage struct {
-	baseMessage
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitBlockResponseMessage) Command() MessageCommand {
-	return CmdSubmitBlockResponseMessage
-}
-
-// NewSubmitBlockResponseMessage returns a instance of the message
-func NewSubmitBlockResponseMessage() *SubmitBlockResponseMessage {
-	return &SubmitBlockResponseMessage{}
-}

app/appmessage/rpc_submit_transaction.go

@@ -1,41 +0,0 @@
-package appmessage
-
-// SubmitTransactionRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitTransactionRequestMessage struct {
-	baseMessage
-	Transaction *MsgTx
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitTransactionRequestMessage) Command() MessageCommand {
-	return CmdSubmitTransactionRequestMessage
-}
-
-// NewSubmitTransactionRequestMessage returns a instance of the message
-func NewSubmitTransactionRequestMessage(transaction *MsgTx) *SubmitTransactionRequestMessage {
-	return &SubmitTransactionRequestMessage{
-		Transaction: transaction,
-	}
-}
-
-// SubmitTransactionResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitTransactionResponseMessage struct {
-	baseMessage
-	TxID string
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitTransactionResponseMessage) Command() MessageCommand {
-	return CmdSubmitTransactionResponseMessage
-}
-
-// NewSubmitTransactionResponseMessage returns a instance of the message
-func NewSubmitTransactionResponseMessage(txID string) *SubmitTransactionResponseMessage {
-	return &SubmitTransactionResponseMessage{
-		TxID: txID,
-	}
-}

app/component_manager.go

@@ -1,164 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"sync/atomic"
-
-	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
-
-	"github.com/kaspanet/kaspad/domain"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol"
-	"github.com/kaspanet/kaspad/app/rpc"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/util/panics"
-)
-
-// ComponentManager is a wrapper for all the kaspad services
-type ComponentManager struct {
-	cfg               *config.Config
-	addressManager    *addressmanager.AddressManager
-	protocolManager   *protocol.Manager
-	rpcManager        *rpc.Manager
-	connectionManager *connmanager.ConnectionManager
-	netAdapter        *netadapter.NetAdapter
-
-	started, shutdown int32
-}
-
-// Start launches all the kaspad services.
-func (a *ComponentManager) Start() {
-	// Already started?
-	if atomic.AddInt32(&a.started, 1) != 1 {
-		return
-	}
-
-	log.Trace("Starting kaspad")
-
-	err := a.netAdapter.Start()
-	if err != nil {
-		panics.Exit(log, fmt.Sprintf("Error starting the net adapter: %+v", err))
-	}
-
-	a.maybeSeedFromDNS()
-
-	a.connectionManager.Start()
-}
-
-// Stop gracefully shuts down all the kaspad services.
-func (a *ComponentManager) Stop() {
-	// Make sure this only happens once.
-	if atomic.AddInt32(&a.shutdown, 1) != 1 {
-		log.Infof("Kaspad is already in the process of shutting down")
-		return
-	}
-
-	log.Warnf("Kaspad shutting down")
-
-	a.connectionManager.Stop()
-
-	err := a.netAdapter.Stop()
-	if err != nil {
-		log.Errorf("Error stopping the net adapter: %+v", err)
-	}
-
-	err = a.addressManager.Stop()
-	if err != nil {
-		log.Errorf("Error stopping address manager: %s", err)
-	}
-
-	return
-}
-
-// NewComponentManager returns a new ComponentManager instance.
-// Use Start() to begin all services within this ComponentManager
-func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database, interrupt chan<- struct{}) (
-	*ComponentManager, error) {
-
-	domain, err := domain.New(cfg.ActiveNetParams, db)
-	if err != nil {
-		return nil, err
-	}
-
-	netAdapter, err := netadapter.NewNetAdapter(cfg)
-	if err != nil {
-		return nil, err
-	}
-	addressManager, err := addressmanager.New(cfg, db)
-	if err != nil {
-		return nil, err
-	}
-	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
-	if err != nil {
-		return nil, err
-	}
-	protocolManager, err := protocol.NewManager(cfg, domain, netAdapter, addressManager, connectionManager)
-	if err != nil {
-		return nil, err
-	}
-	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, interrupt)
-
-	return &ComponentManager{
-		cfg:               cfg,
-		protocolManager:   protocolManager,
-		rpcManager:        rpcManager,
-		connectionManager: connectionManager,
-		netAdapter:        netAdapter,
-		addressManager:    addressManager,
-	}, nil
-
-}
-
-func setupRPC(
-	cfg *config.Config,
-	domain domain.Domain,
-	netAdapter *netadapter.NetAdapter,
-	protocolManager *protocol.Manager,
-	connectionManager *connmanager.ConnectionManager,
-	addressManager *addressmanager.AddressManager,
-	shutDownChan chan<- struct{},
-) *rpc.Manager {
-
-	rpcManager := rpc.NewManager(
-		cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, shutDownChan)
-	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
-
-	return rpcManager
-}
-
-func (a *ComponentManager) maybeSeedFromDNS() {
-	if !a.cfg.DisableDNSSeed {
-		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
-			a.cfg.Lookup, func(addresses []*appmessage.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)
-			})
-	}
-
-	if a.cfg.GRPCSeed != "" {
-		dnsseed.SeedFromGRPC(a.cfg.NetParams(), a.cfg.GRPCSeed, appmessage.SFNodeNetwork, false, nil,
-			func(addresses []*appmessage.NetAddress) {
-				a.addressManager.AddAddresses(addresses, addresses[0], nil)
-			})
-	}
-}
-
-// P2PNodeID returns the network ID associated with this ComponentManager
-func (a *ComponentManager) P2PNodeID() *id.ID {
-	return a.netAdapter.ID()
-}
-
-// AddressManager returns the AddressManager associated with this ComponentManager
-func (a *ComponentManager) AddressManager() *addressmanager.AddressManager {
-	return a.addressManager
-}

app/log.go

@@ -6,7 +6,7 @@
 package app
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/logger"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 

app/protocol/flowcontext/blocks.go

@@ -1,80 +0,0 @@
-package flowcontext
-
-import (
-	"sync/atomic"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-)
-
-// OnNewBlock updates the mempool after a new block arrival, and
-// relays newly unorphaned transactions and possibly rebroadcast
-// manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
-	f.Domain().MiningManager().HandleNewBlockTransactions(block.Transactions)
-
-	if f.onBlockAddedToDAGHandler != nil {
-		err := f.onBlockAddedToDAGHandler(block)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
-	block *externalapi.DomainBlock, transactionsAcceptedToMempool []*externalapi.DomainTransaction) error {
-
-	f.updateTransactionsToRebroadcast(block)
-
-	// Don't relay transactions when in IBD.
-	if atomic.LoadUint32(&f.isInIBD) != 0 {
-		return nil
-	}
-
-	var txIDsToRebroadcast []*externalapi.DomainTransactionID
-	if f.shouldRebroadcastTransactions() {
-		txIDsToRebroadcast = f.txIDsToRebroadcast()
-	}
-
-	txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
-	for i, tx := range transactionsAcceptedToMempool {
-		txIDsToBroadcast[i] = consensusserialization.TransactionID(tx)
-	}
-	offset := len(transactionsAcceptedToMempool)
-	for i, txID := range txIDsToRebroadcast {
-		txIDsToBroadcast[offset+i] = txID
-	}
-
-	if len(txIDsToBroadcast) == 0 {
-		return nil
-	}
-	if len(txIDsToBroadcast) > appmessage.MaxInvPerTxInvMsg {
-		txIDsToBroadcast = txIDsToBroadcast[:appmessage.MaxInvPerTxInvMsg]
-	}
-	inv := appmessage.NewMsgInvTransaction(txIDsToBroadcast)
-	return f.Broadcast(inv)
-}
-
-// SharedRequestedBlocks returns a *blockrelay.SharedRequestedBlocks for sharing
-// data about requested blocks between different peers.
-func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks {
-	return f.sharedRequestedBlocks
-}
-
-// AddBlock adds the given block to the DAG and propagates it.
-func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
-	err := f.Domain().Consensus().ValidateAndInsertBlock(block)
-	if err != nil {
-		return err
-	}
-	err = f.OnNewBlock(block)
-	if err != nil {
-		return err
-	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
-}

app/protocol/flowcontext/domain.go

@@ -1,10 +0,0 @@
-package flowcontext
-
-import (
-	"github.com/kaspanet/kaspad/domain"
-)
-
-// Domain returns the Domain object associated to the flow context.
-func (f *FlowContext) Domain() domain.Domain {
-	return f.domain
-}

app/protocol/flowcontext/errors.go

@@ -1,31 +0,0 @@
-package flowcontext
-
-import (
-	"errors"
-	"sync/atomic"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-)
-
-// HandleError handles an error from a flow,
-// It sends the error to errChan if isStopping == 0 and increments isStopping
-//
-// If this is ErrRouteClosed - forward it to errChan
-// If this is ProtocolError - logs the error, and forward it to errChan
-// Otherwise - panics
-func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error) {
-	isErrRouteClosed := errors.Is(err, router.ErrRouteClosed)
-	if !isErrRouteClosed {
-		if protocolErr := &(protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
-			panic(err)
-		}
-
-		log.Errorf("error from %s: %+v", flowName, err)
-	}
-
-	if atomic.AddUint32(isStopping, 1) == 1 {
-		errChan <- err
-	}
-}

app/protocol/flowcontext/flow_context.go

@@ -1,81 +0,0 @@
-package flowcontext
-
-import (
-	"sync"
-	"time"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
-	"github.com/kaspanet/kaspad/domain"
-
-	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-)
-
-// OnBlockAddedToDAGHandler is a handler function that's triggered
-// when a block is added to the DAG
-type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock) error
-
-// OnTransactionAddedToMempoolHandler is a handler function that's triggered
-// when a transaction is added to the mempool
-type OnTransactionAddedToMempoolHandler func()
-
-// FlowContext holds state that is relevant to more than one flow or one peer, and allows communication between
-// different flows that can be associated to different peers.
-type FlowContext struct {
-	cfg               *config.Config
-	netAdapter        *netadapter.NetAdapter
-	domain            domain.Domain
-	addressManager    *addressmanager.AddressManager
-	connectionManager *connmanager.ConnectionManager
-
-	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
-	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
-
-	transactionsToRebroadcastLock sync.Mutex
-	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
-	lastRebroadcastTime           time.Time
-	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
-
-	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
-
-	isInIBD       uint32
-	startIBDMutex sync.Mutex
-	ibdPeer       *peerpkg.Peer
-
-	peers      map[id.ID]*peerpkg.Peer
-	peersMutex sync.RWMutex
-}
-
-// New returns a new instance of FlowContext.
-func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanager.AddressManager,
-	netAdapter *netadapter.NetAdapter, connectionManager *connmanager.ConnectionManager) *FlowContext {
-
-	return &FlowContext{
-		cfg:                         cfg,
-		netAdapter:                  netAdapter,
-		domain:                      domain,
-		addressManager:              addressManager,
-		connectionManager:           connectionManager,
-		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
-		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
-		peers:                       make(map[id.ID]*peerpkg.Peer),
-		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
-	}
-}
-
-// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
-func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
-	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
-}
-
-// SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
-func (f *FlowContext) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler) {
-	f.onTransactionAddedToMempoolHandler = onTransactionAddedToMempoolHandler
-}

app/protocol/flowcontext/transactions.go

@@ -1,69 +0,0 @@
-package flowcontext
-
-import (
-	"time"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-)
-
-// AddTransaction adds transaction to the mempool and propagates it.
-func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
-	f.transactionsToRebroadcastLock.Lock()
-	defer f.transactionsToRebroadcastLock.Unlock()
-
-	err := f.Domain().MiningManager().ValidateAndInsertTransaction(tx, false)
-	if err != nil {
-		return err
-	}
-
-	transactionID := consensusserialization.TransactionID(tx)
-	f.transactionsToRebroadcast[*transactionID] = tx
-	inv := appmessage.NewMsgInvTransaction([]*externalapi.DomainTransactionID{transactionID})
-	return f.Broadcast(inv)
-}
-
-func (f *FlowContext) updateTransactionsToRebroadcast(block *externalapi.DomainBlock) {
-	f.transactionsToRebroadcastLock.Lock()
-	defer f.transactionsToRebroadcastLock.Unlock()
-	// Note: if the block is red, its transactions won't be rebroadcasted
-	// anymore, although they are not included in the UTXO set.
-	// This is probably ok, since red blocks are quite rare.
-	for _, tx := range block.Transactions {
-		delete(f.transactionsToRebroadcast, *consensusserialization.TransactionID(tx))
-	}
-}
-
-func (f *FlowContext) shouldRebroadcastTransactions() bool {
-	const rebroadcastInterval = 30 * time.Second
-	return time.Since(f.lastRebroadcastTime) > rebroadcastInterval
-}
-
-func (f *FlowContext) txIDsToRebroadcast() []*externalapi.DomainTransactionID {
-	f.transactionsToRebroadcastLock.Lock()
-	defer f.transactionsToRebroadcastLock.Unlock()
-
-	txIDs := make([]*externalapi.DomainTransactionID, len(f.transactionsToRebroadcast))
-	i := 0
-	for _, tx := range f.transactionsToRebroadcast {
-		txIDs[i] = consensusserialization.TransactionID(tx)
-		i++
-	}
-	return txIDs
-}
-
-// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
-// data about requested transactions between different peers.
-func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
-	return f.sharedRequestedTransactions
-}
-
-// OnTransactionAddedToMempool notifies the handler function that a transaction
-// has been added to the mempool
-func (f *FlowContext) OnTransactionAddedToMempool() {
-	if f.onTransactionAddedToMempoolHandler != nil {
-		f.onTransactionAddedToMempoolHandler()
-	}
-}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -1,50 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// RelayBlockRequestsContext is the interface for the context needed for the HandleRelayBlockRequests flow.
-type RelayBlockRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandleRelayBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
-// their corresponding blocks to the requesting peer.
-func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
-		for _, hash := range getRelayBlocksMessage.Hashes {
-			// Fetch the block from the database.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists {
-				return protocolerrors.Errorf(true, "block %s not found", hash)
-			}
-			block, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
-			}
-
-			// TODO (Partial nodes): Convert block to partial block if needed
-
-			err = outgoingRoute.Enqueue(appmessage.DomainBlockToMsgBlock(block))
-			if err != nil {
-				return err
-			}
-		}
-	}
-}

app/protocol/flows/ibd/ibd.go

@@ -1,213 +0,0 @@
-package ibd
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// HandleIBDContext is the interface for the context needed for the HandleIBD flow.
-type HandleIBDContext interface {
-	Domain() domain.Domain
-	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock) error
-	FinishIBD() error
-}
-
-type handleIBDFlow struct {
-	HandleIBDContext
-	incomingRoute, outgoingRoute *router.Route
-	peer                         *peerpkg.Peer
-}
-
-// HandleIBD waits for IBD start and handles it when IBD is triggered for this peer
-func HandleIBD(context HandleIBDContext, incomingRoute *router.Route, outgoingRoute *router.Route,
-	peer *peerpkg.Peer) error {
-
-	flow := &handleIBDFlow{
-		HandleIBDContext: context,
-		incomingRoute:    incomingRoute,
-		outgoingRoute:    outgoingRoute,
-		peer:             peer,
-	}
-	return flow.start()
-}
-
-func (flow *handleIBDFlow) start() error {
-	for {
-		err := flow.runIBD()
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (flow *handleIBDFlow) runIBD() error {
-	flow.peer.WaitForIBDStart()
-	defer flow.FinishIBD()
-
-	peerSelectedTipHash := flow.peer.SelectedTipHash()
-	log.Debugf("Trying to find highest shared chain block with peer %s with selected tip %s", flow.peer, peerSelectedTipHash)
-	highestSharedBlockHash, err := flow.findHighestSharedBlockHash(peerSelectedTipHash)
-	if err != nil {
-		return err
-	}
-
-	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-
-	return flow.downloadBlocks(highestSharedBlockHash, peerSelectedTipHash)
-}
-
-func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *externalapi.DomainHash) (lowHash *externalapi.DomainHash,
-	err error) {
-
-	lowHash = flow.Config().ActiveNetParams.GenesisHash
-	highHash := peerSelectedTipHash
-
-	for {
-		err := flow.sendGetBlockLocator(lowHash, highHash)
-		if err != nil {
-			return nil, err
-		}
-
-		blockLocatorHashes, err := flow.receiveBlockLocator()
-		if err != nil {
-			return nil, err
-		}
-
-		// We check whether the locator's highest hash is in the local DAG.
-		// If it is, return it. If it isn't, we need to narrow our
-		// getBlockLocator request and try again.
-		locatorHighHash := blockLocatorHashes[0]
-		locatorHighHashInfo, err := flow.Domain().Consensus().GetBlockInfo(locatorHighHash)
-		if err != nil {
-			return nil, err
-		}
-		if locatorHighHashInfo.Exists {
-			return locatorHighHash, nil
-		}
-
-		highHash, lowHash, err = flow.Domain().Consensus().FindNextBlockLocatorBoundaries(blockLocatorHashes)
-		if err != nil {
-			return nil, err
-		}
-	}
-}
-
-func (flow *handleIBDFlow) sendGetBlockLocator(lowHash *externalapi.DomainHash, highHash *externalapi.DomainHash) error {
-
-	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, lowHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
-}
-
-func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, err
-	}
-	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
-	if !ok {
-		return nil,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
-	}
-	return msgBlockLocator.BlockLocatorHashes, nil
-}
-
-func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	err := flow.sendGetBlocks(highestSharedBlockHash, peerSelectedTipHash)
-	if err != nil {
-		return err
-	}
-
-	blocksReceived := 0
-	for {
-		msgIBDBlock, doneIBD, err := flow.receiveIBDBlock()
-		if err != nil {
-			return err
-		}
-
-		if doneIBD {
-			return nil
-		}
-
-		err = flow.processIBDBlock(msgIBDBlock)
-		if err != nil {
-			return err
-		}
-
-		blocksReceived++
-		if blocksReceived%ibdBatchSize == 0 {
-			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextIBDBlocks())
-			if err != nil {
-				return err
-			}
-		}
-	}
-}
-
-func (flow *handleIBDFlow) sendGetBlocks(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	msgGetBlockInvs := appmessage.NewMsgRequstIBDBlocks(highestSharedBlockHash, peerSelectedTipHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
-}
-
-func (flow *handleIBDFlow) receiveIBDBlock() (msgIBDBlock *appmessage.MsgIBDBlock, doneIBD bool, err error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return nil, false, err
-	}
-	switch message := message.(type) {
-	case *appmessage.MsgIBDBlock:
-		return message, false, nil
-	case *appmessage.MsgDoneIBDBlocks:
-		return nil, true, nil
-	default:
-		return nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
-	}
-}
-
-func (flow *handleIBDFlow) processIBDBlock(msgIBDBlock *appmessage.MsgIBDBlock) error {
-	block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
-	blockHash := consensusserialization.BlockHash(block)
-	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
-	if err != nil {
-		return err
-	}
-	if blockInfo.Exists {
-		log.Debugf("IBD block %s is already in the DAG. Skipping...", blockHash)
-		return nil
-	}
-	err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
-	if err != nil {
-		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return errors.Wrapf(err, "failed to process block %s during IBD", blockHash)
-		}
-		log.Infof("Rejected block %s from %s during IBD: %s", blockHash, flow.peer, err)
-
-		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
-	}
-	err = flow.OnNewBlock(block)
-	if err != nil {
-		return err
-	}
-	err = blocklogger.LogBlock(block)
-	if err != nil {
-		return err
-	}
-	return nil
-}

app/protocol/flows/rejects/handle_rejects.go

@@ -1,42 +0,0 @@
-package rejects
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleRejectsContext is the interface for the context needed for the HandleRejects flow.
-type HandleRejectsContext interface {
-}
-
-type handleRejectsFlow struct {
-	HandleRejectsContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRejects handles all reject messages coming through incomingRoute.
-// This function assumes that incomingRoute will only return MsgReject.
-func HandleRejects(context HandleRejectsContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	flow := &handleRejectsFlow{
-		HandleRejectsContext: context,
-		incomingRoute:        incomingRoute,
-		outgoingRoute:        outgoingRoute,
-	}
-	return flow.start()
-}
-
-func (flow *handleRejectsFlow) start() error {
-	message, err := flow.incomingRoute.Dequeue()
-	if err != nil {
-		return err
-	}
-	rejectMessage := message.(*appmessage.MsgReject)
-
-	const maxReasonLength = 255
-	if len(rejectMessage.Reason) > maxReasonLength {
-		return protocolerrors.Errorf(false, "got reject message longer than %d", maxReasonLength)
-	}
-
-	return protocolerrors.Errorf(false, "got reject message: `%s`", rejectMessage.Reason)
-}

app/protocol/manager.go

@@ -1,75 +0,0 @@
-package protocol
-
-import (
-	"fmt"
-
-	"github.com/kaspanet/kaspad/domain"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
-	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-)
-
-// Manager manages the p2p protocol
-type Manager struct {
-	context *flowcontext.FlowContext
-}
-
-// NewManager creates a new instance of the p2p protocol manager
-func NewManager(cfg *config.Config, domain domain.Domain, netAdapter *netadapter.NetAdapter, addressManager *addressmanager.AddressManager,
-	connectionManager *connmanager.ConnectionManager) (*Manager, error) {
-
-	manager := Manager{
-		context: flowcontext.New(cfg, domain, addressManager, netAdapter, connectionManager),
-	}
-
-	netAdapter.SetP2PRouterInitializer(manager.routerInitializer)
-	return &manager, nil
-}
-
-// Peers returns the currently active peers
-func (m *Manager) Peers() []*peerpkg.Peer {
-	return m.context.Peers()
-}
-
-// IBDPeer returns the currently active IBD peer.
-// Returns nil if we aren't currently in IBD
-func (m *Manager) IBDPeer() *peerpkg.Peer {
-	return m.context.IBDPeer()
-}
-
-// AddTransaction adds transaction to the mempool and propagates it.
-func (m *Manager) AddTransaction(tx *externalapi.DomainTransaction) error {
-	return m.context.AddTransaction(tx)
-}
-
-// AddBlock adds the given block to the DAG and propagates it.
-func (m *Manager) AddBlock(block *externalapi.DomainBlock) error {
-	return m.context.AddBlock(block)
-}
-
-func (m *Manager) runFlows(flows []*flow, peer *peerpkg.Peer, errChan <-chan error) error {
-	for _, flow := range flows {
-		executeFunc := flow.executeFunc // extract to new variable so that it's not overwritten
-		spawn(fmt.Sprintf("flow-%s", flow.name), func() {
-			executeFunc(peer)
-		})
-	}
-
-	return <-errChan
-}
-
-// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
-func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowcontext.OnBlockAddedToDAGHandler) {
-	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
-}
-
-// SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
-func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler flowcontext.OnTransactionAddedToMempoolHandler) {
-	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)
-}

app/rpc/log.go

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

app/rpc/manager.go

@@ -1,62 +0,0 @@
-package rpc
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-)
-
-// Manager is an RPC manager
-type Manager struct {
-	context *rpccontext.Context
-}
-
-// NewManager creates a new RPC Manager
-func NewManager(
-	cfg *config.Config,
-	domain domain.Domain,
-	netAdapter *netadapter.NetAdapter,
-	protocolManager *protocol.Manager,
-	connectionManager *connmanager.ConnectionManager,
-	addressManager *addressmanager.AddressManager,
-	shutDownChan chan<- struct{}) *Manager {
-
-	manager := Manager{
-		context: rpccontext.NewContext(
-			cfg,
-			domain,
-			netAdapter,
-			protocolManager,
-			connectionManager,
-			addressManager,
-			shutDownChan,
-		),
-	}
-	netAdapter.SetRPCRouterInitializer(manager.routerInitializer)
-
-	return &manager
-}
-
-// NotifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
-func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock) error {
-	notification := appmessage.NewBlockAddedNotificationMessage(appmessage.DomainBlockToMsgBlock(block))
-	return m.context.NotificationManager.NotifyBlockAdded(notification)
-}
-
-// NotifyFinalityConflict notifies the manager that there's a finality conflict in the DAG
-func (m *Manager) NotifyFinalityConflict(violatingBlockHash string) error {
-	notification := appmessage.NewFinalityConflictNotificationMessage(violatingBlockHash)
-	return m.context.NotificationManager.NotifyFinalityConflict(notification)
-}
-
-// NotifyFinalityConflictResolved notifies the manager that a finality conflict in the DAG has been resolved
-func (m *Manager) NotifyFinalityConflictResolved(finalityBlockHash string) error {
-	notification := appmessage.NewFinalityConflictResolvedNotificationMessage(finalityBlockHash)
-	return m.context.NotificationManager.NotifyFinalityConflictResolved(notification)
-}

app/rpc/rpc.go

@@ -1,90 +0,0 @@
-package rpc
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/app/rpc/rpchandlers"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-type handler func(context *rpccontext.Context, router *router.Router, request appmessage.Message) (appmessage.Message, error)
-
-var handlers = map[appmessage.MessageCommand]handler{
-	appmessage.CmdGetCurrentNetworkRequestMessage:       rpchandlers.HandleGetCurrentNetwork,
-	appmessage.CmdSubmitBlockRequestMessage:             rpchandlers.HandleSubmitBlock,
-	appmessage.CmdGetBlockTemplateRequestMessage:        rpchandlers.HandleGetBlockTemplate,
-	appmessage.CmdNotifyBlockAddedRequestMessage:        rpchandlers.HandleNotifyBlockAdded,
-	appmessage.CmdGetPeerAddressesRequestMessage:        rpchandlers.HandleGetPeerAddresses,
-	appmessage.CmdGetSelectedTipHashRequestMessage:      rpchandlers.HandleGetSelectedTipHash,
-	appmessage.CmdGetMempoolEntryRequestMessage:         rpchandlers.HandleGetMempoolEntry,
-	appmessage.CmdGetConnectedPeerInfoRequestMessage:    rpchandlers.HandleGetConnectedPeerInfo,
-	appmessage.CmdAddPeerRequestMessage:                 rpchandlers.HandleAddPeer,
-	appmessage.CmdSubmitTransactionRequestMessage:       rpchandlers.HandleSubmitTransaction,
-	appmessage.CmdNotifyChainChangedRequestMessage:      rpchandlers.HandleNotifyChainChanged,
-	appmessage.CmdGetBlockRequestMessage:                rpchandlers.HandleGetBlock,
-	appmessage.CmdGetSubnetworkRequestMessage:           rpchandlers.HandleGetSubnetwork,
-	appmessage.CmdGetChainFromBlockRequestMessage:       rpchandlers.HandleGetChainFromBlock,
-	appmessage.CmdGetBlocksRequestMessage:               rpchandlers.HandleGetBlocks,
-	appmessage.CmdGetBlockCountRequestMessage:           rpchandlers.HandleGetBlockCount,
-	appmessage.CmdGetBlockDAGInfoRequestMessage:         rpchandlers.HandleGetBlockDAGInfo,
-	appmessage.CmdResolveFinalityConflictRequestMessage: rpchandlers.HandleResolveFinalityConflict,
-	appmessage.CmdNotifyFinalityConflictsRequestMessage: rpchandlers.HandleNotifyFinalityConflicts,
-	appmessage.CmdGetMempoolEntriesRequestMessage:       rpchandlers.HandleGetMempoolEntries,
-	appmessage.CmdShutDownRequestMessage:                rpchandlers.HandleGetMempoolEntries,
-	appmessage.CmdGetHeadersRequestMessage:              rpchandlers.HandleGetHeaders,
-}
-
-func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {
-	messageTypes := make([]appmessage.MessageCommand, 0, len(handlers))
-	for messageType := range handlers {
-		messageTypes = append(messageTypes, messageType)
-	}
-	incomingRoute, err := router.AddIncomingRoute(messageTypes)
-	if err != nil {
-		panic(err)
-	}
-	m.context.NotificationManager.AddListener(router)
-
-	spawn("routerInitializer-handleIncomingMessages", func() {
-		defer m.context.NotificationManager.RemoveListener(router)
-
-		err := m.handleIncomingMessages(router, incomingRoute)
-		m.handleError(err, netConnection)
-	})
-}
-
-func (m *Manager) handleIncomingMessages(router *router.Router, incomingRoute *router.Route) error {
-	outgoingRoute := router.OutgoingRoute()
-	for {
-		request, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		handler, ok := handlers[request.Command()]
-		if !ok {
-			return err
-		}
-		response, err := handler(m.context, router, request)
-		if err != nil {
-			return err
-		}
-		err = outgoingRoute.Enqueue(response)
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection) {
-	if errors.Is(err, router.ErrTimeout) {
-		log.Warnf("Got timeout from %s. Disconnecting...", netConnection)
-		netConnection.Disconnect()
-		return
-	}
-	if errors.Is(err, router.ErrRouteClosed) {
-		return
-	}
-	panic(err)
-}

app/rpc/rpccontext/context.go

@@ -1,45 +0,0 @@
-package rpccontext
-
-import (
-	"github.com/kaspanet/kaspad/app/protocol"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-)
-
-// Context represents the RPC context
-type Context struct {
-	Config            *config.Config
-	NetAdapter        *netadapter.NetAdapter
-	Domain            domain.Domain
-	ProtocolManager   *protocol.Manager
-	ConnectionManager *connmanager.ConnectionManager
-	AddressManager    *addressmanager.AddressManager
-	ShutDownChan      chan<- struct{}
-
-	NotificationManager *NotificationManager
-}
-
-// NewContext creates a new RPC context
-func NewContext(cfg *config.Config,
-	domain domain.Domain,
-	netAdapter *netadapter.NetAdapter,
-	protocolManager *protocol.Manager,
-	connectionManager *connmanager.ConnectionManager,
-	addressManager *addressmanager.AddressManager,
-	shutDownChan chan<- struct{}) *Context {
-
-	context := &Context{
-		Config:            cfg,
-		NetAdapter:        netAdapter,
-		Domain:            domain,
-		ProtocolManager:   protocolManager,
-		ConnectionManager: connectionManager,
-		AddressManager:    addressManager,
-		ShutDownChan:      shutDownChan,
-	}
-	context.NotificationManager = NewNotificationManager()
-	return context
-}

app/rpc/rpccontext/log.go

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

app/rpc/rpccontext/notificationmanager.go

@@ -1,155 +0,0 @@
-package rpccontext
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-	"sync"
-)
-
-// NotificationManager manages notifications for the RPC
-type NotificationManager struct {
-	sync.RWMutex
-	listeners map[*routerpkg.Router]*NotificationListener
-}
-
-// NotificationListener represents a registered RPC notification listener
-type NotificationListener struct {
-	propagateBlockAddedNotifications               bool
-	propagateChainChangedNotifications             bool
-	propagateFinalityConflictNotifications         bool
-	propagateFinalityConflictResolvedNotifications bool
-}
-
-// NewNotificationManager creates a new NotificationManager
-func NewNotificationManager() *NotificationManager {
-	return &NotificationManager{
-		listeners: make(map[*routerpkg.Router]*NotificationListener),
-	}
-}
-
-// AddListener registers a listener with the given router
-func (nm *NotificationManager) AddListener(router *routerpkg.Router) {
-	nm.Lock()
-	defer nm.Unlock()
-
-	listener := newNotificationListener()
-	nm.listeners[router] = listener
-}
-
-// RemoveListener unregisters the given router
-func (nm *NotificationManager) RemoveListener(router *routerpkg.Router) {
-	nm.Lock()
-	defer nm.Unlock()
-
-	delete(nm.listeners, router)
-}
-
-// Listener retrieves the listener registered with the given router
-func (nm *NotificationManager) Listener(router *routerpkg.Router) (*NotificationListener, error) {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	listener, ok := nm.listeners[router]
-	if !ok {
-		return nil, errors.Errorf("listener not found")
-	}
-	return listener, nil
-}
-
-// NotifyBlockAdded notifies the notification manager that a block has been added to the DAG
-func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAddedNotificationMessage) error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateBlockAddedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// NotifyChainChanged notifies the notification manager that the DAG's selected parent chain has changed
-func (nm *NotificationManager) NotifyChainChanged(notification *appmessage.ChainChangedNotificationMessage) error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateChainChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// NotifyFinalityConflict notifies the notification manager that there's a finality conflict in the DAG
-func (nm *NotificationManager) NotifyFinalityConflict(notification *appmessage.FinalityConflictNotificationMessage) error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateFinalityConflictNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// NotifyFinalityConflictResolved notifies the notification manager that a finality conflict in the DAG has been resolved
-func (nm *NotificationManager) NotifyFinalityConflictResolved(notification *appmessage.FinalityConflictResolvedNotificationMessage) error {
-	nm.RLock()
-	defer nm.RUnlock()
-
-	for router, listener := range nm.listeners {
-		if listener.propagateFinalityConflictResolvedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func newNotificationListener() *NotificationListener {
-	return &NotificationListener{
-		propagateBlockAddedNotifications:               false,
-		propagateChainChangedNotifications:             false,
-		propagateFinalityConflictNotifications:         false,
-		propagateFinalityConflictResolvedNotifications: false,
-	}
-}
-
-// PropagateBlockAddedNotifications instructs the listener to send block added notifications
-// to the remote listener
-func (nl *NotificationListener) PropagateBlockAddedNotifications() {
-	nl.propagateBlockAddedNotifications = true
-}
-
-// PropagateChainChangedNotifications instructs the listener to send chain changed notifications
-// to the remote listener
-func (nl *NotificationListener) PropagateChainChangedNotifications() {
-	nl.propagateChainChangedNotifications = true
-}
-
-// PropagateFinalityConflictNotifications instructs the listener to send finality conflict notifications
-// to the remote listener
-func (nl *NotificationListener) PropagateFinalityConflictNotifications() {
-	nl.propagateFinalityConflictNotifications = true
-}
-
-// PropagateFinalityConflictResolvedNotifications instructs the listener to send finality conflict resolved notifications
-// to the remote listener
-func (nl *NotificationListener) PropagateFinalityConflictResolvedNotifications() {
-	nl.propagateFinalityConflictResolvedNotifications = true
-}

app/rpc/rpccontext/verbosedata.go

@@ -1,185 +0,0 @@
-package rpccontext
-
-import (
-	"encoding/hex"
-	"fmt"
-	"math/big"
-	"strconv"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/estimatedsize"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/pointers"
-)
-
-// BuildBlockVerboseData builds a BlockVerboseData from the given block.
-// This method must be called with the DAG lock held for reads
-func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
-	hash := consensusserialization.BlockHash(block)
-	blockHeader := block.Header
-
-	result := &appmessage.BlockVerboseData{
-		Hash:                 hash.String(),
-		Version:              blockHeader.Version,
-		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version),
-		HashMerkleRoot:       blockHeader.HashMerkleRoot.String(),
-		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot.String(),
-		UTXOCommitment:       blockHeader.UTXOCommitment.String(),
-		ParentHashes:         externalapi.DomainHashesToStrings(blockHeader.ParentHashes),
-		Nonce:                blockHeader.Nonce,
-		Time:                 blockHeader.TimeInMilliseconds,
-		Bits:                 strconv.FormatInt(int64(blockHeader.Bits), 16),
-		Difficulty:           ctx.GetDifficultyRatio(blockHeader.Bits, ctx.Config.ActiveNetParams),
-	}
-
-	txIDs := make([]string, len(block.Transactions))
-	for i, tx := range block.Transactions {
-		txIDs[i] = consensusserialization.TransactionID(tx).String()
-	}
-	result.TxIDs = txIDs
-
-	if includeTransactionVerboseData {
-		transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
-		for i, tx := range block.Transactions {
-			txID := consensusserialization.TransactionID(tx).String()
-			data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
-			if err != nil {
-				return nil, err
-			}
-			transactionVerboseData[i] = data
-		}
-		result.TransactionVerboseData = transactionVerboseData
-	}
-
-	return result, nil
-}
-
-// GetDifficultyRatio returns the proof-of-work difficulty as a multiple of the
-// minimum difficulty using the passed bits field from the header of a block.
-func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) float64 {
-	// The minimum difficulty is the max possible proof-of-work limit bits
-	// converted back to a number. Note this is not the same as the proof of
-	// work limit directly because the block difficulty is encoded in a block
-	// with the compact form which loses precision.
-	target := util.CompactToBig(bits)
-
-	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
-	outString := difficulty.FloatString(8)
-	diff, err := strconv.ParseFloat(outString, 64)
-	if err != nil {
-		log.Errorf("Cannot get difficulty: %s", err)
-		return 0
-	}
-	return diff
-}
-
-// BuildTransactionVerboseData builds a TransactionVerboseData from
-// the given parameters
-func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransaction, txID string,
-	blockHeader *externalapi.DomainBlockHeader, blockHash string) (
-	*appmessage.TransactionVerboseData, error) {
-
-	var payloadHash string
-	if tx.SubnetworkID != subnetworks.SubnetworkIDNative {
-		payloadHash = tx.PayloadHash.String()
-	}
-
-	txReply := &appmessage.TransactionVerboseData{
-		TxID:                      txID,
-		Hash:                      consensusserialization.TransactionHash(tx).String(),
-		Size:                      estimatedsize.TransactionEstimatedSerializedSize(tx),
-		TransactionVerboseInputs:  ctx.buildTransactionVerboseInputs(tx),
-		TransactionVerboseOutputs: ctx.buildTransactionVerboseOutputs(tx, nil),
-		Version:                   tx.Version,
-		LockTime:                  tx.LockTime,
-		SubnetworkID:              tx.SubnetworkID.String(),
-		Gas:                       tx.Gas,
-		PayloadHash:               payloadHash,
-		Payload:                   hex.EncodeToString(tx.Payload),
-	}
-
-	if blockHeader != nil {
-		txReply.Time = uint64(blockHeader.TimeInMilliseconds)
-		txReply.BlockTime = uint64(blockHeader.TimeInMilliseconds)
-		txReply.BlockHash = blockHash
-	}
-
-	return txReply, nil
-}
-
-func (ctx *Context) buildTransactionVerboseInputs(tx *externalapi.DomainTransaction) []*appmessage.TransactionVerboseInput {
-	inputs := make([]*appmessage.TransactionVerboseInput, len(tx.Inputs))
-	for i, transactionInput := range tx.Inputs {
-		// The disassembled string will contain [error] inline
-		// if the script doesn't fully parse, so ignore the
-		// error here.
-		disbuf, _ := txscript.DisasmString(transactionInput.SignatureScript)
-
-		input := &appmessage.TransactionVerboseInput{}
-		input.TxID = transactionInput.PreviousOutpoint.TransactionID.String()
-		input.OutputIndex = transactionInput.PreviousOutpoint.Index
-		input.Sequence = transactionInput.Sequence
-		input.ScriptSig = &appmessage.ScriptSig{
-			Asm: disbuf,
-			Hex: hex.EncodeToString(transactionInput.SignatureScript),
-		}
-		inputs[i] = input
-	}
-
-	return inputs
-}
-
-// buildTransactionVerboseOutputs returns a slice of JSON objects for the outputs of the passed
-// transaction.
-func (ctx *Context) buildTransactionVerboseOutputs(tx *externalapi.DomainTransaction, filterAddrMap map[string]struct{}) []*appmessage.TransactionVerboseOutput {
-	outputs := make([]*appmessage.TransactionVerboseOutput, len(tx.Outputs))
-	for i, transactionOutput := range tx.Outputs {
-		// The disassembled string will contain [error] inline if the
-		// script doesn't fully parse, so ignore the error here.
-		disbuf, _ := txscript.DisasmString(transactionOutput.ScriptPublicKey)
-
-		// Ignore the error here since an error means the script
-		// couldn't parse and there is no additional information about
-		// it anyways.
-		scriptClass, addr, _ := txscript.ExtractScriptPubKeyAddress(
-			transactionOutput.ScriptPublicKey, ctx.Config.ActiveNetParams)
-
-		// Encode the addresses while checking if the address passes the
-		// filter when needed.
-		passesFilter := len(filterAddrMap) == 0
-		var encodedAddr string
-		if addr != nil {
-			encodedAddr = *pointers.String(addr.EncodeAddress())
-
-			// If the filter doesn't already pass, make it pass if
-			// the address exists in the filter.
-			if _, exists := filterAddrMap[encodedAddr]; exists {
-				passesFilter = true
-			}
-		}
-
-		if !passesFilter {
-			continue
-		}
-
-		output := &appmessage.TransactionVerboseOutput{}
-		output.Index = uint32(i)
-		output.Value = transactionOutput.Value
-		output.ScriptPubKey = &appmessage.ScriptPubKeyResult{
-			Address: encodedAddr,
-			Asm:     disbuf,
-			Hex:     hex.EncodeToString(transactionOutput.ScriptPublicKey),
-			Type:    scriptClass.String(),
-		}
-		outputs[i] = output
-	}
-
-	return outputs
-}

app/rpc/rpchandlers/add_peer.go

@@ -1,24 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/network"
-)
-
-// HandleAddPeer handles the respectively named RPC command
-func HandleAddPeer(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	AddPeerRequest := request.(*appmessage.AddPeerRequestMessage)
-	address, err := network.NormalizeAddress(AddPeerRequest.Address, context.Config.ActiveNetParams.DefaultPort)
-	if err != nil {
-		errorMessage := &appmessage.AddPeerResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not parse address: %s", err)
-		return errorMessage, nil
-	}
-
-	context.ConnectionManager.AddConnectionRequest(address, AddPeerRequest.IsPermanent)
-
-	response := appmessage.NewAddPeerResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/get_block.go

@@ -1,38 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetBlock handles the respectively named RPC command
-func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	getBlockRequest := request.(*appmessage.GetBlockRequestMessage)
-
-	// Load the raw block bytes from the database.
-	hash, err := hashes.FromString(getBlockRequest.Hash)
-	if err != nil {
-		errorMessage := &appmessage.GetBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Hash could not be parsed: %s", err)
-		return errorMessage, nil
-	}
-
-	block, err := context.Domain.Consensus().GetBlock(hash)
-	if err != nil {
-		errorMessage := &appmessage.GetBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Block %s not found", hash)
-		return errorMessage, nil
-	}
-
-	response := appmessage.NewGetBlockResponseMessage()
-
-	blockVerboseData, err := context.BuildBlockVerboseData(block, getBlockRequest.IncludeTransactionVerboseData)
-	if err != nil {
-		return nil, err
-	}
-	response.BlockVerboseData = blockVerboseData
-
-	return response, nil
-}

app/rpc/rpchandlers/get_block_count.go

@@ -1,13 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetBlockCount handles the respectively named RPC command
-func HandleGetBlockCount(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	response := appmessage.NewGetBlockCountResponseMessage(0) // TODO
-	return response, nil
-}

app/rpc/rpchandlers/get_block_dag_info.go

@@ -1,17 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetBlockDAGInfo handles the respectively named RPC command
-func HandleGetBlockDAGInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	params := context.Config.ActiveNetParams
-
-	response := appmessage.NewGetBlockDAGInfoResponseMessage()
-	response.NetworkName = params.Name
-
-	return response, nil
-}

app/rpc/rpchandlers/get_block_template.go

@@ -1,33 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-)
-
-// HandleGetBlockTemplate handles the respectively named RPC command
-func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	getBlockTemplateRequest := request.(*appmessage.GetBlockTemplateRequestMessage)
-
-	payAddress, err := util.DecodeAddress(getBlockTemplateRequest.PayAddress, context.Config.ActiveNetParams.Prefix)
-	if err != nil {
-		errorMessage := &appmessage.GetBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not decode address: %s", err)
-		return errorMessage, nil
-	}
-
-	scriptPublicKey, err := txscript.PayToAddrScript(payAddress)
-	if err != nil {
-		return nil, err
-	}
-
-	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey}
-
-	templateBlock := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
-
-	return appmessage.DomainBlockToMsgBlock(templateBlock), nil
-}

app/rpc/rpchandlers/get_blocks.go

@@ -1,19 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-const (
-	// maxBlocksInGetBlocksResponse is the max amount of blocks that are
-	// allowed in a GetBlocksResult.
-	maxBlocksInGetBlocksResponse = 100
-)
-
-// HandleGetBlocks handles the respectively named RPC command
-func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-
-	return nil, nil
-}

app/rpc/rpchandlers/get_chain_from_block.go

@@ -1,18 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-const (
-	// maxBlocksInGetChainFromBlockResponse is the max amount of blocks that
-	// are allowed in a GetChainFromBlockResponse.
-	maxBlocksInGetChainFromBlockResponse = 1000
-)
-
-// HandleGetChainFromBlock handles the respectively named RPC command
-func HandleGetChainFromBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/get_connected_peer_info.go

@@ -1,31 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetConnectedPeerInfo handles the respectively named RPC command
-func HandleGetConnectedPeerInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	peers := context.ProtocolManager.Peers()
-	ibdPeer := context.ProtocolManager.IBDPeer()
-	infos := make([]*appmessage.GetConnectedPeerInfoMessage, 0, len(peers))
-	for _, peer := range peers {
-		info := &appmessage.GetConnectedPeerInfoMessage{
-			ID:                        peer.ID().String(),
-			Address:                   peer.Address(),
-			LastPingDuration:          peer.LastPingDuration().Milliseconds(),
-			SelectedTipHash:           peer.SelectedTipHash().String(),
-			IsSyncNode:                peer == ibdPeer,
-			IsOutbound:                peer.IsOutbound(),
-			TimeOffset:                peer.TimeOffset().Milliseconds(),
-			UserAgent:                 peer.UserAgent(),
-			AdvertisedProtocolVersion: peer.AdvertisedProtocolVersion(),
-			TimeConnected:             peer.TimeConnected().Milliseconds(),
-		}
-		infos = append(infos, info)
-	}
-	response := appmessage.NewGetConnectedPeerInfoResponseMessage(infos)
-	return response, nil
-}

app/rpc/rpchandlers/get_current_network.go

@@ -1,13 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetCurrentNetwork handles the respectively named RPC command
-func HandleGetCurrentNetwork(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	response := appmessage.NewGetCurrentNetworkResponseMessage(context.Config.ActiveNetParams.Net.String())
-	return response, nil
-}

app/rpc/rpchandlers/get_headers.go

@@ -1,12 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetHeaders handles the respectively named RPC command
-func HandleGetHeaders(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/get_mempool_entries.go

@@ -1,12 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetMempoolEntries handles the respectively named RPC command
-func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/get_mempool_entry.go

@@ -1,12 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetMempoolEntry handles the respectively named RPC command
-func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/get_peer_addresses.go

@@ -1,21 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetPeerAddresses handles the respectively named RPC command
-func HandleGetPeerAddresses(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	peersState, err := context.AddressManager.PeersStateForSerialization()
-	if err != nil {
-		return nil, err
-	}
-	addresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(peersState.Addresses))
-	for i, address := range peersState.Addresses {
-		addresses[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: string(address.Address)}
-	}
-	response := appmessage.NewGetPeerAddressesResponseMessage(addresses)
-	return response, nil
-}

app/rpc/rpchandlers/get_selected_tip_hash.go

@@ -1,21 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetSelectedTipHash handles the respectively named RPC command
-func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	selectedTip, err := context.Domain.Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return nil, err
-	}
-
-	response := appmessage.NewGetSelectedTipHashResponseMessage(
-		consensusserialization.BlockHash(selectedTip).String())
-
-	return response, nil
-}

app/rpc/rpchandlers/get_subnetwork.go

@@ -1,12 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleGetSubnetwork handles the respectively named RPC command
-func HandleGetSubnetwork(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/log.go

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

app/rpc/rpchandlers/notify_block_added.go

@@ -1,19 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleNotifyBlockAdded handles the respectively named RPC command
-func HandleNotifyBlockAdded(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	listener, err := context.NotificationManager.Listener(router)
-	if err != nil {
-		return nil, err
-	}
-	listener.PropagateBlockAddedNotifications()
-
-	response := appmessage.NewNotifyBlockAddedResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/notify_chain_changed.go

@@ -1,19 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleNotifyChainChanged handles the respectively named RPC command
-func HandleNotifyChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	listener, err := context.NotificationManager.Listener(router)
-	if err != nil {
-		return nil, err
-	}
-	listener.PropagateChainChangedNotifications()
-
-	response := appmessage.NewNotifyChainChangedResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/notify_finality_conflicts.go

@@ -1,20 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleNotifyFinalityConflicts handles the respectively named RPC command
-func HandleNotifyFinalityConflicts(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	listener, err := context.NotificationManager.Listener(router)
-	if err != nil {
-		return nil, err
-	}
-	listener.PropagateFinalityConflictNotifications()
-	listener.PropagateFinalityConflictResolvedNotifications()
-
-	response := appmessage.NewNotifyFinalityConflictsResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/resolve_finality_conflict.go

@@ -1,12 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleResolveFinalityConflict handles the respectively named RPC command
-func HandleResolveFinalityConflict(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
-}

app/rpc/rpchandlers/shut_down.go

@@ -1,25 +0,0 @@
-package rpchandlers
-
-import (
-	"time"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-const pauseBeforeShutDown = time.Second
-
-// HandleShutDown handles the respectively named RPC command
-func HandleShutDown(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	log.Warn("ShutDown RPC called.")
-
-	// Wait a second before shutting down, to allow time to return the response to the caller
-	spawn("HandleShutDown-pauseAndShutDown", func() {
-		<-time.After(pauseBeforeShutDown)
-		close(context.ShutDownChan)
-	})
-
-	response := appmessage.NewShutDownResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/submit_block.go

@@ -1,28 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleSubmitBlock handles the respectively named RPC command
-func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	submitBlockRequest := request.(*appmessage.SubmitBlockRequestMessage)
-
-	msgBlock := submitBlockRequest.Block
-	domainBlock := appmessage.MsgBlockToDomainBlock(msgBlock)
-
-	err := context.ProtocolManager.AddBlock(domainBlock)
-	if err != nil {
-		errorMessage := &appmessage.SubmitBlockResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Block rejected. Reason: %s", err)
-		return errorMessage, nil
-	}
-
-	log.Infof("Accepted domainBlock %s via submitBlock", consensusserialization.BlockHash(domainBlock))
-
-	response := appmessage.NewSubmitBlockResponseMessage()
-	return response, nil
-}

app/rpc/rpchandlers/submit_transaction.go

@@ -1,32 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// HandleSubmitTransaction handles the respectively named RPC command
-func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	submitTransactionRequest := request.(*appmessage.SubmitTransactionRequestMessage)
-
-	domainTransaction := appmessage.MsgTxToDomainTransaction(submitTransactionRequest.Transaction)
-	transactionID := consensusserialization.TransactionID(domainTransaction)
-	err := context.ProtocolManager.AddTransaction(domainTransaction)
-	if err != nil {
-		if !errors.As(err, &mempool.RuleError{}) {
-			return nil, err
-		}
-
-		log.Debugf("Rejected transaction %s: %s", transactionID, err)
-		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Rejected transaction %s: %s", transactionID, err)
-		return errorMessage, nil
-	}
-
-	response := appmessage.NewSubmitTransactionResponseMessage(transactionID.String())
-	return response, nil
-}

blockdag/README.md

@@ -0,0 +1,41 @@
+blockchain
+==========
+
+[![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/blockchain)
+
+Package blockdag implements Kaspa block handling, organization of the blockDAG, 
+block sorting and UTXO-set maintenance.
+The test coverage is currently only around 75%, but will be increasing over
+time.
+
+## Kaspad BlockDAG Processing Overview
+
+Before a block is allowed into the block DAG, it must go through an intensive
+series of validation rules. The following list serves as a general outline of
+those rules to provide some intuition into what is going on under the hood, but
+is by no means exhaustive:
+
+ - Reject duplicate blocks
+ - Perform a series of sanity checks on the block and its transactions such as
+   verifying proof of work, timestamps, number and character of transactions,
+   transaction amounts, script complexity, and merkle root calculations
+ - Save the most recent orphan blocks for a limited time in case their parent
+   blocks become available.
+ - Save blocks from the future for delayed processing
+ - Stop processing if the block is an orphan or delayed as the rest of the 
+   processing depends on the block's position within the block chain
+ - Make sure the block does not violate finality rules
+ - Perform a series of more thorough checks that depend on the block's position
+   within the blockDAG such as verifying block difficulties adhere to
+   difficulty retarget rules, timestamps are after the median of the last
+   several blocks, all transactions are finalized, checkpoint blocks match, and
+   block versions are in line with the previous blocks
+ - Determine how the block fits into the DAG and perform different actions
+   accordingly 
+ - Run the transaction scripts to verify the spender is allowed to spend the
+   coins
+ - Run GhostDAG to fit the block in a canonical sorting
+ - Build the block's UTXO Set, as well as update the global UTXO Set accordingly
+ - Insert the block into the block database
+

blockdag/accept.go

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

blockdag/accept_test.go

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

blockdag/blockheap.go

@@ -0,0 +1,78 @@
+package blockdag
+
+import (
+	"container/heap"
+)
+
+// baseHeap is an implementation for heap.Interface that sorts blocks by their height
+type baseHeap []*blockNode
+
+func (h baseHeap) Len() int      { return len(h) }
+func (h baseHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
+
+func (h *baseHeap) Push(x interface{}) {
+	*h = append(*h, x.(*blockNode))
+}
+
+func (h *baseHeap) Pop() interface{} {
+	oldHeap := *h
+	oldLength := len(oldHeap)
+	popped := oldHeap[oldLength-1]
+	*h = oldHeap[0 : oldLength-1]
+	return popped
+}
+
+// upHeap extends baseHeap to include Less operation that traverses from bottom to top
+type upHeap struct{ baseHeap }
+
+func (h upHeap) Less(i, j int) bool {
+	return h.baseHeap[i].less(h.baseHeap[j])
+}
+
+// downHeap extends baseHeap to include Less operation that traverses from top to bottom
+type downHeap struct{ baseHeap }
+
+func (h downHeap) Less(i, j int) bool {
+	return !h.baseHeap[i].less(h.baseHeap[j])
+}
+
+// blockHeap represents a mutable heap of Blocks, sorted by their height
+type blockHeap struct {
+	impl heap.Interface
+}
+
+// newDownHeap initializes and returns a new blockHeap
+func newDownHeap() blockHeap {
+	h := blockHeap{impl: &downHeap{}}
+	heap.Init(h.impl)
+	return h
+}
+
+// newUpHeap initializes and returns a new blockHeap
+func newUpHeap() blockHeap {
+	h := blockHeap{impl: &upHeap{}}
+	heap.Init(h.impl)
+	return h
+}
+
+// pop removes the block with lowest height from this heap and returns it
+func (bh blockHeap) pop() *blockNode {
+	return heap.Pop(bh.impl).(*blockNode)
+}
+
+// Push pushes the block onto the heap
+func (bh blockHeap) Push(block *blockNode) {
+	heap.Push(bh.impl, block)
+}
+
+// pushSet pushes a blockset to the heap.
+func (bh blockHeap) pushSet(bs blockSet) {
+	for block := range bs {
+		heap.Push(bh.impl, block)
+	}
+}
+
+// Len returns the length of this heap
+func (bh blockHeap) Len() int {
+	return bh.impl.Len()
+}

blockdag/blockheap_test.go

@@ -0,0 +1,129 @@
+package blockdag
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestBlockHeap tests pushing, popping, and determining the length of the heap.
+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.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestBlockHeap: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	block0Header := dagconfig.SimnetParams.GenesisBlock.Header
+	block0, _ := dag.newBlockNode(&block0Header, newBlockSet())
+
+	block100000Header := Block100000.Header
+	block100000, _ := dag.newBlockNode(&block100000Header, blockSetFromSlice(block0))
+
+	block0smallHash, _ := dag.newBlockNode(&block0Header, newBlockSet())
+	block0smallHash.hash = &daghash.Hash{}
+
+	tests := []struct {
+		name            string
+		toPush          []*blockNode
+		expectedLength  int
+		expectedPopUp   *blockNode
+		expectedPopDown *blockNode
+	}{
+		{
+			name:            "empty heap must have length 0",
+			toPush:          []*blockNode{},
+			expectedLength:  0,
+			expectedPopDown: nil,
+			expectedPopUp:   nil,
+		},
+		{
+			name:            "heap with one push must have length 1",
+			toPush:          []*blockNode{block0},
+			expectedLength:  1,
+			expectedPopDown: nil,
+			expectedPopUp:   nil,
+		},
+		{
+			name:            "heap with one push and one pop",
+			toPush:          []*blockNode{block0},
+			expectedLength:  0,
+			expectedPopDown: block0,
+			expectedPopUp:   block0,
+		},
+		{
+			name: "push two blocks with different heights, heap shouldn't have to rebalance " +
+				"for down direction, but will have to rebalance for up direction",
+			toPush:          []*blockNode{block100000, block0},
+			expectedLength:  1,
+			expectedPopDown: block100000,
+			expectedPopUp:   block0,
+		},
+		{
+			name: "push two blocks with different heights, heap shouldn't have to rebalance " +
+				"for up direction, but will have to rebalance for down direction",
+			toPush:          []*blockNode{block0, block100000},
+			expectedLength:  1,
+			expectedPopDown: block100000,
+			expectedPopUp:   block0,
+		},
+		{
+			name: "push two blocks with equal heights but different hashes, heap shouldn't have to rebalance " +
+				"for down direction, but will have to rebalance for up direction",
+			toPush:          []*blockNode{block0, block0smallHash},
+			expectedLength:  1,
+			expectedPopDown: block0,
+			expectedPopUp:   block0smallHash,
+		},
+		{
+			name: "push two blocks with equal heights but different hashes, heap shouldn't have to rebalance " +
+				"for up direction, but will have to rebalance for down direction",
+			toPush:          []*blockNode{block0smallHash, block0},
+			expectedLength:  1,
+			expectedPopDown: block0,
+			expectedPopUp:   block0smallHash,
+		},
+	}
+
+	for _, test := range tests {
+		dHeap := newDownHeap()
+		for _, block := range test.toPush {
+			dHeap.Push(block)
+		}
+
+		var poppedBlock *blockNode
+		if test.expectedPopDown != nil {
+			poppedBlock = dHeap.pop()
+		}
+		if dHeap.Len() != test.expectedLength {
+			t.Errorf("unexpected down heap length in test \"%s\". "+
+				"Expected: %v, got: %v", test.name, test.expectedLength, dHeap.Len())
+		}
+		if poppedBlock != test.expectedPopDown {
+			t.Errorf("unexpected popped block for down heap in test \"%s\". "+
+				"Expected: %v, got: %v", test.name, test.expectedPopDown, poppedBlock)
+		}
+
+		uHeap := newUpHeap()
+		for _, block := range test.toPush {
+			uHeap.Push(block)
+		}
+
+		poppedBlock = nil
+		if test.expectedPopUp != nil {
+			poppedBlock = uHeap.pop()
+		}
+		if uHeap.Len() != test.expectedLength {
+			t.Errorf("unexpected up heap length in test \"%s\". "+
+				"Expected: %v, got: %v", test.name, test.expectedLength, uHeap.Len())
+		}
+		if poppedBlock != test.expectedPopUp {
+			t.Errorf("unexpected popped block for up heap in test \"%s\". "+
+				"Expected: %v, got: %v", test.name, test.expectedPopDown, poppedBlock)
+		}
+	}
+}

blockdag/blockindex.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2015-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockdag
+
+import (
+	"github.com/kaspanet/kaspad/dbaccess"
+	"sync"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// blockIndex provides facilities for keeping track of an in-memory index of the
+// block DAG.
+type blockIndex 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
+
+	sync.RWMutex
+	index map[daghash.Hash]*blockNode
+	dirty map[*blockNode]struct{}
+}
+
+// newBlockIndex returns a new empty instance of a block index. The index will
+// be dynamically populated as block nodes are loaded from the database and
+// manually added.
+func newBlockIndex(dagParams *dagconfig.Params) *blockIndex {
+	return &blockIndex{
+		dagParams: dagParams,
+		index:     make(map[daghash.Hash]*blockNode),
+		dirty:     make(map[*blockNode]struct{}),
+	}
+}
+
+// HaveBlock returns whether or not the block index contains the provided hash.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) HaveBlock(hash *daghash.Hash) bool {
+	bi.RLock()
+	defer bi.RUnlock()
+	_, hasBlock := bi.index[*hash]
+	return hasBlock
+}
+
+// LookupNode returns the block node identified by the provided hash. It will
+// 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, bool) {
+	bi.RLock()
+	defer bi.RUnlock()
+	node, ok := bi.index[*hash]
+	return node, ok
+}
+
+// AddNode adds the provided node to the block index and marks it as dirty.
+// Duplicate entries are not checked so it is up to caller to avoid adding them.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) AddNode(node *blockNode) {
+	bi.Lock()
+	defer bi.Unlock()
+	bi.addNode(node)
+	bi.dirty[node] = struct{}{}
+}
+
+// addNode adds the provided node to the block index, but does not mark it as
+// dirty. This can be used while initializing the block index.
+//
+// This function is NOT safe for concurrent access.
+func (bi *blockIndex) addNode(node *blockNode) {
+	bi.index[*node.hash] = node
+}
+
+// NodeStatus provides concurrent-safe access to the status field of a node.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) NodeStatus(node *blockNode) blockStatus {
+	bi.RLock()
+	defer bi.RUnlock()
+	status := node.status
+	return status
+}
+
+// SetStatusFlags flips the provided status flags on the block node to on,
+// regardless of whether they were on or off previously. This does not unset any
+// flags currently on.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) SetStatusFlags(node *blockNode, flags blockStatus) {
+	bi.Lock()
+	defer bi.Unlock()
+	node.status |= flags
+	bi.dirty[node] = struct{}{}
+}
+
+// UnsetStatusFlags flips the provided status flags on the block node to off,
+// regardless of whether they were on or off previously.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) UnsetStatusFlags(node *blockNode, flags blockStatus) {
+	bi.Lock()
+	defer bi.Unlock()
+	node.status &^= flags
+	bi.dirty[node] = struct{}{}
+}
+
+// flushToDB writes all dirty block nodes to the database.
+func (bi *blockIndex) flushToDB(dbContext *dbaccess.TxContext) error {
+	bi.Lock()
+	defer bi.Unlock()
+	if len(bi.dirty) == 0 {
+		return nil
+	}
+
+	for node := range bi.dirty {
+		serializedBlockNode, err := serializeBlockNode(node)
+		if err != nil {
+			return err
+		}
+		key := blockIndexKey(node.hash, node.blueScore)
+		err = dbaccess.StoreIndexBlock(dbContext, key, serializedBlockNode)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (bi *blockIndex) clearDirtyEntries() {
+	bi.dirty = make(map[*blockNode]struct{})
+}

blockdag/blockindex_test.go

@@ -0,0 +1,26 @@
+package blockdag
+
+import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"testing"
+)
+
+func TestAncestorErrors(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	params := dagconfig.SimnetParams
+	dag, teardownFunc, err := DAGSetup("TestAncestorErrors", true, Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("TestAncestorErrors: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	node := newTestNode(dag, newBlockSet(), int32(0x10000000), 0, mstime.Now())
+	node.blueScore = 2
+	ancestor := node.SelectedAncestor(3)
+	if ancestor != nil {
+		t.Errorf("TestAncestorErrors: Ancestor() unexpectedly returned a node. Expected: <nil>")
+	}
+}

blockdag/blocklocator.go

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

blockdag/blocknode.go

@@ -0,0 +1,237 @@
+// Copyright (c) 2015-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockdag
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
+
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// blockStatus is a bit field representing the validation state of the block.
+type blockStatus byte
+
+const (
+	// statusDataStored indicates that the block's payload is stored on disk.
+	statusDataStored blockStatus = 1 << iota
+
+	// statusValid indicates that the block has been fully validated.
+	statusValid
+
+	// statusValidateFailed indicates that the block has failed validation.
+	statusValidateFailed
+
+	// statusInvalidAncestor indicates that one of the block's ancestors has
+	// has failed validation, thus the block is also invalid.
+	statusInvalidAncestor
+)
+
+// KnownValid returns whether the block is known to be valid. This will return
+// false for a valid block that has not been fully validated yet.
+func (status blockStatus) KnownValid() bool {
+	return status&statusValid != 0
+}
+
+// KnownInvalid returns whether the block is known to be invalid. This may be
+// because the block itself failed validation or any of its ancestors is
+// invalid. This will return false for invalid blocks that have not been proven
+// invalid yet.
+func (status blockStatus) KnownInvalid() bool {
+	return status&(statusValidateFailed|statusInvalidAncestor) != 0
+}
+
+// blockNode represents a block within the block DAG. The DAG is stored into
+// the block database.
+type blockNode struct {
+	// NOTE: Additions, deletions, or modifications to the order of the
+	// definitions in this struct should not be changed without considering
+	// how it affects alignment on 64-bit platforms. The current order is
+	// specifically crafted to result in minimal padding. There will be
+	// hundreds of thousands of these in memory, so a few extra bytes of
+	// padding adds up.
+
+	// parents is the parent blocks for this node.
+	parents blockSet
+
+	// selectedParent is the selected parent for this node.
+	// The selected parent is the parent that if chosen will maximize the blue score of this block
+	selectedParent *blockNode
+
+	// children are all the blocks that refer to this block as a parent
+	children blockSet
+
+	// blues are all blue blocks in this block's worldview that are in its selected parent anticone
+	blues []*blockNode
+
+	// blueScore is the count of all the blue blocks in this block's past
+	blueScore uint64
+
+	// bluesAnticoneSizes is a map holding the set of blues affected by this block and their
+	// modified blue anticone size.
+	bluesAnticoneSizes map[*blockNode]dagconfig.KType
+
+	// hash is the double sha 256 of the block.
+	hash *daghash.Hash
+
+	// Some fields from block headers to aid in  reconstructing headers
+	// from memory. These must be treated as immutable and are intentionally
+	// ordered to avoid padding on 64-bit platforms.
+	version              int32
+	bits                 uint32
+	nonce                uint64
+	timestamp            int64
+	hashMerkleRoot       *daghash.Hash
+	acceptedIDMerkleRoot *daghash.Hash
+	utxoCommitment       *daghash.Hash
+
+	// status is a bitfield representing the validation state of the block. The
+	// status field, unlike the other fields, may be written to and so should
+	// only be accessed using the concurrent-safe NodeStatus method on
+	// blockIndex once the node has been added to the global index.
+	status blockStatus
+
+	// isFinalized determines whether the node is below the finality point.
+	isFinalized bool
+}
+
+// newBlockNode returns a new block node for the given block header and parents, and the
+// anticone of its selected parent (parent with highest blue score).
+// selectedParentAnticone is used to update reachability data we store for future reachability queries.
+// This function is NOT safe for concurrent access.
+func (dag *BlockDAG) newBlockNode(blockHeader *domainmessage.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
+	node = &blockNode{
+		parents:            parents,
+		children:           make(blockSet),
+		blueScore:          math.MaxUint64, // Initialized to the max value to avoid collisions with the genesis block
+		timestamp:          dag.Now().UnixMilliseconds(),
+		bluesAnticoneSizes: make(map[*blockNode]dagconfig.KType),
+	}
+
+	// blockHeader is nil only for the virtual block
+	if blockHeader != nil {
+		node.hash = blockHeader.BlockHash()
+		node.version = blockHeader.Version
+		node.bits = blockHeader.Bits
+		node.nonce = blockHeader.Nonce
+		node.timestamp = blockHeader.Timestamp.UnixMilliseconds()
+		node.hashMerkleRoot = blockHeader.HashMerkleRoot
+		node.acceptedIDMerkleRoot = blockHeader.AcceptedIDMerkleRoot
+		node.utxoCommitment = blockHeader.UTXOCommitment
+	} else {
+		node.hash = &daghash.ZeroHash
+	}
+
+	if len(parents) == 0 {
+		// The genesis block is defined to have a blueScore of 0
+		node.blueScore = 0
+		return node, nil
+	}
+
+	selectedParentAnticone, err := dag.ghostdag(node)
+	if err != nil {
+		panic(errors.Wrap(err, "unexpected error in GHOSTDAG"))
+	}
+	return node, selectedParentAnticone
+}
+
+// updateParentsChildren updates the node's parents to point to new node
+func (node *blockNode) updateParentsChildren() {
+	for parent := range node.parents {
+		parent.children.add(node)
+	}
+}
+
+func (node *blockNode) less(other *blockNode) bool {
+	if node.blueScore == other.blueScore {
+		return daghash.Less(node.hash, other.hash)
+	}
+
+	return node.blueScore < other.blueScore
+}
+
+// Header constructs a block header from the node and returns it.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) Header() *domainmessage.BlockHeader {
+	// No lock is needed because all accessed fields are immutable.
+	return &domainmessage.BlockHeader{
+		Version:              node.version,
+		ParentHashes:         node.ParentHashes(),
+		HashMerkleRoot:       node.hashMerkleRoot,
+		AcceptedIDMerkleRoot: node.acceptedIDMerkleRoot,
+		UTXOCommitment:       node.utxoCommitment,
+		Timestamp:            node.time(),
+		Bits:                 node.bits,
+		Nonce:                node.nonce,
+	}
+}
+
+// SelectedAncestor returns the ancestor block node at the provided blue score by following
+// the selected-parents chain backwards from this node. The returned block will be nil when a
+// blue score is requested that is higher than the blue score of the passed node.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) SelectedAncestor(blueScore uint64) *blockNode {
+	if blueScore > node.blueScore {
+		return nil
+	}
+
+	n := node
+	for n != nil && n.blueScore > blueScore {
+		n = n.selectedParent
+	}
+
+	return n
+}
+
+// RelativeAncestor returns the ancestor block node a relative 'distance' of
+// blue blocks before this node. This is equivalent to calling Ancestor with
+// the node's blue score minus provided distance.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) RelativeAncestor(distance uint64) *blockNode {
+	return node.SelectedAncestor(node.blueScore - distance)
+}
+
+// CalcPastMedianTime returns the median time of the previous few blocks
+// prior to, and including, the block node.
+//
+// This function is safe for concurrent access.
+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 mstime.UnixMilliseconds(medianTimestamp)
+}
+
+func (node *blockNode) ParentHashes() []*daghash.Hash {
+	return node.parents.hashes()
+}
+
+// isGenesis returns if the current block is the genesis block
+func (node *blockNode) isGenesis() bool {
+	return len(node.parents) == 0
+}
+
+func (node *blockNode) finalityScore(dag *BlockDAG) uint64 {
+	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/blocknode_test.go

@@ -0,0 +1,41 @@
+package blockdag
+
+import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"testing"
+)
+
+// This test is to ensure the size BlueAnticoneSizesSize is serialized to the size of KType.
+// We verify that by serializing and deserializing the block while making sure that we stay within the expected range.
+func TestBlueAnticoneSizesSize(t *testing.T) {
+	dag, teardownFunc, err := DAGSetup("TestBlueAnticoneSizesSize", true, Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestBlueAnticoneSizesSize: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	k := dagconfig.KType(0)
+	k--
+
+	if k < dagconfig.KType(0) {
+		t.Fatalf("KType must be unsigned")
+	}
+
+	blockHeader := dagconfig.SimnetParams.GenesisBlock.Header
+	node, _ := dag.newBlockNode(&blockHeader, newBlockSet())
+	fakeBlue := &blockNode{hash: &daghash.Hash{1}}
+	dag.index.AddNode(fakeBlue)
+	// Setting maxKType to maximum value of KType.
+	// As we verify above that KType is unsigned we can be sure that maxKType is indeed the maximum value of KType.
+	maxKType := ^dagconfig.KType(0)
+	node.bluesAnticoneSizes[fakeBlue] = maxKType
+	serializedNode, _ := serializeBlockNode(node)
+	deserializedNode, _ := dag.deserializeBlockNode(serializedNode)
+	if deserializedNode.bluesAnticoneSizes[fakeBlue] != maxKType {
+		t.Fatalf("TestBlueAnticoneSizesSize: BlueAnticoneSize should not change when deserializing. Expected: %v but got %v",
+			maxKType, deserializedNode.bluesAnticoneSizes[fakeBlue])
+	}
+}

blockdag/blockset.go

@@ -0,0 +1,117 @@
+package blockdag
+
+import (
+	"strings"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// blockSet implements a basic unsorted set of blocks
+type blockSet map[*blockNode]struct{}
+
+// newBlockSet creates a new, empty BlockSet
+func newBlockSet() blockSet {
+	return map[*blockNode]struct{}{}
+}
+
+// blockSetFromSlice converts a slice of blockNodes into an unordered set represented as map
+func blockSetFromSlice(nodes ...*blockNode) blockSet {
+	set := newBlockSet()
+	for _, node := range nodes {
+		set.add(node)
+	}
+	return set
+}
+
+// add adds a blockNode to this BlockSet
+func (bs blockSet) add(node *blockNode) {
+	bs[node] = struct{}{}
+}
+
+// remove removes a blockNode from this BlockSet, if exists
+// Does nothing if this set does not contain the blockNode
+func (bs blockSet) remove(node *blockNode) {
+	delete(bs, node)
+}
+
+// clone clones thie block set
+func (bs blockSet) clone() blockSet {
+	clone := newBlockSet()
+	for node := range bs {
+		clone.add(node)
+	}
+	return clone
+}
+
+// subtract returns the difference between the BlockSet and another BlockSet
+func (bs blockSet) subtract(other blockSet) blockSet {
+	diff := newBlockSet()
+	for node := range bs {
+		if !other.contains(node) {
+			diff.add(node)
+		}
+	}
+	return diff
+}
+
+// addSet adds all blockNodes in other set to this set
+func (bs blockSet) addSet(other blockSet) {
+	for node := range other {
+		bs.add(node)
+	}
+}
+
+// addSlice adds provided slice to this set
+func (bs blockSet) addSlice(slice []*blockNode) {
+	for _, node := range slice {
+		bs.add(node)
+	}
+}
+
+// union returns a BlockSet that contains all blockNodes included in this set,
+// the other set, or both
+func (bs blockSet) union(other blockSet) blockSet {
+	union := bs.clone()
+
+	union.addSet(other)
+
+	return union
+}
+
+// contains returns true iff this set contains node
+func (bs blockSet) contains(node *blockNode) bool {
+	_, ok := bs[node]
+	return ok
+}
+
+// hashes returns the hashes of the blockNodes in this set.
+func (bs blockSet) hashes() []*daghash.Hash {
+	hashes := make([]*daghash.Hash, 0, len(bs))
+	for node := range bs {
+		hashes = append(hashes, node.hash)
+	}
+	daghash.Sort(hashes)
+	return hashes
+}
+
+func (bs blockSet) String() string {
+	nodeStrs := make([]string, 0, len(bs))
+	for node := range bs {
+		nodeStrs = append(nodeStrs, node.String())
+	}
+	return strings.Join(nodeStrs, ",")
+}
+
+func (bs blockSet) bluest() *blockNode {
+	var bluestNode *blockNode
+	var maxScore uint64
+	for node := range bs {
+		if bluestNode == nil ||
+			node.blueScore > maxScore ||
+			(node.blueScore == maxScore && daghash.Less(node.hash, bluestNode.hash)) {
+			bluestNode = node
+			maxScore = node.blueScore
+		}
+	}
+	return bluestNode
+}

blockdag/blockset_test.go

@@ -0,0 +1,245 @@
+package blockdag
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+func TestHashes(t *testing.T) {
+	bs := blockSetFromSlice(
+		&blockNode{
+			hash: &daghash.Hash{3},
+		},
+		&blockNode{
+			hash: &daghash.Hash{1},
+		},
+		&blockNode{
+			hash: &daghash.Hash{0},
+		},
+		&blockNode{
+			hash: &daghash.Hash{2},
+		},
+	)
+
+	expected := []*daghash.Hash{
+		{0},
+		{1},
+		{2},
+		{3},
+	}
+
+	hashes := bs.hashes()
+	if !daghash.AreEqual(hashes, expected) {
+		t.Errorf("TestHashes: hashes order is %s but expected %s", hashes, expected)
+	}
+}
+
+func TestBlockSetSubtract(t *testing.T) {
+	node1 := &blockNode{hash: &daghash.Hash{10}}
+	node2 := &blockNode{hash: &daghash.Hash{20}}
+	node3 := &blockNode{hash: &daghash.Hash{30}}
+
+	tests := []struct {
+		name           string
+		setA           blockSet
+		setB           blockSet
+		expectedResult blockSet
+	}{
+		{
+			name:           "both sets empty",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
+		},
+		{
+			name:           "subtract an empty set",
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "subtract from empty set",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(),
+		},
+		{
+			name:           "subtract unrelated set",
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(node2),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "typical case",
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1),
+		},
+	}
+
+	for _, test := range tests {
+		result := test.setA.subtract(test.setB)
+		if !reflect.DeepEqual(result, test.expectedResult) {
+			t.Errorf("blockSet.subtract: unexpected result in test '%s'. "+
+				"Expected: %v, got: %v", test.name, test.expectedResult, result)
+		}
+	}
+}
+
+func TestBlockSetAddSet(t *testing.T) {
+	node1 := &blockNode{hash: &daghash.Hash{10}}
+	node2 := &blockNode{hash: &daghash.Hash{20}}
+	node3 := &blockNode{hash: &daghash.Hash{30}}
+
+	tests := []struct {
+		name           string
+		setA           blockSet
+		setB           blockSet
+		expectedResult blockSet
+	}{
+		{
+			name:           "both sets empty",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
+		},
+		{
+			name:           "add an empty set",
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "add to empty set",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "add already added member",
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1, node2),
+		},
+		{
+			name:           "typical case",
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1, node2, node3),
+		},
+	}
+
+	for _, test := range tests {
+		test.setA.addSet(test.setB)
+		if !reflect.DeepEqual(test.setA, test.expectedResult) {
+			t.Errorf("blockSet.addSet: unexpected result in test '%s'. "+
+				"Expected: %v, got: %v", test.name, test.expectedResult, test.setA)
+		}
+	}
+}
+
+func TestBlockSetAddSlice(t *testing.T) {
+	node1 := &blockNode{hash: &daghash.Hash{10}}
+	node2 := &blockNode{hash: &daghash.Hash{20}}
+	node3 := &blockNode{hash: &daghash.Hash{30}}
+
+	tests := []struct {
+		name           string
+		set            blockSet
+		slice          []*blockNode
+		expectedResult blockSet
+	}{
+		{
+			name:           "add empty slice to empty set",
+			set:            blockSetFromSlice(),
+			slice:          []*blockNode{},
+			expectedResult: blockSetFromSlice(),
+		},
+		{
+			name:           "add an empty slice",
+			set:            blockSetFromSlice(node1),
+			slice:          []*blockNode{},
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "add to empty set",
+			set:            blockSetFromSlice(),
+			slice:          []*blockNode{node1},
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "add already added member",
+			set:            blockSetFromSlice(node1, node2),
+			slice:          []*blockNode{node1},
+			expectedResult: blockSetFromSlice(node1, node2),
+		},
+		{
+			name:           "typical case",
+			set:            blockSetFromSlice(node1, node2),
+			slice:          []*blockNode{node2, node3},
+			expectedResult: blockSetFromSlice(node1, node2, node3),
+		},
+	}
+
+	for _, test := range tests {
+		test.set.addSlice(test.slice)
+		if !reflect.DeepEqual(test.set, test.expectedResult) {
+			t.Errorf("blockSet.addSlice: unexpected result in test '%s'. "+
+				"Expected: %v, got: %v", test.name, test.expectedResult, test.set)
+		}
+	}
+}
+
+func TestBlockSetUnion(t *testing.T) {
+	node1 := &blockNode{hash: &daghash.Hash{10}}
+	node2 := &blockNode{hash: &daghash.Hash{20}}
+	node3 := &blockNode{hash: &daghash.Hash{30}}
+
+	tests := []struct {
+		name           string
+		setA           blockSet
+		setB           blockSet
+		expectedResult blockSet
+	}{
+		{
+			name:           "both sets empty",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
+		},
+		{
+			name:           "union against an empty set",
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "union from an empty set",
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
+		},
+		{
+			name:           "union with subset",
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1, node2),
+		},
+		{
+			name:           "typical case",
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1, node2, node3),
+		},
+	}
+
+	for _, test := range tests {
+		result := test.setA.union(test.setB)
+		if !reflect.DeepEqual(result, test.expectedResult) {
+			t.Errorf("blockSet.union: unexpected result in test '%s'. "+
+				"Expected: %v, got: %v", test.name, test.expectedResult, result)
+		}
+	}
+}

blockdag/blockwindow.go

@@ -1,7 +1,6 @@
-package difficultymanager
+package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/bigintpool"
 	"github.com/pkg/errors"
@@ -10,54 +9,46 @@ import (
 	"sort"
 )
 
-type difficultyBlock struct {
-	timeInMilliseconds int64
-	Bits               uint32
-}
-
-type blockWindow []difficultyBlock
-
-func (dm *difficultyManager) getDifficultyBlock(blockHash *externalapi.DomainHash) (difficultyBlock, error) {
-	header, err := dm.headerStore.BlockHeader(dm.databaseContext, blockHash)
-	if err != nil {
-		return difficultyBlock{}, err
-	}
-	return difficultyBlock{
-		timeInMilliseconds: header.TimeInMilliseconds,
-		Bits:               header.Bits,
-	}, nil
-}
+type blockWindow []*blockNode
 
 // blueBlockWindow returns a blockWindow of the given size that contains the
 // blues in the past of startindNode, sorted by GHOSTDAG order.
 // If the number of blues in the past of startingNode is less then windowSize,
 // the window will be padded by genesis blocks to achieve a size of windowSize.
-func (dm *difficultyManager) blueBlockWindow(startingNode *externalapi.DomainHash, windowSize uint64) (blockWindow, error) {
+func blueBlockWindow(startingNode *blockNode, windowSize uint64) blockWindow {
 	window := make(blockWindow, 0, windowSize)
-	windowHashes, err := dm.dagTraversalManager.BlueWindow(startingNode, windowSize)
-	if err != nil {
-		return nil, err
+	currentNode := startingNode
+	for uint64(len(window)) < windowSize && currentNode.selectedParent != nil {
+		if currentNode.selectedParent != nil {
+			for _, blue := range currentNode.blues {
+				window = append(window, blue)
+				if uint64(len(window)) == windowSize {
+					break
+				}
+			}
+			currentNode = currentNode.selectedParent
+		}
 	}
 
-	for _, hash := range windowHashes {
-		block, err := dm.getDifficultyBlock(hash)
-		if err != nil {
-			return nil, err
+	if uint64(len(window)) < windowSize {
+		genesis := currentNode
+		for uint64(len(window)) < windowSize {
+			window = append(window, genesis)
 		}
-		window = append(window, block)
 	}
-	return window, nil
+
+	return window
 }
 
 func (window blockWindow) minMaxTimestamps() (min, max int64) {
 	min = math.MaxInt64
 	max = 0
-	for _, block := range window {
-		if block.timeInMilliseconds < min {
-			min = block.timeInMilliseconds
+	for _, node := range window {
+		if node.timestamp < min {
+			min = node.timestamp
 		}
-		if block.timeInMilliseconds > max {
-			max = block.timeInMilliseconds
+		if node.timestamp > max {
+			max = node.timestamp
 		}
 	}
 	return
@@ -68,8 +59,8 @@ func (window blockWindow) averageTarget(averageTarget *big.Int) {
 
 	target := bigintpool.Acquire(0)
 	defer bigintpool.Release(target)
-	for _, block := range window {
-		util.CompactToBigWithDestination(block.Bits, target)
+	for _, node := range window {
+		util.CompactToBigWithDestination(node.bits, target)
 		averageTarget.Add(averageTarget, target)
 	}
 
@@ -84,7 +75,7 @@ func (window blockWindow) medianTimestamp() (int64, error) {
 	}
 	timestamps := make([]int64, len(window))
 	for i, node := range window {
-		timestamps[i] = node.timeInMilliseconds
+		timestamps[i] = node.timestamp
 	}
 	sort.Sort(timeSorter(timestamps))
 	return timestamps[len(timestamps)/2], nil

blockdag/blockwindow_test.go

@@ -0,0 +1,160 @@
+package blockdag
+
+import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/pkg/errors"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestBlueBlockWindow(t *testing.T) {
+	params := dagconfig.SimnetParams
+	params.K = 1
+	dag, teardownFunc, err := DAGSetup("TestBlueBlockWindow", true, Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup dag instance: %v", err)
+	}
+	defer teardownFunc()
+
+	resetExtraNonceForTest()
+
+	windowSize := uint64(10)
+	genesisNode := dag.genesis
+	blockTime := genesisNode.Header().Timestamp
+	blockByIDMap := make(map[string]*blockNode)
+	idByBlockMap := make(map[*blockNode]string)
+	blockByIDMap["A"] = genesisNode
+	idByBlockMap[genesisNode] = "A"
+
+	blocksData := []*struct {
+		parents                          []string
+		id                               string //id is a virtual entity that is used only for tests so we can define relations between blocks without knowing their hash
+		expectedWindowWithGenesisPadding []string
+	}{
+		{
+			parents:                          []string{"A"},
+			id:                               "B",
+			expectedWindowWithGenesisPadding: []string{"A", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"B"},
+			id:                               "C",
+			expectedWindowWithGenesisPadding: []string{"B", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"B"},
+			id:                               "D",
+			expectedWindowWithGenesisPadding: []string{"B", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"D", "C"},
+			id:                               "E",
+			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"D", "C"},
+			id:                               "F",
+			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"A"},
+			id:                               "G",
+			expectedWindowWithGenesisPadding: []string{"A", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"G"},
+			id:                               "H",
+			expectedWindowWithGenesisPadding: []string{"G", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"H", "F"},
+			id:                               "I",
+			expectedWindowWithGenesisPadding: []string{"F", "D", "C", "B", "A", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"I"},
+			id:                               "J",
+			expectedWindowWithGenesisPadding: []string{"I", "F", "D", "C", "B", "A", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"J"},
+			id:                               "K",
+			expectedWindowWithGenesisPadding: []string{"J", "I", "F", "D", "C", "B", "A", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"K"},
+			id:                               "L",
+			expectedWindowWithGenesisPadding: []string{"K", "J", "I", "F", "D", "C", "B", "A", "A", "A"},
+		},
+		{
+			parents:                          []string{"L"},
+			id:                               "M",
+			expectedWindowWithGenesisPadding: []string{"L", "K", "J", "I", "F", "D", "C", "B", "A", "A"},
+		},
+		{
+			parents:                          []string{"M"},
+			id:                               "N",
+			expectedWindowWithGenesisPadding: []string{"M", "L", "K", "J", "I", "F", "D", "C", "B", "A"},
+		},
+		{
+			parents:                          []string{"N"},
+			id:                               "O",
+			expectedWindowWithGenesisPadding: []string{"N", "M", "L", "K", "J", "I", "F", "D", "C", "B"},
+		},
+	}
+
+	for _, blockData := range blocksData {
+		blockTime = blockTime.Add(time.Second)
+		parents := blockSet{}
+		for _, parentID := range blockData.parents {
+			parent := blockByIDMap[parentID]
+			parents.add(parent)
+		}
+
+		block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
+		if err != nil {
+			t.Fatalf("block %v got unexpected error from PrepareBlockForTest: %v", blockData.id, err)
+		}
+
+		utilBlock := util.NewBlock(block)
+		isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, BFNoPoWCheck)
+		if err != nil {
+			t.Fatalf("dag.ProcessBlock got unexpected error for block %v: %v", blockData.id, err)
+		}
+		if isDelayed {
+			t.Fatalf("block %s "+
+				"is too far in the future", blockData.id)
+		}
+		if isOrphan {
+			t.Fatalf("block %v was unexpectedly orphan", blockData.id)
+		}
+
+		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
+
+		window := blueBlockWindow(node, windowSize)
+		if err := checkWindowIDs(window, blockData.expectedWindowWithGenesisPadding, idByBlockMap); err != nil {
+			t.Errorf("Unexpected values for window for block %s: %s", blockData.id, err)
+		}
+	}
+}
+
+func checkWindowIDs(window []*blockNode, expectedIDs []string, idByBlockMap map[*blockNode]string) error {
+	ids := make([]string, len(window))
+	for i, node := range window {
+		ids[i] = idByBlockMap[node]
+	}
+	if !reflect.DeepEqual(ids, expectedIDs) {
+		return errors.Errorf("window expected to have blocks %s but got %s", expectedIDs, ids)
+	}
+	return nil
+}

blockdag/coinbase.go

@@ -0,0 +1,199 @@
+package blockdag
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"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/pkg/errors"
+)
+
+// compactFeeData is a specialized data type to store a compact list of fees
+// inside a block.
+// Every transaction gets a single uint64 value, stored as a plain binary list.
+// The transactions are ordered the same way they are ordered inside the block, making it easy
+// to traverse every transaction in a block and extract its fee.
+//
+// compactFeeFactory is used to create such a list.
+// compactFeeIterator is used to iterate over such a list.
+
+type compactFeeData []byte
+
+func (cfd compactFeeData) Len() int {
+	return len(cfd) / 8
+}
+
+type compactFeeFactory struct {
+	buffer *bytes.Buffer
+	writer *bufio.Writer
+}
+
+func newCompactFeeFactory() *compactFeeFactory {
+	buffer := bytes.NewBuffer([]byte{})
+	return &compactFeeFactory{
+		buffer: buffer,
+		writer: bufio.NewWriter(buffer),
+	}
+}
+
+func (cfw *compactFeeFactory) add(txFee uint64) error {
+	return binary.Write(cfw.writer, binary.LittleEndian, txFee)
+}
+
+func (cfw *compactFeeFactory) data() (compactFeeData, error) {
+	err := cfw.writer.Flush()
+
+	return compactFeeData(cfw.buffer.Bytes()), err
+}
+
+type compactFeeIterator struct {
+	reader io.Reader
+}
+
+func (cfd compactFeeData) iterator() *compactFeeIterator {
+	return &compactFeeIterator{
+		reader: bufio.NewReader(bytes.NewBuffer(cfd)),
+	}
+}
+
+func (cfr *compactFeeIterator) next() (uint64, error) {
+	var txFee uint64
+
+	err := binary.Read(cfr.reader, binary.LittleEndian, &txFee)
+
+	return txFee, err
+}
+
+// The following functions relate to storing and retrieving fee data from the database
+
+// getBluesFeeData returns the compactFeeData for all nodes's blues,
+// used to calculate the fees this blockNode needs to pay
+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(dag.databaseContext, blueBlock.hash)
+		if err != nil {
+			return nil, err
+		}
+
+		bluesFeeData[*blueBlock.hash] = feeData
+	}
+
+	return bluesFeeData, nil
+}
+
+// The following functions deal with building and validating the coinbase transaction
+
+func (node *blockNode) validateCoinbaseTransaction(dag *BlockDAG, block *util.Block, txsAcceptanceData MultiBlockTxsAcceptanceData) error {
+	if node.isGenesis() {
+		return nil
+	}
+	blockCoinbaseTx := block.CoinbaseTransaction().MsgTx()
+	_, scriptPubKey, extraData, err := coinbasepayload.DeserializeCoinbasePayload(blockCoinbaseTx)
+	if errors.Is(err, coinbasepayload.ErrIncorrectScriptPubKeyLen) {
+		return ruleError(ErrBadCoinbaseTransaction, err.Error())
+	}
+	if err != nil {
+		return err
+	}
+	expectedCoinbaseTransaction, err := node.expectedCoinbaseTransaction(dag, txsAcceptanceData, scriptPubKey, extraData)
+	if err != nil {
+		return err
+	}
+
+	if !expectedCoinbaseTransaction.Hash().IsEqual(block.CoinbaseTransaction().Hash()) {
+		return ruleError(ErrBadCoinbaseTransaction, "Coinbase transaction is not built as expected")
+	}
+
+	return nil
+}
+
+// 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 := dag.getBluesFeeData(node)
+	if err != nil {
+		return nil, err
+	}
+
+	txIns := []*domainmessage.TxIn{}
+	txOuts := []*domainmessage.TxOut{}
+
+	for _, blue := range node.blues {
+		txOut, err := coinbaseOutputForBlueBlock(dag, blue, txsAcceptanceData, bluesFeeData)
+		if err != nil {
+			return nil, err
+		}
+		if txOut != nil {
+			txOuts = append(txOuts, txOut)
+		}
+	}
+	payload, err := coinbasepayload.SerializeCoinbasePayload(node.blueScore, scriptPubKey, extraData)
+	if err != nil {
+		return nil, err
+	}
+	coinbaseTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkid.SubnetworkIDCoinbase, 0, payload)
+	sortedCoinbaseTx := txsort.Sort(coinbaseTx)
+	return util.NewTx(sortedCoinbaseTx), nil
+}
+
+// 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) (*domainmessage.TxOut, error) {
+
+	blockTxsAcceptanceData, ok := txsAcceptanceData.FindAcceptanceData(blueBlock.hash)
+	if !ok {
+		return nil, errors.Errorf("No txsAcceptanceData for block %s", blueBlock.hash)
+	}
+	blockFeeData, ok := feeData[*blueBlock.hash]
+	if !ok {
+		return nil, errors.Errorf("No feeData for block %s", blueBlock.hash)
+	}
+
+	if len(blockTxsAcceptanceData.TxAcceptanceData) != blockFeeData.Len() {
+		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)
+	}
+
+	totalFees := uint64(0)
+	feeIterator := blockFeeData.iterator()
+
+	for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
+		fee, err := feeIterator.next()
+		if err != nil {
+			return nil, errors.Errorf("Error retrieving fee from compactFeeData iterator: %s", err)
+		}
+		if txAcceptanceData.IsAccepted {
+			totalFees += fee
+		}
+	}
+
+	totalReward := CalcBlockSubsidy(blueBlock.blueScore, dag.Params) + totalFees
+
+	if totalReward == 0 {
+		return nil, nil
+	}
+
+	// the ScriptPubKey for the coinbase is parsed from the coinbase payload
+	_, scriptPubKey, _, err := coinbasepayload.DeserializeCoinbasePayload(blockTxsAcceptanceData.TxAcceptanceData[0].Tx.MsgTx())
+	if err != nil {
+		return nil, err
+	}
+
+	txOut := &domainmessage.TxOut{
+		Value:        totalReward,
+		ScriptPubKey: scriptPubKey,
+	}
+
+	return txOut, nil
+}

blockdag/coinbase_test.go

@@ -0,0 +1,60 @@
+package blockdag
+
+import (
+	"io"
+	"reflect"
+	"testing"
+)
+
+func TestFeeAccumulators(t *testing.T) {
+	fees := []uint64{1, 2, 3, 4, 5, 6, 7, 0xffffffffffffffff}
+
+	factory := newCompactFeeFactory()
+
+	for _, fee := range fees {
+		err := factory.add(fee)
+		if err != nil {
+			t.Fatalf("Error writing %d as tx fee: %s", fee, err)
+		}
+	}
+
+	expectedData := compactFeeData{
+		1, 0, 0, 0, 0, 0, 0, 0,
+		2, 0, 0, 0, 0, 0, 0, 0,
+		3, 0, 0, 0, 0, 0, 0, 0,
+		4, 0, 0, 0, 0, 0, 0, 0,
+		5, 0, 0, 0, 0, 0, 0, 0,
+		6, 0, 0, 0, 0, 0, 0, 0,
+		7, 0, 0, 0, 0, 0, 0, 0,
+		255, 255, 255, 255, 255, 255, 255, 255,
+	}
+	actualData, err := factory.data()
+
+	if err != nil {
+		t.Fatalf("Error getting bytes from writer: %s", err)
+	}
+	if !reflect.DeepEqual(expectedData, actualData) {
+		t.Errorf("Expected bytes: %v, but got: %v", expectedData, actualData)
+	}
+
+	iterator := actualData.iterator()
+
+	for i, expectedFee := range fees {
+		actualFee, err := iterator.next()
+		if err != nil {
+			t.Fatalf("Error getting fee for Tx#%d: %s", i, err)
+		}
+
+		if actualFee != expectedFee {
+			t.Errorf("Tx #%d: Expected fee: %d, but got %d", i, expectedFee, actualFee)
+		}
+	}
+
+	_, err = iterator.next()
+	if err == nil {
+		t.Fatal("No error from iterator.nextTxFee after done reading all transactions")
+	}
+	if err != io.EOF {
+		t.Fatalf("Error from iterator.nextTxFee after done reading all transactions is not io.EOF: %s", err)
+	}
+}