[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,23 +9,21 @@ import (
 	crand "crypto/rand" // for seeding
 	"encoding/binary"
 	"encoding/gob"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"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/util/subnetworkid"
 
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -94,7 +92,7 @@ type PeersStateForSerialization struct {
 }
 
 type localAddress struct {
-	netAddress *appmessage.NetAddress
+	netAddress *domainmessage.NetAddress
 	score      AddressPriority
 }
 
@@ -194,7 +192,7 @@ const (
 var ErrAddressNotFound = errors.New("address not found")
 
 // New returns a new Kaspa address manager.
-func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext) (*AddressManager, error) {
+func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext) *AddressManager {
 	addressManager := AddressManager{
 		cfg:               cfg,
 		databaseContext:   databaseContext,
@@ -204,17 +202,13 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext) (*Addres
 		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 *subnetworkid.SubnetworkID) {
+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) {
@@ -224,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*,
@@ -376,7 +371,7 @@ func (am *AddressManager) pickTried(subnetworkID *subnetworkid.SubnetworkID, buc
 	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{}
@@ -397,7 +392,7 @@ func (am *AddressManager) newAddressBucketIndex(netAddress, srcAddress *appmessa
 	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[:]...)
@@ -710,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
@@ -721,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
@@ -763,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 *subnetworkid.SubnetworkID) {
+func (am *AddressManager) AddAddresses(addresses []*domainmessage.NetAddress, sourceAddress *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -775,13 +770,35 @@ 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 *subnetworkid.SubnetworkID) {
+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 *subnetworkid.SubnetworkID) int {
@@ -826,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 *subnetworkid.SubnetworkID) []*appmessage.NetAddress {
+func (am *AddressManager) AddressCache(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) []*domainmessage.NetAddress {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -834,7 +851,7 @@ 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().IsEqual(subnetworkID) {
@@ -890,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)
@@ -903,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))
@@ -1014,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()
 
@@ -1038,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()
 
@@ -1061,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 *subnetworkid.SubnetworkID) {
+func (am *AddressManager) Good(address *domainmessage.NetAddress, subnetworkID *subnetworkid.SubnetworkID) {
 	am.mutex.Lock()
 	defer am.mutex.Unlock()
 
@@ -1237,7 +1254,7 @@ func (am *AddressManager) incrementTriedAddressCount(subnetworkID *subnetworkid.
 
 // 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)
 	}
@@ -1262,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
@@ -1329,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 ||
@@ -1359,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()
 
@@ -1391,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()
 
@@ -1402,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

@@ -6,25 +6,26 @@ package addressmanager
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/app/appmessage"
 	"io/ioutil"
 	"net"
 	"reflect"
 	"testing"
 	"time"
 
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"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
 }
 
@@ -98,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)
 }
@@ -123,10 +124,7 @@ func newAddrManagerForTest(t *testing.T, testName string,
 		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()
@@ -177,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
@@ -196,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,
 		},
@@ -253,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)
 	}
@@ -276,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)
 	}
@@ -300,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++ {
@@ -311,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()
@@ -329,7 +327,7 @@ 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([]*subnetworkid.SubnetworkID, subnetworkCount)
 
@@ -346,7 +344,7 @@ func TestGood(t *testing.T) {
 		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 {
@@ -376,9 +374,9 @@ 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 := subnetworkid.SubnetworkIDNative
 	amgr.AddAddress(addr, srcAddr, oldSubnetwork)
@@ -454,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)
 	}
@@ -481,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)
 	}
@@ -517,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")},
@@ -525,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)
@@ -585,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
@@ -599,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 {
@@ -624,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,18 +5,19 @@
 package addressmanager
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"time"
 
 	"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
@@ -27,9 +28,9 @@ type KnownAddress struct {
 	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
 }
 

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

@@ -4,24 +4,24 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/addressmanager"
 
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/netadapter/id"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
-	"github.com/kaspanet/kaspad/domain/mempool"
-	"github.com/kaspanet/kaspad/domain/mining"
-	"github.com/kaspanet/kaspad/domain/txscript"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
-	"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/infrastructure/network/rpc"
-	"github.com/kaspanet/kaspad/infrastructure/os/signal"
+	"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"
 )
@@ -62,11 +62,11 @@ func (a *App) Start() {
 }
 
 // Stop gracefully shuts down all the kaspad services.
-func (a *App) Stop() {
+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
+		return nil
 	}
 
 	log.Warnf("Kaspad shutting down")
@@ -86,12 +86,7 @@ func (a *App) Stop() {
 		}
 	}
 
-	err = a.addressManager.Stop()
-	if err != nil {
-		log.Errorf("Error stopping address manager: %s", err)
-	}
-
-	return
+	return nil
 }
 
 // New returns a new App instance configured to listen on addr for the
@@ -114,14 +109,13 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrup
 	if err != nil {
 		return nil, err
 	}
-	addressManager, err := addressmanager.New(cfg, databaseContext)
-	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
@@ -144,8 +138,8 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrup
 
 func (a *App) maybeSeedFromDNS() {
 	if !a.cfg.DisableDNSSeed {
-		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
-			a.cfg.Lookup, func(addresses []*appmessage.NetAddress) {
+		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.
@@ -196,10 +190,11 @@ func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript
 			MaxTxVersion:    1,
 		},
 		CalcSequenceLockNoLock: func(tx *util.Tx, utxoSet blockdag.UTXOSet) (*blockdag.SequenceLock, error) {
-			return dag.CalcSequenceLockNoLock(tx, utxoSet)
+			return dag.CalcSequenceLockNoLock(tx, utxoSet, true)
 		},
-		SigCache: sigCache,
-		DAG:      dag,
+		IsDeploymentActive: dag.IsDeploymentActive,
+		SigCache:           sigCache,
+		DAG:                dag,
 	}
 
 	return mempool.New(&mempoolConfig)
@@ -246,3 +241,9 @@ func (a *App) P2PNodeID() *id.ID {
 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/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/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/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/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)
-}

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_test.go

@@ -3,7 +3,7 @@ package blockdag
 import (
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 

blockdag/blockindex.go

@@ -5,12 +5,10 @@
 package blockdag
 
 import (
-	"fmt"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
-	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"sync"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -136,42 +134,3 @@ func (bi *blockIndex) flushToDB(dbContext *dbaccess.TxContext) error {
 func (bi *blockIndex) clearDirtyEntries() {
 	bi.dirty = make(map[*blockNode]struct{})
 }
-
-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()
-}
-
-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/blockindex_test.go

@@ -1,7 +1,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"testing"
 )

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

@@ -8,11 +8,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -106,7 +106,7 @@ type blockNode struct {
 // 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 *appmessage.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
+func (dag *BlockDAG) newBlockNode(blockHeader *domainmessage.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
 	node = &blockNode{
 		parents:            parents,
 		children:           make(blockSet),
@@ -160,9 +160,9 @@ func (node *blockNode) less(other *blockNode) bool {
 // Header constructs a block header from the node and returns it.
 //
 // This function is safe for concurrent access.
-func (node *blockNode) Header() *appmessage.BlockHeader {
+func (node *blockNode) Header() *domainmessage.BlockHeader {
 	// No lock is needed because all accessed fields are immutable.
-	return &appmessage.BlockHeader{
+	return &domainmessage.BlockHeader{
 		Version:              node.version,
 		ParentHashes:         node.ParentHashes(),
 		HashMerkleRoot:       node.hashMerkleRoot,

blockdag/blocknode_test.go

@@ -1,7 +1,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"testing"
 )

blockdag/blockwindow_test.go

@@ -1,7 +1,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 	"reflect"
@@ -51,14 +51,14 @@ func TestBlueBlockWindow(t *testing.T) {
 			expectedWindowWithGenesisPadding: []string{"B", "A", "A", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
-			parents:                          []string{"C", "D"},
+			parents:                          []string{"D", "C"},
 			id:                               "E",
-			expectedWindowWithGenesisPadding: []string{"C", "D", "B", "A", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
-			parents:                          []string{"C", "D"},
+			parents:                          []string{"D", "C"},
 			id:                               "F",
-			expectedWindowWithGenesisPadding: []string{"C", "D", "B", "A", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"A"},
@@ -73,37 +73,37 @@ func TestBlueBlockWindow(t *testing.T) {
 		{
 			parents:                          []string{"H", "F"},
 			id:                               "I",
-			expectedWindowWithGenesisPadding: []string{"F", "C", "D", "B", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"F", "D", "C", "B", "A", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"I"},
 			id:                               "J",
-			expectedWindowWithGenesisPadding: []string{"I", "F", "C", "D", "B", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"I", "F", "D", "C", "B", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"J"},
 			id:                               "K",
-			expectedWindowWithGenesisPadding: []string{"J", "I", "F", "C", "D", "B", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"J", "I", "F", "D", "C", "B", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"K"},
 			id:                               "L",
-			expectedWindowWithGenesisPadding: []string{"K", "J", "I", "F", "C", "D", "B", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"K", "J", "I", "F", "D", "C", "B", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"L"},
 			id:                               "M",
-			expectedWindowWithGenesisPadding: []string{"L", "K", "J", "I", "F", "C", "D", "B", "A", "A"},
+			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", "C", "D", "B", "A"},
+			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", "C", "D", "B"},
+			expectedWindowWithGenesisPadding: []string{"N", "M", "L", "K", "J", "I", "F", "D", "C", "B"},
 		},
 	}
 

blockdag/coinbase.go

@@ -6,8 +6,8 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"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"
@@ -124,8 +124,8 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
 		return nil, err
 	}
 
-	txIns := []*appmessage.TxIn{}
-	txOuts := []*appmessage.TxOut{}
+	txIns := []*domainmessage.TxIn{}
+	txOuts := []*domainmessage.TxOut{}
 
 	for _, blue := range node.blues {
 		txOut, err := coinbaseOutputForBlueBlock(dag, blue, txsAcceptanceData, bluesFeeData)
@@ -140,7 +140,7 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
 	if err != nil {
 		return nil, err
 	}
-	coinbaseTx := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, txIns, txOuts, subnetworkid.SubnetworkIDCoinbase, 0, payload)
+	coinbaseTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkid.SubnetworkIDCoinbase, 0, payload)
 	sortedCoinbaseTx := txsort.Sort(coinbaseTx)
 	return util.NewTx(sortedCoinbaseTx), nil
 }
@@ -148,7 +148,7 @@ func (node *blockNode) expectedCoinbaseTransaction(dag *BlockDAG, txsAcceptanceD
 // 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) (*appmessage.TxOut, error) {
+	txsAcceptanceData MultiBlockTxsAcceptanceData, feeData map[daghash.Hash]compactFeeData) (*domainmessage.TxOut, error) {
 
 	blockTxsAcceptanceData, ok := txsAcceptanceData.FindAcceptanceData(blueBlock.hash)
 	if !ok {
@@ -190,31 +190,10 @@ func coinbaseOutputForBlueBlock(dag *BlockDAG, blueBlock *blockNode,
 		return nil, err
 	}
 
-	txOut := &appmessage.TxOut{
+	txOut := &domainmessage.TxOut{
 		Value:        totalReward,
 		ScriptPubKey: scriptPubKey,
 	}
 
 	return txOut, nil
 }
-
-// NextBlockCoinbaseTransaction prepares the coinbase transaction for the next mined block
-//
-// This function CAN'T be called with the DAG lock held.
-func (dag *BlockDAG) NextBlockCoinbaseTransaction(scriptPubKey []byte, extraData []byte) (*util.Tx, error) {
-	dag.dagLock.RLock()
-	defer dag.dagLock.RUnlock()
-
-	return dag.NextBlockCoinbaseTransactionNoLock(scriptPubKey, extraData)
-}
-
-// NextBlockCoinbaseTransactionNoLock prepares the coinbase transaction for the next mined block
-//
-// This function MUST be called with the DAG read-lock held
-func (dag *BlockDAG) NextBlockCoinbaseTransactionNoLock(scriptPubKey []byte, extraData []byte) (*util.Tx, error) {
-	txsAcceptanceData, err := dag.TxsAcceptedByVirtual()
-	if err != nil {
-		return nil, err
-	}
-	return dag.virtual.blockNode.expectedCoinbaseTransaction(dag, txsAcceptanceData, scriptPubKey, extraData)
-}

blockdag/common_test.go

@@ -17,8 +17,8 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
@@ -78,7 +78,7 @@ func loadUTXOSet(filename string) (UTXOSet, error) {
 		if err != nil {
 			return nil, err
 		}
-		utxoSet.utxoCollection[appmessage.Outpoint{TxID: txID, Index: index}] = entry
+		utxoSet.utxoCollection[domainmessage.Outpoint{TxID: txID, Index: index}] = entry
 	}
 
 	return utxoSet, nil
@@ -103,6 +103,8 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG {
 		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
 		powMaxBits:                     util.BigToCompact(params.PowMax),
 		index:                          index,
+		warningCaches:                  newThresholdCaches(vbNumBits),
+		deploymentCaches:               newThresholdCaches(dagconfig.DefinedDeployments),
 	}
 
 	// Create a genesis block node and block index index populated with it
@@ -118,7 +120,7 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG {
 // provided fields populated and fake values for the other fields.
 func newTestNode(dag *BlockDAG, parents blockSet, blockVersion int32, bits uint32, timestamp mstime.Time) *blockNode {
 	// Make up a header and create a block node from it.
-	header := &appmessage.BlockHeader{
+	header := &domainmessage.BlockHeader{
 		Version:              blockVersion,
 		ParentHashes:         parents.hashes(),
 		Bits:                 bits,
@@ -166,7 +168,7 @@ func checkRuleError(gotErr, wantErr error) error {
 	return nil
 }
 
-func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parents ...*appmessage.MsgBlock) *appmessage.MsgBlock {
+func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parents ...*domainmessage.MsgBlock) *domainmessage.MsgBlock {
 	parentHashes := make([]*daghash.Hash, len(parents))
 	for i, parent := range parents {
 		parentHashes[i] = parent.BlockHash()
@@ -174,7 +176,7 @@ func prepareAndProcessBlockByParentMsgBlocks(t *testing.T, dag *BlockDAG, parent
 	return PrepareAndProcessBlockForTest(t, dag, parentHashes, nil)
 }
 
-func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *appmessage.MsgBlock) *blockNode {
+func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *domainmessage.MsgBlock) *blockNode {
 	node, ok := dag.index.LookupNode(block.BlockHash())
 	if !ok {
 		t.Fatalf("couldn't find block node with hash %s", block.BlockHash())

blockdag/dag_test.go

@@ -14,12 +14,12 @@ import (
 	"time"
 
 	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
@@ -255,7 +255,7 @@ func TestCalcSequenceLock(t *testing.T) {
 	// Create a utxo view with a fake utxo for the inputs used in the
 	// transactions created below. This utxo is added such that it has an
 	// age of 4 blocks.
-	msgTx := appmessage.NewNativeMsgTx(appmessage.TxVersion, nil, []*appmessage.TxOut{{ScriptPubKey: nil, Value: 10}})
+	msgTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, nil, []*domainmessage.TxOut{{ScriptPubKey: nil, Value: 10}})
 	targetTx := util.NewTx(msgTx)
 	utxoSet := NewFullUTXOSet()
 	blueScore := uint64(numBlocksToGenerate) - 4
@@ -270,7 +270,7 @@ func TestCalcSequenceLock(t *testing.T) {
 	// that the sequence lock heights are always calculated from the same
 	// point of view that they were originally calculated from for a given
 	// utxo. That is to say, the height prior to it.
-	utxo := appmessage.Outpoint{
+	utxo := domainmessage.Outpoint{
 		TxID:  *targetTx.ID(),
 		Index: 0,
 	}
@@ -290,8 +290,8 @@ func TestCalcSequenceLock(t *testing.T) {
 
 	// Add an additional transaction which will serve as our unconfirmed
 	// output.
-	unConfTx := appmessage.NewNativeMsgTx(appmessage.TxVersion, nil, []*appmessage.TxOut{{ScriptPubKey: nil, Value: 5}})
-	unConfUtxo := appmessage.Outpoint{
+	unConfTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, nil, []*domainmessage.TxOut{{ScriptPubKey: nil, Value: 5}})
+	unConfUtxo := domainmessage.Outpoint{
 		TxID:  *unConfTx.TxID(),
 		Index: 0,
 	}
@@ -303,8 +303,9 @@ func TestCalcSequenceLock(t *testing.T) {
 
 	tests := []struct {
 		name    string
-		tx      *appmessage.MsgTx
+		tx      *domainmessage.MsgTx
 		utxoSet UTXOSet
+		mempool bool
 		want    *SequenceLock
 	}{
 		// A transaction with a single input with max sequence number.
@@ -312,7 +313,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		// should be disabled.
 		{
 			name:    "single input, max sequence number",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: utxo, Sequence: appmessage.MaxTxInSequenceNum}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: domainmessage.MaxTxInSequenceNum}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Milliseconds:   -1,
@@ -327,7 +328,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		// the targeted block.
 		{
 			name:    "single input, milliseconds lock time below time granularity",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 2)}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 2)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Milliseconds:   medianTime - 1,
@@ -339,7 +340,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		// milliseconds after the median past time of the DAG.
 		{
 			name:    "single input, 1048575 milliseconds after median time",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Milliseconds:   medianTime + 1048575,
@@ -354,8 +355,8 @@ func TestCalcSequenceLock(t *testing.T) {
 		// latest lock that isn't disabled.
 		{
 			name: "multiple varied inputs",
-			tx: appmessage.NewNativeMsgTx(1,
-				[]*appmessage.TxIn{{
+			tx: domainmessage.NewNativeMsgTx(1,
+				[]*domainmessage.TxIn{{
 					PreviousOutpoint: utxo,
 					Sequence:         LockTimeToSequence(true, 2621440),
 				}, {
@@ -364,12 +365,12 @@ func TestCalcSequenceLock(t *testing.T) {
 				}, {
 					PreviousOutpoint: utxo,
 					Sequence: LockTimeToSequence(false, 5) |
-						appmessage.SequenceLockTimeDisabled,
+						domainmessage.SequenceLockTimeDisabled,
 				}},
 				nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Milliseconds:   medianTime + (5 << appmessage.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (5 << domainmessage.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 3,
 			},
 		},
@@ -379,7 +380,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		// height of 2 meaning it can be included at height 3.
 		{
 			name:    "single input, lock-time in blocks",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(false, 3)}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: utxo, Sequence: LockTimeToSequence(false, 3)}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Milliseconds:   -1,
@@ -391,7 +392,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		// be the time further in the future.
 		{
 			name: "two inputs, lock-times in seconds",
-			tx: appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{
+			tx: domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{
 				PreviousOutpoint: utxo,
 				Sequence:         LockTimeToSequence(true, 5242880),
 			}, {
@@ -400,7 +401,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			}}, nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Milliseconds:   medianTime + (10 << appmessage.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (10 << domainmessage.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: -1,
 			},
 		},
@@ -410,8 +411,8 @@ func TestCalcSequenceLock(t *testing.T) {
 		// indicating it can be included at height 11.
 		{
 			name: "two inputs, lock-times in blocks",
-			tx: appmessage.NewNativeMsgTx(1,
-				[]*appmessage.TxIn{{
+			tx: domainmessage.NewNativeMsgTx(1,
+				[]*domainmessage.TxIn{{
 					PreviousOutpoint: utxo,
 					Sequence:         LockTimeToSequence(false, 1),
 				}, {
@@ -430,8 +431,8 @@ func TestCalcSequenceLock(t *testing.T) {
 		// further into the future for both inputs should be chosen.
 		{
 			name: "four inputs, two lock-times in time, two lock-times in blocks",
-			tx: appmessage.NewNativeMsgTx(1,
-				[]*appmessage.TxIn{{
+			tx: domainmessage.NewNativeMsgTx(1,
+				[]*domainmessage.TxIn{{
 					PreviousOutpoint: utxo,
 					Sequence:         LockTimeToSequence(true, 2621440),
 				}, {
@@ -447,7 +448,7 @@ func TestCalcSequenceLock(t *testing.T) {
 				nil),
 			utxoSet: utxoSet,
 			want: &SequenceLock{
-				Milliseconds:   medianTime + (13 << appmessage.SequenceLockTimeGranularity) - 1,
+				Milliseconds:   medianTime + (13 << domainmessage.SequenceLockTimeGranularity) - 1,
 				BlockBlueScore: int64(prevUtxoBlueScore) + 8,
 			},
 		},
@@ -459,8 +460,9 @@ func TestCalcSequenceLock(t *testing.T) {
 		// after that.
 		{
 			name:    "single input, unconfirmed, lock-time in blocks",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(false, 2)}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(false, 2)}}, nil),
 			utxoSet: utxoSet,
+			mempool: true,
 			want: &SequenceLock{
 				Milliseconds:   -1,
 				BlockBlueScore: int64(nextBlockBlueScore) + 1,
@@ -471,8 +473,9 @@ func TestCalcSequenceLock(t *testing.T) {
 		// MTP of the *next* block.
 		{
 			name:    "single input, unconfirmed, lock-time in milliseoncds",
-			tx:      appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
+			tx:      domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{{PreviousOutpoint: unConfUtxo, Sequence: LockTimeToSequence(true, 1048576)}}, nil),
 			utxoSet: utxoSet,
+			mempool: true,
 			want: &SequenceLock{
 				Milliseconds:   nextMedianTime + 1048575,
 				BlockBlueScore: -1,
@@ -483,7 +486,7 @@ func TestCalcSequenceLock(t *testing.T) {
 	t.Logf("Running %v SequenceLock tests", len(tests))
 	for _, test := range tests {
 		utilTx := util.NewTx(test.tx)
-		seqLock, err := dag.CalcSequenceLock(utilTx, utxoSet)
+		seqLock, err := dag.CalcSequenceLock(utilTx, utxoSet, test.mempool)
 		if err != nil {
 			t.Fatalf("test '%s', unable to calc sequence lock: %v", test.name, err)
 		}
@@ -698,7 +701,7 @@ func TestConfirmations(t *testing.T) {
 	}
 
 	// Add a chain of blocks
-	chainBlocks := make([]*appmessage.MsgBlock, 5)
+	chainBlocks := make([]*domainmessage.MsgBlock, 5)
 	chainBlocks[0] = dag.Params.GenesisBlock
 	for i := uint32(1); i < 5; i++ {
 		chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
@@ -718,7 +721,7 @@ func TestConfirmations(t *testing.T) {
 		}
 	}
 
-	branchingBlocks := make([]*appmessage.MsgBlock, 2)
+	branchingBlocks := make([]*domainmessage.MsgBlock, 2)
 	// Add two branching blocks
 	branchingBlocks[0] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[1])
 	branchingBlocks[1] = prepareAndProcessBlockByParentMsgBlocks(t, dag, branchingBlocks[0])
@@ -791,7 +794,7 @@ func TestAcceptingBlock(t *testing.T) {
 	defer teardownFunc()
 	dag.TestSetCoinbaseMaturity(0)
 
-	acceptingBlockByMsgBlock := func(block *appmessage.MsgBlock) (*blockNode, error) {
+	acceptingBlockByMsgBlock := func(block *domainmessage.MsgBlock) (*blockNode, error) {
 		node := nodeByMsgBlock(t, dag, block)
 		return dag.acceptingBlock(node)
 	}
@@ -807,7 +810,7 @@ func TestAcceptingBlock(t *testing.T) {
 	}
 
 	numChainBlocks := uint32(10)
-	chainBlocks := make([]*appmessage.MsgBlock, numChainBlocks)
+	chainBlocks := make([]*domainmessage.MsgBlock, numChainBlocks)
 	chainBlocks[0] = dag.Params.GenesisBlock
 	for i := uint32(1); i <= numChainBlocks-1; i++ {
 		chainBlocks[i] = prepareAndProcessBlockByParentMsgBlocks(t, dag, chainBlocks[i-1])
@@ -1027,11 +1030,11 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 	}
 	defer teardownFunc()
 
-	invalidCbTx := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, []*appmessage.TxIn{}, []*appmessage.TxOut{}, subnetworkid.SubnetworkIDCoinbase, 0, []byte{})
+	invalidCbTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{}, []*domainmessage.TxOut{}, subnetworkid.SubnetworkIDCoinbase, 0, []byte{})
 	txs := []*util.Tx{util.NewTx(invalidCbTx)}
 	hashMerkleRoot := BuildHashMerkleTreeStore(txs).Root()
-	invalidMsgBlock := appmessage.NewMsgBlock(
-		appmessage.NewBlockHeader(
+	invalidMsgBlock := domainmessage.NewMsgBlock(
+		domainmessage.NewBlockHeader(
 			1,
 			[]*daghash.Hash{params.GenesisHash}, hashMerkleRoot,
 			&daghash.Hash{},
@@ -1063,8 +1066,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 		t.Fatalf("invalidBlockNode status to have %b flags raised (got: %b)", statusValidateFailed, invalidBlockNode.status)
 	}
 
-	invalidMsgBlockChild := appmessage.NewMsgBlock(
-		appmessage.NewBlockHeader(1, []*daghash.Hash{
+	invalidMsgBlockChild := domainmessage.NewMsgBlock(
+		domainmessage.NewBlockHeader(1, []*daghash.Hash{
 			invalidBlock.Hash(),
 		}, hashMerkleRoot, &daghash.Hash{}, &daghash.Hash{}, dag.genesis.bits, 0),
 	)
@@ -1092,8 +1095,8 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 		t.Fatalf("invalidBlockNode status to have %b flags raised (got %b)", statusInvalidAncestor, invalidBlockChildNode.status)
 	}
 
-	invalidMsgBlockGrandChild := appmessage.NewMsgBlock(
-		appmessage.NewBlockHeader(1, []*daghash.Hash{
+	invalidMsgBlockGrandChild := domainmessage.NewMsgBlock(
+		domainmessage.NewBlockHeader(1, []*daghash.Hash{
 			invalidBlockChild.Hash(),
 		}, hashMerkleRoot, &daghash.Hash{}, &daghash.Hash{}, dag.genesis.bits, 0),
 	)
@@ -1121,7 +1124,22 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 	}
 }
 
-func testProcessBlockRuleError(t *testing.T, dag *BlockDAG, block *appmessage.MsgBlock, expectedRuleErr error) {
+func TestIsDAGCurrentMaxDiff(t *testing.T) {
+	netParams := []*dagconfig.Params{
+		&dagconfig.MainnetParams,
+		&dagconfig.TestnetParams,
+		&dagconfig.DevnetParams,
+		&dagconfig.RegressionNetParams,
+		&dagconfig.SimnetParams,
+	}
+	for _, params := range netParams {
+		if params.FinalityDuration < isDAGCurrentMaxDiff*params.TargetTimePerBlock {
+			t.Errorf("in %s, a DAG can be considered current even if it's below the finality point", params.Name)
+		}
+	}
+}
+
+func testProcessBlockRuleError(t *testing.T, dag *BlockDAG, block *domainmessage.MsgBlock, expectedRuleErr error) {
 	isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(block), BFNoPoWCheck)
 
 	err = checkRuleError(err, expectedRuleErr)
@@ -1157,24 +1175,24 @@ func TestDoubleSpends(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to build signature script: %s", err)
 	}
-	txIn := &appmessage.TxIn{
-		PreviousOutpoint: appmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
+	txIn := &domainmessage.TxIn{
+		PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
 		SignatureScript:  signatureScript,
-		Sequence:         appmessage.MaxTxInSequenceNum,
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 	}
-	txOut := &appmessage.TxOut{
+	txOut := &domainmessage.TxOut{
 		ScriptPubKey: OpTrueScript,
 		Value:        uint64(1),
 	}
-	tx1 := appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn}, []*appmessage.TxOut{txOut})
+	tx1 := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
 
-	doubleSpendTxOut := &appmessage.TxOut{
+	doubleSpendTxOut := &domainmessage.TxOut{
 		ScriptPubKey: OpTrueScript,
 		Value:        uint64(2),
 	}
-	doubleSpendTx1 := appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn}, []*appmessage.TxOut{doubleSpendTxOut})
+	doubleSpendTx1 := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{doubleSpendTxOut})
 
-	blockWithTx1 := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*appmessage.MsgTx{tx1})
+	blockWithTx1 := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*domainmessage.MsgTx{tx1})
 
 	// Check that a block will be rejected if it has a transaction that already exists in its past.
 	anotherBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{blockWithTx1.BlockHash()}, nil)
@@ -1209,7 +1227,7 @@ func TestDoubleSpends(t *testing.T) {
 
 	testProcessBlockRuleError(t, dag, blockWithDoubleSpendForTx1, ruleError(ErrMissingTxOut, ""))
 
-	blockInAnticoneOfBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*appmessage.MsgTx{doubleSpendTx1})
+	blockInAnticoneOfBlockWithTx1, err := PrepareBlockForTest(dag, []*daghash.Hash{fundingBlock.BlockHash()}, []*domainmessage.MsgTx{doubleSpendTx1})
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -1264,7 +1282,7 @@ func TestUTXOCommitment(t *testing.T) {
 
 	resetExtraNonceForTest()
 
-	createTx := func(txToSpend *appmessage.MsgTx) *appmessage.MsgTx {
+	createTx := func(txToSpend *domainmessage.MsgTx) *domainmessage.MsgTx {
 		scriptPubKey, err := txscript.PayToScriptHashScript(OpTrueScript)
 		if err != nil {
 			t.Fatalf("TestUTXOCommitment: failed to build script pub key: %s", err)
@@ -1273,16 +1291,16 @@ func TestUTXOCommitment(t *testing.T) {
 		if err != nil {
 			t.Fatalf("TestUTXOCommitment: failed to build signature script: %s", err)
 		}
-		txIn := &appmessage.TxIn{
-			PreviousOutpoint: appmessage.Outpoint{TxID: *txToSpend.TxID(), Index: 0},
+		txIn := &domainmessage.TxIn{
+			PreviousOutpoint: domainmessage.Outpoint{TxID: *txToSpend.TxID(), Index: 0},
 			SignatureScript:  signatureScript,
-			Sequence:         appmessage.MaxTxInSequenceNum,
+			Sequence:         domainmessage.MaxTxInSequenceNum,
 		}
-		txOut := &appmessage.TxOut{
+		txOut := &domainmessage.TxOut{
 			ScriptPubKey: scriptPubKey,
 			Value:        uint64(1),
 		}
-		return appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn}, []*appmessage.TxOut{txOut})
+		return domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
 	}
 
 	// Build the following DAG:
@@ -1298,12 +1316,12 @@ func TestUTXOCommitment(t *testing.T) {
 
 	// Block C:
 	txSpendBlockACoinbase := createTx(blockA.Transactions[0])
-	blockCTxs := []*appmessage.MsgTx{txSpendBlockACoinbase}
+	blockCTxs := []*domainmessage.MsgTx{txSpendBlockACoinbase}
 	blockC := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockA.BlockHash()}, blockCTxs)
 
 	// Block D:
 	txSpendTxInBlockC := createTx(txSpendBlockACoinbase)
-	blockDTxs := []*appmessage.MsgTx{txSpendTxInBlockC}
+	blockDTxs := []*domainmessage.MsgTx{txSpendTxInBlockC}
 	blockD := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{blockB.BlockHash(), blockC.BlockHash()}, blockDTxs)
 
 	// Get the pastUTXO of blockD

blockdag/dagio.go

@@ -11,11 +11,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/binaryserializer"
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -49,7 +49,7 @@ func IsNotInDAGErr(err error) bool {
 // keys will be iterated in an ascending order by the outpoint index.
 var outpointIndexByteOrder = binary.BigEndian
 
-func serializeOutpoint(w io.Writer, outpoint *appmessage.Outpoint) error {
+func serializeOutpoint(w io.Writer, outpoint *domainmessage.Outpoint) error {
 	_, err := w.Write(outpoint.TxID[:])
 	if err != nil {
 		return err
@@ -61,10 +61,10 @@ func serializeOutpoint(w io.Writer, outpoint *appmessage.Outpoint) error {
 var outpointSerializeSize = daghash.TxIDSize + 4
 
 // deserializeOutpoint decodes an outpoint from the passed serialized byte
-// slice into a new appmessage.Outpoint using a format that is suitable for long-
+// slice into a new domainmessage.Outpoint using a format that is suitable for long-
 // term storage. This format is described in detail above.
-func deserializeOutpoint(r io.Reader) (*appmessage.Outpoint, error) {
-	outpoint := &appmessage.Outpoint{}
+func deserializeOutpoint(r io.Reader) (*domainmessage.Outpoint, error) {
+	outpoint := &domainmessage.Outpoint{}
 	_, err := r.Read(outpoint.TxID[:])
 	if err != nil {
 		return nil, err
@@ -410,7 +410,7 @@ func (dag *BlockDAG) processUnprocessedBlockNodes(unprocessedBlockNodes []*block
 func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 	buffer := bytes.NewReader(blockRow)
 
-	var header appmessage.BlockHeader
+	var header domainmessage.BlockHeader
 	err := header.Deserialize(buffer)
 	if err != nil {
 		return nil, err
@@ -464,7 +464,7 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		return nil, err
 	}
 
-	bluesCount, err := appmessage.ReadVarInt(buffer)
+	bluesCount, err := domainmessage.ReadVarInt(buffer)
 	if err != nil {
 		return nil, err
 	}
@@ -483,7 +483,7 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		}
 	}
 
-	bluesAnticoneSizesLen, err := appmessage.ReadVarInt(buffer)
+	bluesAnticoneSizesLen, err := domainmessage.ReadVarInt(buffer)
 	if err != nil {
 		return nil, err
 	}
@@ -527,7 +527,7 @@ func storeBlock(dbContext *dbaccess.TxContext, block *util.Block) error {
 }
 
 func serializeBlockNode(node *blockNode) ([]byte, error) {
-	w := bytes.NewBuffer(make([]byte, 0, appmessage.MaxBlockHeaderPayload+1))
+	w := bytes.NewBuffer(make([]byte, 0, domainmessage.MaxBlockHeaderPayload+1))
 	header := node.Header()
 	err := header.Serialize(w)
 	if err != nil {
@@ -554,7 +554,7 @@ func serializeBlockNode(node *blockNode) ([]byte, error) {
 		return nil, err
 	}
 
-	err = appmessage.WriteVarInt(w, uint64(len(node.blues)))
+	err = domainmessage.WriteVarInt(w, uint64(len(node.blues)))
 	if err != nil {
 		return nil, err
 	}
@@ -566,7 +566,7 @@ func serializeBlockNode(node *blockNode) ([]byte, error) {
 		}
 	}
 
-	err = appmessage.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
+	err = domainmessage.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
 	if err != nil {
 		return nil, err
 	}
@@ -662,16 +662,3 @@ func (dag *BlockDAG) BlockHashesFrom(lowHash *daghash.Hash, limit int) ([]*dagha
 
 	return blockHashes, nil
 }
-
-func (dag *BlockDAG) fetchBlueBlocks(node *blockNode) ([]*util.Block, error) {
-	blueBlocks := make([]*util.Block, len(node.blues))
-	for i, blueBlockNode := range node.blues {
-		blueBlock, err := dag.fetchBlockByHash(blueBlockNode.hash)
-		if err != nil {
-			return nil, err
-		}
-
-		blueBlocks[i] = blueBlock
-	}
-	return blueBlocks, nil
-}

blockdag/difficulty.go

@@ -15,7 +15,7 @@ import (
 // block given its bluest parent.
 func (dag *BlockDAG) requiredDifficulty(bluestParent *blockNode, newBlockTime mstime.Time) uint32 {
 	// Genesis block.
-	if dag.Params.DisableDifficultyAdjustment || bluestParent == nil || bluestParent.blueScore < dag.difficultyAdjustmentWindowSize+1 {
+	if bluestParent == nil || bluestParent.blueScore < dag.difficultyAdjustmentWindowSize+1 {
 		return dag.powMaxBits
 	}
 

blockdag/difficulty_test.go

@@ -5,7 +5,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"math/big"
 	"testing"
@@ -80,7 +80,7 @@ func TestCalcWork(t *testing.T) {
 }
 
 func TestDifficulty(t *testing.T) {
-	params := dagconfig.MainnetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	params.DifficultyAdjustmentWindowSize = 264
 	dag, teardownFunc, err := DAGSetup("TestDifficulty", true, Config{

blockdag/external_dag_test.go

@@ -13,11 +13,11 @@ import (
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/testtools"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/domain/mining"
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/mining"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 )
 
@@ -125,7 +125,7 @@ func TestFinality(t *testing.T) {
 		t.Errorf("NextBlockCoinbaseTransaction: %s", err)
 	}
 	merkleRoot := blockdag.BuildHashMerkleTreeStore([]*util.Tx{fakeCoinbaseTx}).Root()
-	beforeFinalityBlock := appmessage.NewMsgBlock(&appmessage.BlockHeader{
+	beforeFinalityBlock := domainmessage.NewMsgBlock(&domainmessage.BlockHeader{
 		Version:              0x10000000,
 		ParentHashes:         []*daghash.Hash{genesis.Hash()},
 		HashMerkleRoot:       merkleRoot,
@@ -164,7 +164,7 @@ func TestFinality(t *testing.T) {
 }
 
 // TestFinalityInterval tests that the finality interval is
-// smaller then appmessage.MaxInvPerMsg, so when a peer receives
+// smaller then domainmessage.MaxInvPerMsg, so when a peer receives
 // a getblocks message it should always be able to send
 // all the necessary invs.
 func TestFinalityInterval(t *testing.T) {
@@ -172,6 +172,7 @@ func TestFinalityInterval(t *testing.T) {
 		&dagconfig.MainnetParams,
 		&dagconfig.TestnetParams,
 		&dagconfig.DevnetParams,
+		&dagconfig.RegressionNetParams,
 		&dagconfig.SimnetParams,
 	}
 	for _, params := range netParams {
@@ -184,8 +185,8 @@ func TestFinalityInterval(t *testing.T) {
 			}
 			defer teardownFunc()
 
-			if dag.FinalityInterval() > appmessage.MaxInvPerMsg {
-				t.Errorf("FinalityInterval in %s should be lower or equal to appmessage.MaxInvPerMsg", params.Name)
+			if dag.FinalityInterval() > domainmessage.MaxInvPerMsg {
+				t.Errorf("FinalityInterval in %s should be lower or equal to domainmessage.MaxInvPerMsg", params.Name)
 			}
 		}()
 	}
@@ -252,34 +253,34 @@ func TestChainedTransactions(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to build signature script: %s", err)
 	}
-	txIn := &appmessage.TxIn{
-		PreviousOutpoint: appmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
+	txIn := &domainmessage.TxIn{
+		PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
 		SignatureScript:  signatureScript,
-		Sequence:         appmessage.MaxTxInSequenceNum,
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 	}
-	txOut := &appmessage.TxOut{
+	txOut := &domainmessage.TxOut{
 		ScriptPubKey: blockdag.OpTrueScript,
 		Value:        uint64(1),
 	}
-	tx := appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn}, []*appmessage.TxOut{txOut})
+	tx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut})
 
-	chainedTxIn := &appmessage.TxIn{
-		PreviousOutpoint: appmessage.Outpoint{TxID: *tx.TxID(), Index: 0},
+	chainedTxIn := &domainmessage.TxIn{
+		PreviousOutpoint: domainmessage.Outpoint{TxID: *tx.TxID(), Index: 0},
 		SignatureScript:  signatureScript,
-		Sequence:         appmessage.MaxTxInSequenceNum,
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 	}
 
 	scriptPubKey, err := txscript.PayToScriptHashScript(blockdag.OpTrueScript)
 	if err != nil {
 		t.Fatalf("Failed to build public key script: %s", err)
 	}
-	chainedTxOut := &appmessage.TxOut{
+	chainedTxOut := &domainmessage.TxOut{
 		ScriptPubKey: scriptPubKey,
 		Value:        uint64(1),
 	}
-	chainedTx := appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{chainedTxIn}, []*appmessage.TxOut{chainedTxOut})
+	chainedTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{chainedTxIn}, []*domainmessage.TxOut{chainedTxOut})
 
-	block2, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*appmessage.MsgTx{tx}, false)
+	block2, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*domainmessage.MsgTx{tx}, false)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -314,18 +315,18 @@ func TestChainedTransactions(t *testing.T) {
 		t.Errorf("ProcessBlock: block2 got unexpectedly orphaned")
 	}
 
-	nonChainedTxIn := &appmessage.TxIn{
-		PreviousOutpoint: appmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
+	nonChainedTxIn := &domainmessage.TxIn{
+		PreviousOutpoint: domainmessage.Outpoint{TxID: *cbTx.TxID(), Index: 0},
 		SignatureScript:  signatureScript,
-		Sequence:         appmessage.MaxTxInSequenceNum,
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 	}
-	nonChainedTxOut := &appmessage.TxOut{
+	nonChainedTxOut := &domainmessage.TxOut{
 		ScriptPubKey: scriptPubKey,
 		Value:        uint64(1),
 	}
-	nonChainedTx := appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{nonChainedTxIn}, []*appmessage.TxOut{nonChainedTxOut})
+	nonChainedTx := domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{nonChainedTxIn}, []*domainmessage.TxOut{nonChainedTxOut})
 
-	block3, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*appmessage.MsgTx{nonChainedTx}, false)
+	block3, err := mining.PrepareBlockForTest(dag, []*daghash.Hash{block1.BlockHash()}, []*domainmessage.MsgTx{nonChainedTx}, false)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -362,23 +363,23 @@ func TestOrderInDiffFromAcceptanceData(t *testing.T) {
 
 	createBlock := func(previousBlock *util.Block) *util.Block {
 		// Prepare a transaction that spends the previous block's coinbase transaction
-		var txs []*appmessage.MsgTx
+		var txs []*domainmessage.MsgTx
 		if !previousBlock.IsGenesis() {
 			previousCoinbaseTx := previousBlock.MsgBlock().Transactions[0]
 			signatureScript, err := txscript.PayToScriptHashSignatureScript(blockdag.OpTrueScript, nil)
 			if err != nil {
 				t.Fatalf("TestOrderInDiffFromAcceptanceData: Failed to build signature script: %s", err)
 			}
-			txIn := &appmessage.TxIn{
-				PreviousOutpoint: appmessage.Outpoint{TxID: *previousCoinbaseTx.TxID(), Index: 0},
+			txIn := &domainmessage.TxIn{
+				PreviousOutpoint: domainmessage.Outpoint{TxID: *previousCoinbaseTx.TxID(), Index: 0},
 				SignatureScript:  signatureScript,
-				Sequence:         appmessage.MaxTxInSequenceNum,
+				Sequence:         domainmessage.MaxTxInSequenceNum,
 			}
-			txOut := &appmessage.TxOut{
+			txOut := &domainmessage.TxOut{
 				ScriptPubKey: blockdag.OpTrueScript,
 				Value:        uint64(1),
 			}
-			txs = append(txs, appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn}, []*appmessage.TxOut{txOut}))
+			txs = append(txs, domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn}, []*domainmessage.TxOut{txOut}))
 		}
 
 		// Create the block
@@ -437,7 +438,7 @@ func TestGasLimit(t *testing.T) {
 		t.Fatalf("could not register network: %s", err)
 	}
 
-	cbTxs := []*appmessage.MsgTx{}
+	cbTxs := []*domainmessage.MsgTx{}
 	for i := 0; i < 4; i++ {
 		fundsBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), nil, false)
 		if err != nil {
@@ -468,30 +469,30 @@ func TestGasLimit(t *testing.T) {
 		t.Fatalf("Failed to build public key script: %s", err)
 	}
 
-	tx1In := &appmessage.TxIn{
-		PreviousOutpoint: *appmessage.NewOutpoint(cbTxs[0].TxID(), 0),
-		Sequence:         appmessage.MaxTxInSequenceNum,
+	tx1In := &domainmessage.TxIn{
+		PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[0].TxID(), 0),
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 		SignatureScript:  signatureScript,
 	}
-	tx1Out := &appmessage.TxOut{
+	tx1Out := &domainmessage.TxOut{
 		Value:        cbTxs[0].TxOut[0].Value,
 		ScriptPubKey: scriptPubKey,
 	}
-	tx1 := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, []*appmessage.TxIn{tx1In}, []*appmessage.TxOut{tx1Out}, subnetworkID, 10000, []byte{})
+	tx1 := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{tx1In}, []*domainmessage.TxOut{tx1Out}, subnetworkID, 10000, []byte{})
 
-	tx2In := &appmessage.TxIn{
-		PreviousOutpoint: *appmessage.NewOutpoint(cbTxs[1].TxID(), 0),
-		Sequence:         appmessage.MaxTxInSequenceNum,
+	tx2In := &domainmessage.TxIn{
+		PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[1].TxID(), 0),
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 		SignatureScript:  signatureScript,
 	}
-	tx2Out := &appmessage.TxOut{
+	tx2Out := &domainmessage.TxOut{
 		Value:        cbTxs[1].TxOut[0].Value,
 		ScriptPubKey: scriptPubKey,
 	}
-	tx2 := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, []*appmessage.TxIn{tx2In}, []*appmessage.TxOut{tx2Out}, subnetworkID, 10000, []byte{})
+	tx2 := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{tx2In}, []*domainmessage.TxOut{tx2Out}, subnetworkID, 10000, []byte{})
 
 	// Here we check that we can't process a block that has transactions that exceed the gas limit
-	overLimitBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*appmessage.MsgTx{tx1, tx2}, true)
+	overLimitBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1, tx2}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -513,20 +514,20 @@ func TestGasLimit(t *testing.T) {
 		t.Fatalf("ProcessBlock: overLimitBlock got unexpectedly orphan")
 	}
 
-	overflowGasTxIn := &appmessage.TxIn{
-		PreviousOutpoint: *appmessage.NewOutpoint(cbTxs[2].TxID(), 0),
-		Sequence:         appmessage.MaxTxInSequenceNum,
+	overflowGasTxIn := &domainmessage.TxIn{
+		PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[2].TxID(), 0),
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 		SignatureScript:  signatureScript,
 	}
-	overflowGasTxOut := &appmessage.TxOut{
+	overflowGasTxOut := &domainmessage.TxOut{
 		Value:        cbTxs[2].TxOut[0].Value,
 		ScriptPubKey: scriptPubKey,
 	}
-	overflowGasTx := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, []*appmessage.TxIn{overflowGasTxIn}, []*appmessage.TxOut{overflowGasTxOut},
+	overflowGasTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{overflowGasTxIn}, []*domainmessage.TxOut{overflowGasTxOut},
 		subnetworkID, math.MaxUint64, []byte{})
 
 	// Here we check that we can't process a block that its transactions' gas overflows uint64
-	overflowGasBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*appmessage.MsgTx{tx1, overflowGasTx}, true)
+	overflowGasBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1, overflowGasTx}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -548,19 +549,19 @@ func TestGasLimit(t *testing.T) {
 	}
 
 	nonExistentSubnetwork := &subnetworkid.SubnetworkID{123}
-	nonExistentSubnetworkTxIn := &appmessage.TxIn{
-		PreviousOutpoint: *appmessage.NewOutpoint(cbTxs[3].TxID(), 0),
-		Sequence:         appmessage.MaxTxInSequenceNum,
+	nonExistentSubnetworkTxIn := &domainmessage.TxIn{
+		PreviousOutpoint: *domainmessage.NewOutpoint(cbTxs[3].TxID(), 0),
+		Sequence:         domainmessage.MaxTxInSequenceNum,
 		SignatureScript:  signatureScript,
 	}
-	nonExistentSubnetworkTxOut := &appmessage.TxOut{
+	nonExistentSubnetworkTxOut := &domainmessage.TxOut{
 		Value:        cbTxs[3].TxOut[0].Value,
 		ScriptPubKey: scriptPubKey,
 	}
-	nonExistentSubnetworkTx := appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, []*appmessage.TxIn{nonExistentSubnetworkTxIn},
-		[]*appmessage.TxOut{nonExistentSubnetworkTxOut}, nonExistentSubnetwork, 1, []byte{})
+	nonExistentSubnetworkTx := domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{nonExistentSubnetworkTxIn},
+		[]*domainmessage.TxOut{nonExistentSubnetworkTxOut}, nonExistentSubnetwork, 1, []byte{})
 
-	nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*appmessage.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
+	nonExistentSubnetworkBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{nonExistentSubnetworkTx, overflowGasTx}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
@@ -581,7 +582,7 @@ func TestGasLimit(t *testing.T) {
 	}
 
 	// Here we check that we can process a block with a transaction that doesn't exceed the gas limit
-	validBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*appmessage.MsgTx{tx1}, true)
+	validBlock, err := mining.PrepareBlockForTest(dag, dag.TipHashes(), []*domainmessage.MsgTx{tx1}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}

blockdag/ghostdag.go

@@ -1,7 +1,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/pkg/errors"
 	"sort"
 )

blockdag/ghostdag_test.go

@@ -1,34 +1,24 @@
 package blockdag
 
 import (
-	"encoding/json"
 	"fmt"
-	"os"
-	"path/filepath"
 	"reflect"
 	"sort"
 	"strings"
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
-type block struct {
-	ID                     string // id is a virtual entity that is used only for tests so we can define relations between blocks without knowing their hash
-	ExpectedScore          uint64
-	ExpectedSelectedParent string
-	ExpectedBlues          []string
-	Parents                []string
-}
-
-type testData struct {
-	K            dagconfig.KType
-	GenesisID    string
-	ExpectedReds []string
-	Blocks       []block
+type testBlockData 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
+	expectedScore          uint64
+	expectedSelectedParent string
+	expectedBlues          []string
 }
 
 // TestGHOSTDAG iterates over several dag simulations, and checks
@@ -36,26 +26,158 @@ type testData struct {
 // block are calculated as expected.
 func TestGHOSTDAG(t *testing.T) {
 	dagParams := dagconfig.SimnetParams
-	err := filepath.Walk("./testdata/dags/", func(path string, info os.FileInfo, err error) error {
-		if info.IsDir() {
-			return nil
-		}
-		var test testData
-		file, err := os.Open(path)
-		if err != nil {
-			t.Fatalf("TestGHOSTDAG: failed opening file: %s", path)
-		}
-		decoder := json.NewDecoder(file)
-		decoder.DisallowUnknownFields()
-		err = decoder.Decode(&test)
-		if err != nil {
-			t.Fatalf("TestGHOSTDAG: test: %s, failed decoding json: %v", info.Name(), err)
-		}
 
+	tests := []struct {
+		k            dagconfig.KType
+		expectedReds []string
+		dagData      []*testBlockData
+	}{
+		{
+			k:            3,
+			expectedReds: []string{"F", "G", "H", "I", "N", "P"},
+			dagData: []*testBlockData{
+				{
+					parents:                []string{"A"},
+					id:                     "B",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"B"},
+					id:                     "C",
+					expectedScore:          2,
+					expectedSelectedParent: "B",
+					expectedBlues:          []string{"B"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "D",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"C", "D"},
+					id:                     "E",
+					expectedScore:          4,
+					expectedSelectedParent: "C",
+					expectedBlues:          []string{"C", "D"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "F",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"F"},
+					id:                     "G",
+					expectedScore:          2,
+					expectedSelectedParent: "F",
+					expectedBlues:          []string{"F"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "H",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "I",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"E", "G"},
+					id:                     "J",
+					expectedScore:          5,
+					expectedSelectedParent: "E",
+					expectedBlues:          []string{"E"},
+				},
+				{
+					parents:                []string{"J"},
+					id:                     "K",
+					expectedScore:          6,
+					expectedSelectedParent: "J",
+					expectedBlues:          []string{"J"},
+				},
+				{
+					parents:                []string{"I", "K"},
+					id:                     "L",
+					expectedScore:          7,
+					expectedSelectedParent: "K",
+					expectedBlues:          []string{"K"},
+				},
+				{
+					parents:                []string{"L"},
+					id:                     "M",
+					expectedScore:          8,
+					expectedSelectedParent: "L",
+					expectedBlues:          []string{"L"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "N",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "O",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "P",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "Q",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "R",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"R"},
+					id:                     "S",
+					expectedScore:          10,
+					expectedSelectedParent: "R",
+					expectedBlues:          []string{"R"},
+				},
+				{
+					parents:                []string{"N", "O", "P", "Q", "S"},
+					id:                     "T",
+					expectedScore:          13,
+					expectedSelectedParent: "S",
+					expectedBlues:          []string{"S", "O", "Q"},
+				},
+			},
+		},
+	}
+
+	for i, test := range tests {
 		func() {
 			resetExtraNonceForTest()
-			dagParams.K = test.K
-			dag, teardownFunc, err := DAGSetup(fmt.Sprintf("TestGHOSTDAG %s", info.Name()), true, Config{
+			dagParams.K = test.k
+			dag, teardownFunc, err := DAGSetup(fmt.Sprintf("TestGHOSTDAG%d", i), true, Config{
 				DAGParams: &dagParams,
 			})
 			if err != nil {
@@ -66,33 +188,32 @@ func TestGHOSTDAG(t *testing.T) {
 			genesisNode := dag.genesis
 			blockByIDMap := make(map[string]*blockNode)
 			idByBlockMap := make(map[*blockNode]string)
-			blockByIDMap[test.GenesisID] = genesisNode
-			idByBlockMap[genesisNode] = test.GenesisID
+			blockByIDMap["A"] = genesisNode
+			idByBlockMap[genesisNode] = "A"
 
-			for _, blockData := range test.Blocks {
+			for _, blockData := range test.dagData {
 				parents := blockSet{}
-				for _, parentID := range blockData.Parents {
+				for _, parentID := range blockData.parents {
 					parent := blockByIDMap[parentID]
 					parents.add(parent)
 				}
 
 				block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
 				if err != nil {
-					t.Fatalf("TestGHOSTDAG: block %s got unexpected error from PrepareBlockForTest: %v", blockData.ID,
-						err)
+					t.Fatalf("TestGHOSTDAG: 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("TestGHOSTDAG: dag.ProcessBlock got unexpected error for block %s: %v", blockData.ID, err)
+					t.Fatalf("TestGHOSTDAG: dag.ProcessBlock got unexpected error for block %v: %v", blockData.id, err)
 				}
 				if isDelayed {
 					t.Fatalf("TestGHOSTDAG: block %s "+
-						"is too far in the future", blockData.ID)
+						"is too far in the future", blockData.id)
 				}
 				if isOrphan {
-					t.Fatalf("TestGHOSTDAG: block %s was unexpectedly orphan", blockData.ID)
+					t.Fatalf("TestGHOSTDAG: block %v was unexpectedly orphan", blockData.id)
 				}
 
 				node, ok := dag.index.LookupNode(utilBlock.Hash())
@@ -100,8 +221,8 @@ func TestGHOSTDAG(t *testing.T) {
 					t.Fatalf("block %s does not exist in the DAG", utilBlock.Hash())
 				}
 
-				blockByIDMap[blockData.ID] = node
-				idByBlockMap[node] = blockData.ID
+				blockByIDMap[blockData.id] = node
+				idByBlockMap[node] = blockData.id
 
 				bluesIDs := make([]string, 0, len(node.blues))
 				for _, blue := range node.blues {
@@ -110,17 +231,17 @@ func TestGHOSTDAG(t *testing.T) {
 				selectedParentID := idByBlockMap[node.selectedParent]
 				fullDataStr := fmt.Sprintf("blues: %v, selectedParent: %v, score: %v",
 					bluesIDs, selectedParentID, node.blueScore)
-				if blockData.ExpectedScore != node.blueScore {
-					t.Errorf("Test %s: Block %s expected to have score %v but got %v (fulldata: %v)",
-						info.Name(), blockData.ID, blockData.ExpectedScore, node.blueScore, fullDataStr)
+				if blockData.expectedScore != node.blueScore {
+					t.Errorf("Test %d: Block %v expected to have score %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedScore, node.blueScore, fullDataStr)
 				}
-				if blockData.ExpectedSelectedParent != selectedParentID {
-					t.Errorf("Test %s: Block %s expected to have selected parent %v but got %v (fulldata: %v)",
-						info.Name(), blockData.ID, blockData.ExpectedSelectedParent, selectedParentID, fullDataStr)
+				if blockData.expectedSelectedParent != selectedParentID {
+					t.Errorf("Test %d: Block %v expected to have selected parent %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedSelectedParent, selectedParentID, fullDataStr)
 				}
-				if !reflect.DeepEqual(blockData.ExpectedBlues, bluesIDs) {
-					t.Errorf("Test %s: Block %s expected to have blues %v but got %v (fulldata: %v)",
-						info.Name(), blockData.ID, blockData.ExpectedBlues, bluesIDs, fullDataStr)
+				if !reflect.DeepEqual(blockData.expectedBlues, bluesIDs) {
+					t.Errorf("Test %d: Block %v expected to have blues %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedBlues, bluesIDs, fullDataStr)
 				}
 			}
 
@@ -138,22 +259,16 @@ func TestGHOSTDAG(t *testing.T) {
 					delete(reds, blueID)
 				}
 			}
-			if !checkReds(test.ExpectedReds, reds) {
+			if !checkReds(test.expectedReds, reds) {
 				redsIDs := make([]string, 0, len(reds))
 				for id := range reds {
 					redsIDs = append(redsIDs, id)
 				}
 				sort.Strings(redsIDs)
-				sort.Strings(test.ExpectedReds)
-				t.Errorf("Test %s: Expected reds %v but got %v", info.Name(), test.ExpectedReds, redsIDs)
+				sort.Strings(test.expectedReds)
+				t.Errorf("Test %d: Expected reds %v but got %v", i, test.expectedReds, redsIDs)
 			}
 		}()
-
-		return nil
-	})
-
-	if err != nil {
-		t.Fatal(err)
 	}
 }
 

blockdag/indexers/acceptanceindex.go

@@ -4,9 +4,9 @@ import (
 	"bytes"
 	"encoding/gob"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
@@ -113,7 +113,7 @@ func (idx *AcceptanceIndex) TxsAcceptanceData(blockHash *daghash.Hash) (blockdag
 }
 
 type serializableTxAcceptanceData struct {
-	MsgTx      appmessage.MsgTx
+	MsgTx      domainmessage.MsgTx
 	IsAccepted bool
 }
 

blockdag/indexers/acceptanceindex_test.go

@@ -9,10 +9,10 @@ import (
 	"syscall"
 	"testing"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/pkg/errors"
@@ -21,19 +21,19 @@ import (
 func TestAcceptanceIndexSerializationAndDeserialization(t *testing.T) {
 	// Create test data
 	hash, _ := daghash.NewHashFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	txIn1 := &appmessage.TxIn{SignatureScript: []byte{1}, PreviousOutpoint: appmessage.Outpoint{Index: 1}, Sequence: 0}
-	txIn2 := &appmessage.TxIn{SignatureScript: []byte{2}, PreviousOutpoint: appmessage.Outpoint{Index: 2}, Sequence: 0}
-	txOut1 := &appmessage.TxOut{ScriptPubKey: []byte{1}, Value: 10}
-	txOut2 := &appmessage.TxOut{ScriptPubKey: []byte{2}, Value: 20}
+	txIn1 := &domainmessage.TxIn{SignatureScript: []byte{1}, PreviousOutpoint: domainmessage.Outpoint{Index: 1}, Sequence: 0}
+	txIn2 := &domainmessage.TxIn{SignatureScript: []byte{2}, PreviousOutpoint: domainmessage.Outpoint{Index: 2}, Sequence: 0}
+	txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{1}, Value: 10}
+	txOut2 := &domainmessage.TxOut{ScriptPubKey: []byte{2}, Value: 20}
 	blockTxsAcceptanceData := blockdag.BlockTxsAcceptanceData{
 		BlockHash: *hash,
 		TxAcceptanceData: []blockdag.TxAcceptanceData{
 			{
-				Tx:         util.NewTx(appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn1}, []*appmessage.TxOut{txOut1})),
+				Tx:         util.NewTx(domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn1}, []*domainmessage.TxOut{txOut1})),
 				IsAccepted: true,
 			},
 			{
-				Tx:         util.NewTx(appmessage.NewNativeMsgTx(appmessage.TxVersion, []*appmessage.TxIn{txIn2}, []*appmessage.TxOut{txOut2})),
+				Tx:         util.NewTx(domainmessage.NewNativeMsgTx(domainmessage.TxVersion, []*domainmessage.TxIn{txIn2}, []*domainmessage.TxOut{txOut2})),
 				IsAccepted: false,
 			},
 		},

blockdag/indexers/indexer.go

@@ -8,8 +8,8 @@ Package indexers implements optional block DAG indexes.
 package indexers
 
 import (
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 

blockdag/indexers/log.go

@@ -5,7 +5,7 @@
 package indexers
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/logger"
 )
 
 var log, _ = logger.Get(logger.SubsystemTags.INDX)

blockdag/indexers/manager.go

@@ -5,8 +5,8 @@
 package indexers
 
 import (
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 

blockdag/log.go

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

blockdag/merkle.go

@@ -5,9 +5,7 @@
 package blockdag
 
 import (
-	"fmt"
 	"math"
-	"sort"
 
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -134,49 +132,3 @@ func buildMerkleTreeStore(hashes []*daghash.Hash) MerkleTree {
 
 	return merkles
 }
-
-func calculateAcceptedIDMerkleRoot(multiBlockTxsAcceptanceData MultiBlockTxsAcceptanceData) *daghash.Hash {
-	var acceptedTxs []*util.Tx
-	for _, blockTxsAcceptanceData := range multiBlockTxsAcceptanceData {
-		for _, txAcceptance := range blockTxsAcceptanceData.TxAcceptanceData {
-			if !txAcceptance.IsAccepted {
-				continue
-			}
-			acceptedTxs = append(acceptedTxs, txAcceptance.Tx)
-		}
-	}
-	sort.Slice(acceptedTxs, func(i, j int) bool {
-		return daghash.LessTxID(acceptedTxs[i].ID(), acceptedTxs[j].ID())
-	})
-
-	acceptedIDMerkleTree := BuildIDMerkleTreeStore(acceptedTxs)
-	return acceptedIDMerkleTree.Root()
-}
-
-func (node *blockNode) validateAcceptedIDMerkleRoot(dag *BlockDAG, txsAcceptanceData MultiBlockTxsAcceptanceData) error {
-	if node.isGenesis() {
-		return nil
-	}
-
-	calculatedAccepetedIDMerkleRoot := calculateAcceptedIDMerkleRoot(txsAcceptanceData)
-	header := node.Header()
-	if !header.AcceptedIDMerkleRoot.IsEqual(calculatedAccepetedIDMerkleRoot) {
-		str := fmt.Sprintf("block accepted ID merkle root is invalid - block "+
-			"header indicates %s, but calculated value is %s",
-			header.AcceptedIDMerkleRoot, calculatedAccepetedIDMerkleRoot)
-		return ruleError(ErrBadMerkleRoot, str)
-	}
-	return nil
-}
-
-// NextAcceptedIDMerkleRootNoLock prepares the acceptedIDMerkleRoot for the next mined block
-//
-// This function MUST be called with the DAG read-lock held
-func (dag *BlockDAG) NextAcceptedIDMerkleRootNoLock() (*daghash.Hash, error) {
-	txsAcceptanceData, err := dag.TxsAcceptedByVirtual()
-	if err != nil {
-		return nil, err
-	}
-
-	return calculateAcceptedIDMerkleRoot(txsAcceptanceData), nil
-}

blockdag/mining.go

@@ -3,36 +3,39 @@ package blockdag
 import (
 	"bytes"
 	"encoding/binary"
-	"math"
 	"time"
 
 	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/mstime"
 )
 
-// The current block version
-const blockVersion = 0x10000000
-
 // BlockForMining returns a block with the given transactions
 // that points to the current DAG tips, that is valid from
 // all aspects except proof of work.
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*appmessage.MsgBlock, error) {
+func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*domainmessage.MsgBlock, error) {
 	blockTimestamp := dag.NextBlockTime()
 	requiredDifficulty := dag.NextRequiredDifficulty(blockTimestamp)
 
+	// Calculate the next expected block version based on the state of the
+	// rule change deployments.
+	nextBlockVersion, err := dag.CalcNextBlockVersion()
+	if err != nil {
+		return nil, err
+	}
+
 	// Create a new block ready to be solved.
 	hashMerkleTree := BuildHashMerkleTreeStore(transactions)
 	acceptedIDMerkleRoot, err := dag.NextAcceptedIDMerkleRootNoLock()
 	if err != nil {
 		return nil, err
 	}
-	var msgBlock appmessage.MsgBlock
+	var msgBlock domainmessage.MsgBlock
 	for _, tx := range transactions {
 		msgBlock.AddTransaction(tx.MsgTx())
 	}
@@ -42,8 +45,8 @@ func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*appmessage.MsgBlo
 		return nil, err
 	}
 
-	msgBlock.Header = appmessage.BlockHeader{
-		Version:              blockVersion,
+	msgBlock.Header = domainmessage.BlockHeader{
+		Version:              nextBlockVersion,
 		ParentHashes:         dag.TipHashes(),
 		HashMerkleRoot:       hashMerkleTree.Root(),
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
@@ -124,15 +127,3 @@ func (dag *BlockDAG) NextBlockTime() mstime.Time {
 
 	return newTimestamp
 }
-
-// CurrentBits returns the bits of the tip with the lowest bits, which also means it has highest difficulty.
-func (dag *BlockDAG) CurrentBits() uint32 {
-	tips := dag.virtual.tips()
-	minBits := uint32(math.MaxUint32)
-	for tip := range tips {
-		if minBits > tip.Header().Bits {
-			minBits = tip.Header().Bits
-		}
-	}
-	return minBits
-}

blockdag/multisetstore.go

@@ -3,7 +3,7 @@ package blockdag
 import (
 	"bytes"
 	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/locks"
 	"github.com/pkg/errors"

blockdag/notifications_test.go

@@ -8,7 +8,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 )
 
 // TestNotifications ensures that notification callbacks are fired on events.

blockdag/process.go

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

blockdag/process_test.go

@@ -1,14 +1,13 @@
 package blockdag
 
 import (
-	"github.com/pkg/errors"
 	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/kaspanet/kaspad/util"
 
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -105,9 +104,6 @@ func TestProcessDelayedBlocks(t *testing.T) {
 	blockDelay := time.Duration(dag1.Params.TimestampDeviationTolerance)*dag1.Params.TargetTimePerBlock + 5*time.Second
 	delayedBlock.Header.Timestamp = initialTime.Add(blockDelay)
 
-	// We change the nonce here because processDelayedBlocks always runs without BFNoPoWCheck.
-	delayedBlock.Header.Nonce = 2
-
 	isOrphan, isDelayed, err := dag1.ProcessBlock(util.NewBlock(delayedBlock), BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
@@ -240,101 +236,3 @@ func TestProcessDelayedBlocks(t *testing.T) {
 		t.Errorf("delayedBlockChild shouldn't be added to the DAG because its parent has been added to the DAG")
 	}
 }
-
-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/reachability.go

@@ -2,7 +2,7 @@ package blockdag
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/pkg/errors"
 	"math"
 	"strings"
@@ -268,15 +268,6 @@ func (rtn *reachabilityTreeNode) addChild(child *reachabilityTreeNode, reindexRo
 	rtn.children = append(rtn.children, child)
 	child.parent = rtn
 
-	modifiedNodes[rtn] = struct{}{}
-	modifiedNodes[child] = struct{}{}
-
-	// Temporarily set the child's interval to be empty, at
-	// the start of rtn's remaining interval. This is done
-	// so that child-of-rtn checks (e.g.
-	// findAncestorAmongChildren) will not fail for rtn.
-	child.interval = newReachabilityInterval(remaining.start, remaining.start-1)
-
 	// Handle rtn not being a descendant of the reindex root.
 	// Note that we check rtn here instead of child because
 	// at this point we don't yet know child's interval.
@@ -315,6 +306,8 @@ func (rtn *reachabilityTreeNode) addChild(child *reachabilityTreeNode, reindexRo
 		return err
 	}
 	child.interval = allocated
+	modifiedNodes[rtn] = struct{}{}
+	modifiedNodes[child] = struct{}{}
 	return nil
 }
 

blockdag/reachability_test.go

@@ -1,7 +1,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"reflect"
 	"strings"
@@ -1047,37 +1047,3 @@ func TestReindexIntervalsEarlierThanReindexRoot(t *testing.T) {
 		}
 	}
 }
-
-func TestTipsAfterReindexIntervalsEarlierThanReindexRoot(t *testing.T) {
-	// Create a new database and DAG instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("TestTipsAfterReindexIntervalsEarlierThanReindexRoot", true, Config{
-		DAGParams: &dagconfig.SimnetParams,
-	})
-	if err != nil {
-		t.Fatalf("Failed to setup DAG instance: %v", err)
-	}
-	defer teardownFunc()
-
-	// Set the reindex window to a low number to make this test run fast
-	originalReachabilityReindexWindow := reachabilityReindexWindow
-	reachabilityReindexWindow = 10
-	defer func() {
-		reachabilityReindexWindow = originalReachabilityReindexWindow
-	}()
-
-	// Add a chain of reachabilityReindexWindow + 1 blocks above the genesis.
-	// This will set the reindex root to the child of genesis
-	chainTipHash := dag.Params.GenesisHash
-	for i := uint64(0); i < reachabilityReindexWindow+1; i++ {
-		block := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chainTipHash}, nil)
-		chainTipHash = block.BlockHash()
-	}
-
-	// Add another block above the genesis block. This will trigger an
-	// earlier-than-reindex-root reindex
-	sideBlock := PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{dag.Params.GenesisHash}, nil)
-
-	// Add a block whose parents are the chain tip and the side block.
-	// We expect this not to fail
-	PrepareAndProcessBlockForTest(t, dag, []*daghash.Hash{chainTipHash, sideBlock.BlockHash()}, nil)
-}

blockdag/reachabilitystore.go

@@ -2,9 +2,9 @@ package blockdag
 
 import (
 	"bytes"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/infrastructure/db/database"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/database"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/pkg/errors"
 	"io"
@@ -108,6 +108,7 @@ func (store *reachabilityStore) clearDirtyEntries() {
 }
 
 func (store *reachabilityStore) init(dbContext dbaccess.Context) error {
+	// TODO: (Stas) This is a quick and dirty hack.
 	// We iterate over the entire bucket twice:
 	// * First, populate the loaded set with all entries
 	// * Second, connect the parent/children pointers in each entry
@@ -224,20 +225,20 @@ func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachab
 	if treeNode.parent != nil {
 		parentHash = treeNode.parent.blockNode.hash
 	}
-	err = appmessage.WriteElement(w, parentHash)
+	err = domainmessage.WriteElement(w, parentHash)
 	if err != nil {
 		return err
 	}
 
 	// Serialize the amount of children
-	err = appmessage.WriteVarInt(w, uint64(len(treeNode.children)))
+	err = domainmessage.WriteVarInt(w, uint64(len(treeNode.children)))
 	if err != nil {
 		return err
 	}
 
 	// Serialize the children
 	for _, child := range treeNode.children {
-		err = appmessage.WriteElement(w, child.blockNode.hash)
+		err = domainmessage.WriteElement(w, child.blockNode.hash)
 		if err != nil {
 			return err
 		}
@@ -248,13 +249,13 @@ func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachab
 
 func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, interval *reachabilityInterval) error {
 	// Serialize start
-	err := appmessage.WriteElement(w, interval.start)
+	err := domainmessage.WriteElement(w, interval.start)
 	if err != nil {
 		return err
 	}
 
 	// Serialize end
-	err = appmessage.WriteElement(w, interval.end)
+	err = domainmessage.WriteElement(w, interval.end)
 	if err != nil {
 		return err
 	}
@@ -264,14 +265,14 @@ func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, inter
 
 func (store *reachabilityStore) serializeFutureCoveringSet(w io.Writer, futureCoveringSet futureCoveringTreeNodeSet) error {
 	// Serialize the set size
-	err := appmessage.WriteVarInt(w, uint64(len(futureCoveringSet)))
+	err := domainmessage.WriteVarInt(w, uint64(len(futureCoveringSet)))
 	if err != nil {
 		return err
 	}
 
 	// Serialize each node in the set
 	for _, node := range futureCoveringSet {
-		err = appmessage.WriteElement(w, node.blockNode.hash)
+		err = domainmessage.WriteElement(w, node.blockNode.hash)
 		if err != nil {
 			return err
 		}
@@ -311,7 +312,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
 	// Deserialize the parent
 	// If this is the zero hash, this node is the genesis and as such doesn't have a parent
 	parentHash := &daghash.Hash{}
-	err = appmessage.ReadElement(r, parentHash)
+	err = domainmessage.ReadElement(r, parentHash)
 	if err != nil {
 		return err
 	}
@@ -324,7 +325,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
 	}
 
 	// Deserialize the amount of children
-	childCount, err := appmessage.ReadVarInt(r)
+	childCount, err := domainmessage.ReadVarInt(r)
 	if err != nil {
 		return err
 	}
@@ -333,7 +334,7 @@ func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *re
 	children := make([]*reachabilityTreeNode, childCount)
 	for i := uint64(0); i < childCount; i++ {
 		childHash := &daghash.Hash{}
-		err = appmessage.ReadElement(r, childHash)
+		err = domainmessage.ReadElement(r, childHash)
 		if err != nil {
 			return err
 		}
@@ -353,7 +354,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
 
 	// Deserialize start
 	start := uint64(0)
-	err := appmessage.ReadElement(r, &start)
+	err := domainmessage.ReadElement(r, &start)
 	if err != nil {
 		return nil, err
 	}
@@ -361,7 +362,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
 
 	// Deserialize end
 	end := uint64(0)
-	err = appmessage.ReadElement(r, &end)
+	err = domainmessage.ReadElement(r, &end)
 	if err != nil {
 		return nil, err
 	}
@@ -372,7 +373,7 @@ func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*r
 
 func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destination *reachabilityData) error {
 	// Deserialize the set size
-	setSize, err := appmessage.ReadVarInt(r)
+	setSize, err := domainmessage.ReadVarInt(r)
 	if err != nil {
 		return err
 	}
@@ -381,7 +382,7 @@ func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destin
 	futureCoveringSet := make(futureCoveringTreeNodeSet, setSize)
 	for i := uint64(0); i < setSize; i++ {
 		blockHash := &daghash.Hash{}
-		err = appmessage.ReadElement(r, blockHash)
+		err = domainmessage.ReadElement(r, blockHash)
 		if err != nil {
 			return err
 		}

blockdag/scriptval.go

@@ -9,15 +9,15 @@ import (
 	"runtime"
 	"time"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 )
 
 // txValidateItem holds a transaction along with which input to validate.
 type txValidateItem struct {
 	txInIndex int
-	txIn      *appmessage.TxIn
+	txIn      *domainmessage.TxIn
 	tx        *util.Tx
 }
 

blockdag/scriptval_test.go

@@ -10,13 +10,13 @@ import (
 	"runtime"
 	"testing"
 
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/txscript"
 )
 
 // TestCheckBlockScripts ensures that validating the all of the scripts in a
 // known-good block doesn't return an error.
 func TestCheckBlockScripts(t *testing.T) {
-	t.Skip()
+	t.Skip() // TODO: Reactivate this test once we have blocks from testnet.
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
 	testBlockNum := 277647

blockdag/subnetworks.go

@@ -5,12 +5,12 @@ import (
 	"encoding/binary"
 	"fmt"
 
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/util"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 )
 
@@ -19,7 +19,7 @@ import (
 // subnetwork based on it.
 // This function returns an error if one or more transactions are invalid
 func registerSubnetworks(dbContext dbaccess.Context, txs []*util.Tx) error {
-	subnetworkRegistryTxs := make([]*appmessage.MsgTx, 0)
+	subnetworkRegistryTxs := make([]*domainmessage.MsgTx, 0)
 	for _, tx := range txs {
 		msgTx := tx.MsgTx()
 
@@ -60,7 +60,7 @@ func registerSubnetworks(dbContext dbaccess.Context, txs []*util.Tx) error {
 // validateSubnetworkRegistryTransaction makes sure that a given subnetwork registry
 // transaction is valid. Such a transaction is valid iff:
 // - Its entire payload is a uint64 (8 bytes)
-func validateSubnetworkRegistryTransaction(tx *appmessage.MsgTx) error {
+func validateSubnetworkRegistryTransaction(tx *domainmessage.MsgTx) error {
 	if len(tx.Payload) != 8 {
 		return ruleError(ErrSubnetworkRegistry, fmt.Sprintf("validation failed: subnetwork registry"+
 			"tx '%s' has an invalid payload", tx.TxHash()))
@@ -70,7 +70,7 @@ func validateSubnetworkRegistryTransaction(tx *appmessage.MsgTx) error {
 }
 
 // TxToSubnetworkID creates a subnetwork ID from a subnetwork registry transaction
-func TxToSubnetworkID(tx *appmessage.MsgTx) (*subnetworkid.SubnetworkID, error) {
+func TxToSubnetworkID(tx *domainmessage.MsgTx) (*subnetworkid.SubnetworkID, error) {
 	txHash := tx.TxHash()
 	return subnetworkid.New(util.Hash160(txHash[:]))
 }
@@ -114,14 +114,14 @@ type subnetwork struct {
 	gasLimit uint64
 }
 
-func newSubnetwork(tx *appmessage.MsgTx) *subnetwork {
+func newSubnetwork(tx *domainmessage.MsgTx) *subnetwork {
 	return &subnetwork{
 		gasLimit: ExtractGasLimit(tx),
 	}
 }
 
 // ExtractGasLimit extracts the gas limit from the transaction payload
-func ExtractGasLimit(tx *appmessage.MsgTx) uint64 {
+func ExtractGasLimit(tx *domainmessage.MsgTx) uint64 {
 	return binary.LittleEndian.Uint64(tx.Payload[:8])
 }
 
@@ -155,50 +155,3 @@ func deserializeSubnetwork(serializedSNetBytes []byte) (*subnetwork, error) {
 		gasLimit: gasLimit,
 	}, nil
 }
-
-func (dag *BlockDAG) validateGasLimit(block *util.Block) error {
-	var currentSubnetworkID *subnetworkid.SubnetworkID
-	var currentSubnetworkGasLimit uint64
-	var currentGasUsage uint64
-	var err error
-
-	// We assume here that transactions are ordered by subnetworkID,
-	// since it was already validated in checkTransactionSanity
-	for _, tx := range block.Transactions() {
-		msgTx := tx.MsgTx()
-
-		// In native and Built-In subnetworks all txs must have Gas = 0, and that was already validated in checkTransactionSanity
-		// Therefore - no need to check them here.
-		if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) || msgTx.SubnetworkID.IsBuiltIn() {
-			continue
-		}
-
-		if !msgTx.SubnetworkID.IsEqual(currentSubnetworkID) {
-			currentSubnetworkID = &msgTx.SubnetworkID
-			currentGasUsage = 0
-			currentSubnetworkGasLimit, err = dag.GasLimit(currentSubnetworkID)
-			if err != nil {
-				return errors.Errorf("Error getting gas limit for subnetworkID '%s': %s", currentSubnetworkID, err)
-			}
-		}
-
-		newGasUsage := currentGasUsage + msgTx.Gas
-		if newGasUsage < currentGasUsage { // check for overflow
-			str := fmt.Sprintf("Block gas usage in subnetwork with ID %s has overflown", currentSubnetworkID)
-			return ruleError(ErrInvalidGas, str)
-		}
-		if newGasUsage > currentSubnetworkGasLimit {
-			str := fmt.Sprintf("Block wastes too much gas in subnetwork with ID %s", currentSubnetworkID)
-			return ruleError(ErrInvalidGas, str)
-		}
-
-		currentGasUsage = newGasUsage
-	}
-
-	return nil
-}
-
-// SubnetworkID returns the node's subnetwork ID
-func (dag *BlockDAG) SubnetworkID() *subnetworkid.SubnetworkID {
-	return dag.subnetworkID
-}

blockdag/sync_rate.go

@@ -5,13 +5,7 @@ import (
 	"time"
 )
 
-const (
-	syncRateWindowDuration = 15 * time.Minute
-
-	// isDAGCurrentMaxDiff is the number of blocks from the network tips (estimated by timestamps) for the current
-	// to be considered not synced
-	isDAGCurrentMaxDiff = 40_000
-)
+const syncRateWindowDuration = 15 * time.Minute
 
 // addBlockProcessingTimestamp adds the last block processing timestamp in order to measure the recent sync rate.
 //
@@ -64,40 +58,3 @@ func (dag *BlockDAG) IsSyncRateBelowThreshold(maxDeviation float64) bool {
 func (dag *BlockDAG) uptime() time.Duration {
 	return mstime.Now().Sub(dag.startTime)
 }
-
-// isSynced returns whether or not the DAG believes it is synced. Several
-// factors are used to guess, but the key factors that allow the DAG to
-// believe it is synced are:
-//  - Latest block has a timestamp newer than 24 hours ago
-//
-// This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) isSynced() bool {
-	// Not synced if the virtual's selected parent has a timestamp
-	// before 24 hours ago. If the DAG is empty, we take the genesis
-	// block timestamp.
-	//
-	// The DAG appears to be syncned if none of the checks reported
-	// otherwise.
-	var dagTimestamp int64
-	selectedTip := dag.selectedTip()
-	if selectedTip == nil {
-		dagTimestamp = dag.Params.GenesisBlock.Header.Timestamp.UnixMilliseconds()
-	} else {
-		dagTimestamp = selectedTip.timestamp
-	}
-	dagTime := mstime.UnixMilliseconds(dagTimestamp)
-	return dag.Now().Sub(dagTime) <= isDAGCurrentMaxDiff*dag.Params.TargetTimePerBlock
-}
-
-// IsSynced returns whether or not the DAG believes it is synced. Several
-// factors are used to guess, but the key factors that allow the DAG to
-// believe it is synced are:
-//  - Latest block has a timestamp newer than 24 hours ago
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) IsSynced() bool {
-	dag.dagLock.RLock()
-	defer dag.dagLock.RUnlock()
-
-	return dag.isSynced()
-}

blockdag/test_utils.go

@@ -14,16 +14,16 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/kaspanet/kaspad/infrastructure/db/database/ffldb/ldb"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/database/ffldb/ldb"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -121,30 +121,30 @@ type txSubnetworkData struct {
 	Payload      []byte
 }
 
-func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, subnetworkData *txSubnetworkData) *appmessage.MsgTx {
-	txIns := []*appmessage.TxIn{}
-	txOuts := []*appmessage.TxOut{}
+func createTxForTest(numInputs uint32, numOutputs uint32, outputValue uint64, subnetworkData *txSubnetworkData) *domainmessage.MsgTx {
+	txIns := []*domainmessage.TxIn{}
+	txOuts := []*domainmessage.TxOut{}
 
 	for i := uint32(0); i < numInputs; i++ {
-		txIns = append(txIns, &appmessage.TxIn{
-			PreviousOutpoint: *appmessage.NewOutpoint(&daghash.TxID{}, i),
+		txIns = append(txIns, &domainmessage.TxIn{
+			PreviousOutpoint: *domainmessage.NewOutpoint(&daghash.TxID{}, i),
 			SignatureScript:  []byte{},
-			Sequence:         appmessage.MaxTxInSequenceNum,
+			Sequence:         domainmessage.MaxTxInSequenceNum,
 		})
 	}
 
 	for i := uint32(0); i < numOutputs; i++ {
-		txOuts = append(txOuts, &appmessage.TxOut{
+		txOuts = append(txOuts, &domainmessage.TxOut{
 			ScriptPubKey: OpTrueScript,
 			Value:        outputValue,
 		})
 	}
 
 	if subnetworkData != nil {
-		return appmessage.NewSubnetworkMsgTx(appmessage.TxVersion, txIns, txOuts, subnetworkData.subnetworkID, subnetworkData.Gas, subnetworkData.Payload)
+		return domainmessage.NewSubnetworkMsgTx(domainmessage.TxVersion, txIns, txOuts, subnetworkData.subnetworkID, subnetworkData.Gas, subnetworkData.Payload)
 	}
 
-	return appmessage.NewNativeMsgTx(appmessage.TxVersion, txIns, txOuts)
+	return domainmessage.NewNativeMsgTx(domainmessage.TxVersion, txIns, txOuts)
 }
 
 // VirtualForTest is an exported version for virtualBlock, so that it can be returned by exported test_util methods
@@ -186,7 +186,7 @@ func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (
 // LoadBlocks reads files containing kaspa gzipped block data from disk
 // and returns them as an array of util.Block.
 func LoadBlocks(filename string) (blocks []*util.Block, err error) {
-	var network = appmessage.Mainnet
+	var network = domainmessage.Mainnet
 	var dr io.Reader
 	var fi io.ReadCloser
 
@@ -244,30 +244,13 @@ func opTrueAddress(prefix util.Bech32Prefix) (util.Address, error) {
 }
 
 // PrepareBlockForTest generates a block with the proper merkle roots, coinbase transaction etc. This function is used for test purposes only
-func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*appmessage.MsgTx) (*appmessage.MsgBlock, error) {
-	parents := newBlockSet()
-	for _, hash := range parentHashes {
-		parent, ok := dag.index.LookupNode(hash)
-		if !ok {
-			return nil, errors.Errorf("parent %s was not found", hash)
-		}
-		parents.add(parent)
-	}
-	node, _ := dag.newBlockNode(nil, parents)
-
-	_, selectedParentPastUTXO, txsAcceptanceData, err := dag.pastUTXO(node)
+func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*domainmessage.MsgTx) (*domainmessage.MsgBlock, error) {
+	newVirtual, err := GetVirtualFromParentsForTest(dag, parentHashes)
 	if err != nil {
 		return nil, err
 	}
-
-	calculatedAccepetedIDMerkleRoot := calculateAcceptedIDMerkleRoot(txsAcceptanceData)
-
-	multiset, err := node.calcMultiset(dag, txsAcceptanceData, selectedParentPastUTXO)
-	if err != nil {
-		return nil, err
-	}
-
-	calculatedMultisetHash := daghash.Hash(*multiset.Finalize())
+	oldVirtual := SetVirtualForTest(dag, newVirtual)
+	defer SetVirtualForTest(dag, oldVirtual)
 
 	OpTrueAddr, err := opTrueAddress(dag.Params.Prefix)
 	if err != nil {
@@ -282,12 +265,7 @@ func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactio
 		return nil, err
 	}
 
-	coinbasePayloadScriptPubKey, err := txscript.PayToAddrScript(OpTrueAddr)
-	if err != nil {
-		return nil, err
-	}
-
-	blockTransactions[0], err = node.expectedCoinbaseTransaction(dag, txsAcceptanceData, coinbasePayloadScriptPubKey, coinbasePayloadExtraData)
+	blockTransactions[0], err = dag.NextCoinbaseFromAddress(OpTrueAddr, coinbasePayloadExtraData)
 	if err != nil {
 		return nil, err
 	}
@@ -307,33 +285,19 @@ func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactio
 		return subnetworkid.Less(&blockTransactions[i].MsgTx().SubnetworkID, &blockTransactions[j].MsgTx().SubnetworkID)
 	})
 
-	// Create a new block ready to be solved.
-	hashMerkleTree := BuildHashMerkleTreeStore(blockTransactions)
-
-	var msgBlock appmessage.MsgBlock
-	for _, tx := range blockTransactions {
-		msgBlock.AddTransaction(tx.MsgTx())
+	block, err := dag.BlockForMining(blockTransactions)
+	if err != nil {
+		return nil, err
 	}
+	block.Header.Timestamp = dag.NextBlockMinimumTime()
+	block.Header.Bits = dag.NextRequiredDifficulty(block.Header.Timestamp)
 
-	timestamp := node.parents.bluest().PastMedianTime(dag)
-	msgBlock.Header = appmessage.BlockHeader{
-		Version: blockVersion,
-
-		// We use parents.hashes() and not parentHashes because parents.hashes() is sorted.
-		ParentHashes:         parents.hashes(),
-		HashMerkleRoot:       hashMerkleTree.Root(),
-		AcceptedIDMerkleRoot: calculatedAccepetedIDMerkleRoot,
-		UTXOCommitment:       &calculatedMultisetHash,
-		Timestamp:            timestamp,
-		Bits:                 dag.requiredDifficulty(node.parents.bluest(), timestamp),
-	}
-
-	return &msgBlock, nil
+	return block, nil
 }
 
 // PrepareAndProcessBlockForTest prepares a block that points to the given parent
 // hashes and process it.
-func PrepareAndProcessBlockForTest(t *testing.T, dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*appmessage.MsgTx) *appmessage.MsgBlock {
+func PrepareAndProcessBlockForTest(t *testing.T, dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*domainmessage.MsgTx) *domainmessage.MsgBlock {
 	daghash.Sort(parentHashes)
 	block, err := PrepareBlockForTest(dag, parentHashes, transactions)
 	if err != nil {

blockdag/thresholdstate.go

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

blockdag/thresholdstate_test.go

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

blockdag/utxo_ecmh.go

@@ -3,10 +3,10 @@ package blockdag
 import (
 	"bytes"
 	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
-func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *appmessage.Outpoint) (*secp256k1.MultiSet, error) {
+func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *domainmessage.Outpoint) (*secp256k1.MultiSet, error) {
 	w := &bytes.Buffer{}
 	err := serializeUTXO(w, entry, outpoint)
 	if err != nil {
@@ -16,7 +16,7 @@ func addUTXOToMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *appme
 	return ms, nil
 }
 
-func removeUTXOFromMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *appmessage.Outpoint) (*secp256k1.MultiSet, error) {
+func removeUTXOFromMultiset(ms *secp256k1.MultiSet, entry *UTXOEntry, outpoint *domainmessage.Outpoint) (*secp256k1.MultiSet, error) {
 	w := &bytes.Buffer{}
 	err := serializeUTXO(w, entry, outpoint)
 	if err != nil {

blockdag/utxodiffstore.go

@@ -3,7 +3,7 @@ package blockdag
 import (
 	"bytes"
 
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dbaccess"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/locks"
 )

blockdag/utxodiffstore_test.go

@@ -4,9 +4,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/dbaccess"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -42,8 +42,8 @@ func TestUTXODiffStore(t *testing.T) {
 	// Add node's diff data to the utxoDiffStore and check if it's checked correctly.
 	node := createNode()
 	diff := NewUTXODiff()
-	diff.toAdd.add(appmessage.Outpoint{TxID: daghash.TxID{0x01}, Index: 0}, &UTXOEntry{amount: 1, scriptPubKey: []byte{0x01}})
-	diff.toRemove.add(appmessage.Outpoint{TxID: daghash.TxID{0x02}, Index: 0}, &UTXOEntry{amount: 2, scriptPubKey: []byte{0x02}})
+	diff.toAdd.add(domainmessage.Outpoint{TxID: daghash.TxID{0x01}, Index: 0}, &UTXOEntry{amount: 1, scriptPubKey: []byte{0x01}})
+	diff.toRemove.add(domainmessage.Outpoint{TxID: daghash.TxID{0x02}, Index: 0}, &UTXOEntry{amount: 2, scriptPubKey: []byte{0x02}})
 	if err := dag.utxoDiffStore.setBlockDiff(node, diff); err != nil {
 		t.Fatalf("setBlockDiff: unexpected error: %s", err)
 	}

blockdag/utxoio.go

@@ -2,7 +2,7 @@ package blockdag
 
 import (
 	"bytes"
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/binaryserializer"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/pkg/errors"
@@ -17,12 +17,12 @@ import (
 //  diff		 | UTXODiff  | The diff data's diff
 func serializeBlockUTXODiffData(w io.Writer, diffData *blockUTXODiffData) error {
 	hasDiffChild := diffData.diffChild != nil
-	err := appmessage.WriteElement(w, hasDiffChild)
+	err := domainmessage.WriteElement(w, hasDiffChild)
 	if err != nil {
 		return err
 	}
 	if hasDiffChild {
-		err := appmessage.WriteElement(w, diffData.diffChild.hash)
+		err := domainmessage.WriteElement(w, diffData.diffChild.hash)
 		if err != nil {
 			return err
 		}
@@ -41,14 +41,14 @@ func (diffStore *utxoDiffStore) deserializeBlockUTXODiffData(serializedDiffData
 	r := bytes.NewBuffer(serializedDiffData)
 
 	var hasDiffChild bool
-	err := appmessage.ReadElement(r, &hasDiffChild)
+	err := domainmessage.ReadElement(r, &hasDiffChild)
 	if err != nil {
 		return nil, err
 	}
 
 	if hasDiffChild {
 		hash := &daghash.Hash{}
-		err := appmessage.ReadElement(r, hash)
+		err := domainmessage.ReadElement(r, hash)
 		if err != nil {
 			return nil, err
 		}
@@ -86,7 +86,7 @@ func deserializeUTXODiff(r io.Reader) (*UTXODiff, error) {
 }
 
 func deserializeUTXOCollection(r io.Reader) (utxoCollection, error) {
-	count, err := appmessage.ReadVarInt(r)
+	count, err := domainmessage.ReadVarInt(r)
 	if err != nil {
 		return nil, err
 	}
@@ -101,7 +101,7 @@ func deserializeUTXOCollection(r io.Reader) (utxoCollection, error) {
 	return collection, nil
 }
 
-func deserializeUTXO(r io.Reader) (*UTXOEntry, *appmessage.Outpoint, error) {
+func deserializeUTXO(r io.Reader) (*UTXOEntry, *domainmessage.Outpoint, error) {
 	outpoint, err := deserializeOutpoint(r)
 	if err != nil {
 		return nil, nil, err
@@ -134,7 +134,7 @@ func serializeUTXODiff(w io.Writer, diff *UTXODiff) error {
 // the utxo entries and serializing them and their corresponding outpoint
 // prefixed by a varint that indicates their size.
 func serializeUTXOCollection(w io.Writer, collection utxoCollection) error {
-	err := appmessage.WriteVarInt(w, uint64(len(collection)))
+	err := domainmessage.WriteVarInt(w, uint64(len(collection)))
 	if err != nil {
 		return err
 	}
@@ -148,7 +148,7 @@ func serializeUTXOCollection(w io.Writer, collection utxoCollection) error {
 }
 
 // serializeUTXO serializes a utxo entry-outpoint pair
-func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *appmessage.Outpoint) error {
+func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *domainmessage.Outpoint) error {
 	err := serializeOutpoint(w, outpoint)
 	if err != nil {
 		return err
@@ -163,7 +163,7 @@ func serializeUTXO(w io.Writer, entry *UTXOEntry, outpoint *appmessage.Outpoint)
 
 // p2pkhUTXOEntrySerializeSize is the serialized size for a P2PKH UTXO entry.
 // 8 bytes (header code) + 8 bytes (amount) + varint for script pub key length of 25 (for P2PKH) + 25 bytes for P2PKH script.
-var p2pkhUTXOEntrySerializeSize = 8 + 8 + appmessage.VarIntSerializeSize(25) + 25
+var p2pkhUTXOEntrySerializeSize = 8 + 8 + domainmessage.VarIntSerializeSize(25) + 25
 
 // serializeUTXOEntry encodes the entry to the given io.Writer and use compression if useCompression is true.
 // The compression format is described in detail above.
@@ -185,7 +185,7 @@ func serializeUTXOEntry(w io.Writer, entry *UTXOEntry) error {
 		return err
 	}
 
-	err = appmessage.WriteVarInt(w, uint64(len(entry.ScriptPubKey())))
+	err = domainmessage.WriteVarInt(w, uint64(len(entry.ScriptPubKey())))
 	if err != nil {
 		return err
 	}
@@ -225,7 +225,7 @@ func deserializeUTXOEntry(r io.Reader) (*UTXOEntry, error) {
 		return nil, err
 	}
 
-	scriptPubKeyLen, err := appmessage.ReadVarInt(r)
+	scriptPubKeyLen, err := domainmessage.ReadVarInt(r)
 	if err != nil {
 		return nil, err
 	}

blockdag/utxoset.go

@@ -9,7 +9,7 @@ import (
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/go-secp256k1"
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 )
 
 const (
@@ -78,7 +78,7 @@ const (
 )
 
 // NewUTXOEntry creates a new utxoEntry representing the given txOut
-func NewUTXOEntry(txOut *appmessage.TxOut, isCoinbase bool, blockBlueScore uint64) *UTXOEntry {
+func NewUTXOEntry(txOut *domainmessage.TxOut, isCoinbase bool, blockBlueScore uint64) *UTXOEntry {
 	entry := &UTXOEntry{
 		amount:         txOut.Value,
 		scriptPubKey:   txOut.ScriptPubKey,
@@ -93,7 +93,7 @@ func NewUTXOEntry(txOut *appmessage.TxOut, isCoinbase bool, blockBlueScore uint6
 }
 
 // utxoCollection represents a set of UTXOs indexed by their outpoints
-type utxoCollection map[appmessage.Outpoint]*UTXOEntry
+type utxoCollection map[domainmessage.Outpoint]*UTXOEntry
 
 func (uc utxoCollection) String() string {
 	utxoStrings := make([]string, len(uc))
@@ -112,31 +112,31 @@ func (uc utxoCollection) String() string {
 }
 
 // add adds a new UTXO entry to this collection
-func (uc utxoCollection) add(outpoint appmessage.Outpoint, entry *UTXOEntry) {
+func (uc utxoCollection) add(outpoint domainmessage.Outpoint, entry *UTXOEntry) {
 	uc[outpoint] = entry
 }
 
 // remove removes a UTXO entry from this collection if it exists
-func (uc utxoCollection) remove(outpoint appmessage.Outpoint) {
+func (uc utxoCollection) remove(outpoint domainmessage.Outpoint) {
 	delete(uc, outpoint)
 }
 
 // get returns the UTXOEntry represented by provided outpoint,
 // and a boolean value indicating if said UTXOEntry is in the set or not
-func (uc utxoCollection) get(outpoint appmessage.Outpoint) (*UTXOEntry, bool) {
+func (uc utxoCollection) get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
 	entry, ok := uc[outpoint]
 	return entry, ok
 }
 
 // contains returns a boolean value indicating whether a UTXO entry is in the set
-func (uc utxoCollection) contains(outpoint appmessage.Outpoint) bool {
+func (uc utxoCollection) contains(outpoint domainmessage.Outpoint) bool {
 	_, ok := uc[outpoint]
 	return ok
 }
 
 // containsWithBlueScore returns a boolean value indicating whether a UTXOEntry
 // is in the set and its blue score is equal to the given blue score.
-func (uc utxoCollection) containsWithBlueScore(outpoint appmessage.Outpoint, blueScore uint64) bool {
+func (uc utxoCollection) containsWithBlueScore(outpoint domainmessage.Outpoint, blueScore uint64) bool {
 	entry, ok := uc.get(outpoint)
 	return ok && entry.blockBlueScore == blueScore
 }
@@ -353,7 +353,7 @@ func (d *UTXODiff) clone() *UTXODiff {
 //
 // If d.useMultiset is true, this function MUST be
 // called with the DAG lock held.
-func (d *UTXODiff) AddEntry(outpoint appmessage.Outpoint, entry *UTXOEntry) error {
+func (d *UTXODiff) AddEntry(outpoint domainmessage.Outpoint, entry *UTXOEntry) error {
 	if d.toRemove.containsWithBlueScore(outpoint, entry.blockBlueScore) {
 		d.toRemove.remove(outpoint)
 	} else if _, exists := d.toAdd[outpoint]; exists {
@@ -368,7 +368,7 @@ func (d *UTXODiff) AddEntry(outpoint appmessage.Outpoint, entry *UTXOEntry) erro
 //
 // If d.useMultiset is true, this function MUST be
 // called with the DAG lock held.
-func (d *UTXODiff) RemoveEntry(outpoint appmessage.Outpoint, entry *UTXOEntry) error {
+func (d *UTXODiff) RemoveEntry(outpoint domainmessage.Outpoint, entry *UTXOEntry) error {
 	if d.toAdd.containsWithBlueScore(outpoint, entry.blockBlueScore) {
 		d.toAdd.remove(outpoint)
 	} else if _, exists := d.toRemove[outpoint]; exists {
@@ -399,9 +399,9 @@ type UTXOSet interface {
 	fmt.Stringer
 	diffFrom(other UTXOSet) (*UTXODiff, error)
 	WithDiff(utxoDiff *UTXODiff) (UTXOSet, error)
-	AddTx(tx *appmessage.MsgTx, blockBlueScore uint64) (ok bool, err error)
+	AddTx(tx *domainmessage.MsgTx, blockBlueScore uint64) (ok bool, err error)
 	clone() UTXOSet
-	Get(outpoint appmessage.Outpoint) (*UTXOEntry, bool)
+	Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool)
 }
 
 // FullUTXOSet represents a full list of transaction outputs and their values
@@ -456,7 +456,7 @@ func (fus *FullUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
 // necessarily means there's an error).
 //
 // This function MUST be called with the DAG lock held.
-func (fus *FullUTXOSet) AddTx(tx *appmessage.MsgTx, blueScore uint64) (isAccepted bool, err error) {
+func (fus *FullUTXOSet) AddTx(tx *domainmessage.MsgTx, blueScore uint64) (isAccepted bool, err error) {
 	if !fus.containsInputs(tx) {
 		return false, nil
 	}
@@ -467,7 +467,7 @@ func (fus *FullUTXOSet) AddTx(tx *appmessage.MsgTx, blueScore uint64) (isAccepte
 
 	isCoinbase := tx.IsCoinBase()
 	for i, txOut := range tx.TxOut {
-		outpoint := *appmessage.NewOutpoint(tx.TxID(), uint32(i))
+		outpoint := *domainmessage.NewOutpoint(tx.TxID(), uint32(i))
 		entry := NewUTXOEntry(txOut, isCoinbase, blueScore)
 		fus.add(outpoint, entry)
 	}
@@ -475,9 +475,9 @@ func (fus *FullUTXOSet) AddTx(tx *appmessage.MsgTx, blueScore uint64) (isAccepte
 	return true, nil
 }
 
-func (fus *FullUTXOSet) containsInputs(tx *appmessage.MsgTx) bool {
+func (fus *FullUTXOSet) containsInputs(tx *domainmessage.MsgTx) bool {
 	for _, txIn := range tx.TxIn {
-		outpoint := *appmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
+		outpoint := *domainmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
 		if !fus.contains(outpoint) {
 			return false
 		}
@@ -492,7 +492,7 @@ func (fus *FullUTXOSet) clone() UTXOSet {
 }
 
 // Get returns the UTXOEntry associated with the given Outpoint, and a boolean indicating if such entry was found
-func (fus *FullUTXOSet) Get(outpoint appmessage.Outpoint) (*UTXOEntry, bool) {
+func (fus *FullUTXOSet) Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
 	utxoEntry, ok := fus.utxoCollection[outpoint]
 	return utxoEntry, ok
 }
@@ -540,7 +540,7 @@ func (dus *DiffUTXOSet) WithDiff(other *UTXODiff) (UTXOSet, error) {
 //
 // If dus.UTXODiff.useMultiset is true, this function MUST be
 // called with the DAG lock held.
-func (dus *DiffUTXOSet) AddTx(tx *appmessage.MsgTx, blockBlueScore uint64) (bool, error) {
+func (dus *DiffUTXOSet) AddTx(tx *domainmessage.MsgTx, blockBlueScore uint64) (bool, error) {
 	if !dus.containsInputs(tx) {
 		return false, nil
 	}
@@ -553,7 +553,7 @@ func (dus *DiffUTXOSet) AddTx(tx *appmessage.MsgTx, blockBlueScore uint64) (bool
 	return true, nil
 }
 
-func (dus *DiffUTXOSet) appendTx(tx *appmessage.MsgTx, blockBlueScore uint64) error {
+func (dus *DiffUTXOSet) appendTx(tx *domainmessage.MsgTx, blockBlueScore uint64) error {
 	for _, txIn := range tx.TxIn {
 		entry, ok := dus.Get(txIn.PreviousOutpoint)
 		if !ok {
@@ -567,7 +567,7 @@ func (dus *DiffUTXOSet) appendTx(tx *appmessage.MsgTx, blockBlueScore uint64) er
 
 	isCoinbase := tx.IsCoinBase()
 	for i, txOut := range tx.TxOut {
-		outpoint := *appmessage.NewOutpoint(tx.TxID(), uint32(i))
+		outpoint := *domainmessage.NewOutpoint(tx.TxID(), uint32(i))
 		entry := NewUTXOEntry(txOut, isCoinbase, blockBlueScore)
 
 		err := dus.UTXODiff.AddEntry(outpoint, entry)
@@ -578,9 +578,9 @@ func (dus *DiffUTXOSet) appendTx(tx *appmessage.MsgTx, blockBlueScore uint64) er
 	return nil
 }
 
-func (dus *DiffUTXOSet) containsInputs(tx *appmessage.MsgTx) bool {
+func (dus *DiffUTXOSet) containsInputs(tx *domainmessage.MsgTx) bool {
 	for _, txIn := range tx.TxIn {
-		outpoint := *appmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
+		outpoint := *domainmessage.NewOutpoint(&txIn.PreviousOutpoint.TxID, txIn.PreviousOutpoint.Index)
 		isInBase := dus.base.contains(outpoint)
 		isInDiffToAdd := dus.UTXODiff.toAdd.contains(outpoint)
 		isInDiffToRemove := dus.UTXODiff.toRemove.contains(outpoint)
@@ -626,7 +626,7 @@ func (dus *DiffUTXOSet) cloneWithoutBase() UTXOSet {
 
 // Get returns the UTXOEntry associated with provided outpoint in this UTXOSet.
 // Returns false in second output if this UTXOEntry was not found
-func (dus *DiffUTXOSet) Get(outpoint appmessage.Outpoint) (*UTXOEntry, bool) {
+func (dus *DiffUTXOSet) Get(outpoint domainmessage.Outpoint) (*UTXOEntry, bool) {
 	if toRemoveEntry, ok := dus.UTXODiff.toRemove.get(outpoint); ok {
 		// An exception is made for entries with unequal blue scores
 		// These are just "updates" to accepted blue score

blockdag/utxoset_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/kaspanet/kaspad/util/subnetworkid"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
@@ -14,10 +14,10 @@ import (
 func TestUTXOCollection(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
 	txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	outpoint0 := *appmessage.NewOutpoint(txID0, 0)
-	outpoint1 := *appmessage.NewOutpoint(txID1, 0)
-	utxoEntry0 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
-	utxoEntry1 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
+	outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
+	outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
+	utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
+	utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
 
 	// For each of the following test cases, we will:
 	// .String() the given collection and compare it to expectedStringWithMultiset
@@ -73,10 +73,10 @@ func TestUTXOCollection(t *testing.T) {
 func TestUTXODiff(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
 	txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	outpoint0 := *appmessage.NewOutpoint(txID0, 0)
-	outpoint1 := *appmessage.NewOutpoint(txID1, 0)
-	utxoEntry0 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
-	utxoEntry1 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
+	outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
+	outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
+	utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
+	utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
 
 	// Test utxoDiff creation
 
@@ -119,9 +119,9 @@ func TestUTXODiff(t *testing.T) {
 // Each test case represents a cell in the two tables outlined in the documentation for utxoDiff.
 func TestUTXODiffRules(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
-	outpoint0 := *appmessage.NewOutpoint(txID0, 0)
-	utxoEntry1 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 10)
-	utxoEntry2 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 20)
+	outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
+	utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 10)
+	utxoEntry2 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 20)
 
 	// For each of the following test cases, we will:
 	// this.diffFrom(other) and compare it to expectedDiffFromResult
@@ -630,10 +630,10 @@ func (dus *DiffUTXOSet) equal(other *DiffUTXOSet) bool {
 func TestFullUTXOSet(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
 	txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	outpoint0 := *appmessage.NewOutpoint(txID0, 0)
-	outpoint1 := *appmessage.NewOutpoint(txID1, 0)
-	txOut0 := &appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
-	txOut1 := &appmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
+	outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
+	outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
+	txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
+	txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
 	utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
 	utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
 	diff := &UTXODiff{
@@ -661,8 +661,8 @@ func TestFullUTXOSet(t *testing.T) {
 	}
 
 	// Test fullUTXOSet addTx
-	txIn0 := &appmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: appmessage.Outpoint{TxID: *txID0, Index: 0}, Sequence: 0}
-	transaction0 := appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{txIn0}, []*appmessage.TxOut{txOut0})
+	txIn0 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: domainmessage.Outpoint{TxID: *txID0, Index: 0}, Sequence: 0}
+	transaction0 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn0}, []*domainmessage.TxOut{txOut0})
 	if isAccepted, err := emptySet.AddTx(transaction0, 0); err != nil {
 		t.Errorf("AddTx unexpectedly failed: %s", err)
 	} else if isAccepted {
@@ -694,10 +694,10 @@ func TestFullUTXOSet(t *testing.T) {
 func TestDiffUTXOSet(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
 	txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	outpoint0 := *appmessage.NewOutpoint(txID0, 0)
-	outpoint1 := *appmessage.NewOutpoint(txID1, 0)
-	txOut0 := &appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
-	txOut1 := &appmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
+	outpoint0 := *domainmessage.NewOutpoint(txID0, 0)
+	outpoint1 := *domainmessage.NewOutpoint(txID1, 0)
+	txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}
+	txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}
 	utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
 	utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
 	diff := &UTXODiff{
@@ -946,29 +946,29 @@ func TestUTXOSetDiffRules(t *testing.T) {
 
 // TestDiffUTXOSet_addTx makes sure that diffUTXOSet addTx works as expected
 func TestDiffUTXOSet_addTx(t *testing.T) {
-	txOut0 := &appmessage.TxOut{ScriptPubKey: []byte{0}, Value: 10}
+	txOut0 := &domainmessage.TxOut{ScriptPubKey: []byte{0}, Value: 10}
 	utxoEntry0 := NewUTXOEntry(txOut0, true, 0)
-	coinbaseTX := appmessage.NewSubnetworkMsgTx(1, []*appmessage.TxIn{}, []*appmessage.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
+	coinbaseTX := domainmessage.NewSubnetworkMsgTx(1, []*domainmessage.TxIn{}, []*domainmessage.TxOut{txOut0}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
 
 	// transaction1 spends coinbaseTX
 	id1 := coinbaseTX.TxID()
-	outpoint1 := *appmessage.NewOutpoint(id1, 0)
-	txIn1 := &appmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint1, Sequence: 0}
-	txOut1 := &appmessage.TxOut{ScriptPubKey: []byte{1}, Value: 20}
+	outpoint1 := *domainmessage.NewOutpoint(id1, 0)
+	txIn1 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint1, Sequence: 0}
+	txOut1 := &domainmessage.TxOut{ScriptPubKey: []byte{1}, Value: 20}
 	utxoEntry1 := NewUTXOEntry(txOut1, false, 1)
-	transaction1 := appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{txIn1}, []*appmessage.TxOut{txOut1})
+	transaction1 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn1}, []*domainmessage.TxOut{txOut1})
 
 	// transaction2 spends transaction1
 	id2 := transaction1.TxID()
-	outpoint2 := *appmessage.NewOutpoint(id2, 0)
-	txIn2 := &appmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint2, Sequence: 0}
-	txOut2 := &appmessage.TxOut{ScriptPubKey: []byte{2}, Value: 30}
+	outpoint2 := *domainmessage.NewOutpoint(id2, 0)
+	txIn2 := &domainmessage.TxIn{SignatureScript: []byte{}, PreviousOutpoint: outpoint2, Sequence: 0}
+	txOut2 := &domainmessage.TxOut{ScriptPubKey: []byte{2}, Value: 30}
 	utxoEntry2 := NewUTXOEntry(txOut2, false, 2)
-	transaction2 := appmessage.NewNativeMsgTx(1, []*appmessage.TxIn{txIn2}, []*appmessage.TxOut{txOut2})
+	transaction2 := domainmessage.NewNativeMsgTx(1, []*domainmessage.TxIn{txIn2}, []*domainmessage.TxOut{txOut2})
 
 	// outpoint3 is the outpoint for transaction2
 	id3 := transaction2.TxID()
-	outpoint3 := *appmessage.NewOutpoint(id3, 0)
+	outpoint3 := *domainmessage.NewOutpoint(id3, 0)
 
 	// For each of the following test cases, we will:
 	// 1. startSet.addTx() all the transactions in toAdd, in order, with the initial block height startHeight
@@ -977,14 +977,14 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 		name        string
 		startSet    *DiffUTXOSet
 		startHeight uint64
-		toAdd       []*appmessage.MsgTx
+		toAdd       []*domainmessage.MsgTx
 		expectedSet *DiffUTXOSet
 	}{
 		{
 			name:        "add coinbase transaction to empty set",
 			startSet:    NewDiffUTXOSet(NewFullUTXOSet(), NewUTXODiff()),
 			startHeight: 0,
-			toAdd:       []*appmessage.MsgTx{coinbaseTX},
+			toAdd:       []*domainmessage.MsgTx{coinbaseTX},
 			expectedSet: &DiffUTXOSet{
 				base: &FullUTXOSet{utxoCollection: utxoCollection{}},
 				UTXODiff: &UTXODiff{
@@ -997,7 +997,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 			name:        "add regular transaction to empty set",
 			startSet:    NewDiffUTXOSet(NewFullUTXOSet(), NewUTXODiff()),
 			startHeight: 0,
-			toAdd:       []*appmessage.MsgTx{transaction1},
+			toAdd:       []*domainmessage.MsgTx{transaction1},
 			expectedSet: &DiffUTXOSet{
 				base: &FullUTXOSet{utxoCollection: utxoCollection{}},
 				UTXODiff: &UTXODiff{
@@ -1016,7 +1016,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 				},
 			},
 			startHeight: 1,
-			toAdd:       []*appmessage.MsgTx{transaction1},
+			toAdd:       []*domainmessage.MsgTx{transaction1},
 			expectedSet: &DiffUTXOSet{
 				base: &FullUTXOSet{utxoCollection: utxoCollection{outpoint1: utxoEntry0}},
 				UTXODiff: &UTXODiff{
@@ -1035,7 +1035,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 				},
 			},
 			startHeight: 1,
-			toAdd:       []*appmessage.MsgTx{transaction1},
+			toAdd:       []*domainmessage.MsgTx{transaction1},
 			expectedSet: &DiffUTXOSet{
 				base: NewFullUTXOSet(),
 				UTXODiff: &UTXODiff{
@@ -1054,7 +1054,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 				},
 			},
 			startHeight: 1,
-			toAdd:       []*appmessage.MsgTx{transaction1},
+			toAdd:       []*domainmessage.MsgTx{transaction1},
 			expectedSet: &DiffUTXOSet{
 				base: NewFullUTXOSet(),
 				UTXODiff: &UTXODiff{
@@ -1073,7 +1073,7 @@ func TestDiffUTXOSet_addTx(t *testing.T) {
 				},
 			},
 			startHeight: 1,
-			toAdd:       []*appmessage.MsgTx{transaction1, transaction2},
+			toAdd:       []*domainmessage.MsgTx{transaction1, transaction2},
 			expectedSet: &DiffUTXOSet{
 				base: &FullUTXOSet{utxoCollection: utxoCollection{outpoint1: utxoEntry0}},
 				UTXODiff: &UTXODiff{
@@ -1125,16 +1125,16 @@ func (dus *DiffUTXOSet) collection() (utxoCollection, error) {
 func TestUTXOSetAddEntry(t *testing.T) {
 	txID0, _ := daghash.NewTxIDFromStr("0000000000000000000000000000000000000000000000000000000000000000")
 	txID1, _ := daghash.NewTxIDFromStr("1111111111111111111111111111111111111111111111111111111111111111")
-	outpoint0 := appmessage.NewOutpoint(txID0, 0)
-	outpoint1 := appmessage.NewOutpoint(txID1, 0)
-	utxoEntry0 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
-	utxoEntry1 := NewUTXOEntry(&appmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
+	outpoint0 := domainmessage.NewOutpoint(txID0, 0)
+	outpoint1 := domainmessage.NewOutpoint(txID1, 0)
+	utxoEntry0 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 10}, true, 0)
+	utxoEntry1 := NewUTXOEntry(&domainmessage.TxOut{ScriptPubKey: []byte{}, Value: 20}, false, 1)
 
 	utxoDiff := NewUTXODiff()
 
 	tests := []struct {
 		name             string
-		outpointToAdd    *appmessage.Outpoint
+		outpointToAdd    *domainmessage.Outpoint
 		utxoEntryToAdd   *UTXOEntry
 		expectedUTXODiff *UTXODiff
 		expectedError    string

blockdag/validate.go

@@ -6,17 +6,16 @@ package blockdag
 
 import (
 	"fmt"
-	"github.com/kaspanet/go-secp256k1"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"math"
 	"sort"
-
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/kaspanet/kaspad/domain/txscript"
-	"github.com/kaspanet/kaspad/util/mstime"
+	"time"
 
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/domainmessage"
+	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
@@ -47,7 +46,7 @@ const (
 
 // isNullOutpoint determines whether or not a previous transaction outpoint
 // is set.
-func isNullOutpoint(outpoint *appmessage.Outpoint) bool {
+func isNullOutpoint(outpoint *domainmessage.Outpoint) bool {
 	if outpoint.Index == math.MaxUint32 && outpoint.TxID == daghash.ZeroTxID {
 		return true
 	}
@@ -128,55 +127,13 @@ func CalcBlockSubsidy(blueScore uint64, dagParams *dagconfig.Params) uint64 {
 // CheckTransactionSanity performs some preliminary checks on a transaction to
 // ensure it is sane. These checks are context free.
 func CheckTransactionSanity(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID) error {
-	err := checkTransactionInputCount(tx)
-	if err != nil {
-		return err
-	}
-	err = checkTransactionAmountRanges(tx)
-	if err != nil {
-		return err
-	}
-	err = checkDuplicateTransactionInputs(tx)
-	if err != nil {
-		return err
-	}
-	err = checkCoinbaseLength(tx)
-	if err != nil {
-		return err
-	}
-	err = checkTransactionPayloadHash(tx)
-	if err != nil {
-		return err
-	}
-	err = checkGasInBuiltInOrNativeTransactions(tx)
-	if err != nil {
-		return err
-	}
-	err = checkSubnetworkRegistryTransaction(tx)
-	if err != nil {
-		return err
-	}
-	err = checkNativeTransactionPayload(tx)
-	if err != nil {
-		return err
-	}
-	err = checkTransactionSubnetwork(tx, subnetworkID)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func checkTransactionInputCount(tx *util.Tx) error {
-	// A non-coinbase transaction must have at least one input.
+	isCoinbase := tx.IsCoinBase()
+	// A transaction must have at least one input.
 	msgTx := tx.MsgTx()
-	if !tx.IsCoinBase() && len(msgTx.TxIn) == 0 {
+	if !isCoinbase && len(msgTx.TxIn) == 0 {
 		return ruleError(ErrNoTxInputs, "transaction has no inputs")
 	}
-	return nil
-}
 
-func checkTransactionAmountRanges(tx *util.Tx) error {
 	// Ensure the transaction amounts are in range. Each transaction
 	// output must not be negative or more than the max allowed per
 	// transaction. Also, the total of all outputs must abide by the same
@@ -184,7 +141,7 @@ func checkTransactionAmountRanges(tx *util.Tx) error {
 	// as a sompi. One kaspa is a quantity of sompi as defined by the
 	// SompiPerKaspa constant.
 	var totalSompi uint64
-	for _, txOut := range tx.MsgTx().TxOut {
+	for _, txOut := range msgTx.TxOut {
 		sompi := txOut.Value
 		if sompi > util.MaxSompi {
 			str := fmt.Sprintf("transaction output value of %d is "+
@@ -212,25 +169,20 @@ func checkTransactionAmountRanges(tx *util.Tx) error {
 			return ruleError(ErrBadTxOutValue, str)
 		}
 	}
-	return nil
-}
 
-func checkDuplicateTransactionInputs(tx *util.Tx) error {
-	existingTxOut := make(map[appmessage.Outpoint]struct{})
-	for _, txIn := range tx.MsgTx().TxIn {
+	// Check for duplicate transaction inputs.
+	existingTxOut := make(map[domainmessage.Outpoint]struct{})
+	for _, txIn := range msgTx.TxIn {
 		if _, exists := existingTxOut[txIn.PreviousOutpoint]; exists {
 			return ruleError(ErrDuplicateTxInputs, "transaction "+
 				"contains duplicate inputs")
 		}
 		existingTxOut[txIn.PreviousOutpoint] = struct{}{}
 	}
-	return nil
-}
 
-func checkCoinbaseLength(tx *util.Tx) error {
 	// Coinbase payload length must not exceed the max length.
-	if tx.IsCoinBase() {
-		payloadLen := len(tx.MsgTx().Payload)
+	if isCoinbase {
+		payloadLen := len(msgTx.Payload)
 		if payloadLen > MaxCoinbasePayloadLen {
 			str := fmt.Sprintf("coinbase transaction payload length "+
 				"of %d is out of range (max: %d)",
@@ -240,7 +192,7 @@ func checkCoinbaseLength(tx *util.Tx) error {
 	} else {
 		// Previous transaction outputs referenced by the inputs to this
 		// transaction must not be null.
-		for _, txIn := range tx.MsgTx().TxIn {
+		for _, txIn := range msgTx.TxIn {
 			if isNullOutpoint(&txIn.PreviousOutpoint) {
 				return ruleError(ErrBadTxInput, "transaction "+
 					"input refers to previous output that "+
@@ -248,11 +200,8 @@ func checkCoinbaseLength(tx *util.Tx) error {
 			}
 		}
 	}
-	return nil
-}
 
-func checkTransactionPayloadHash(tx *util.Tx) error {
-	msgTx := tx.MsgTx()
+	// Check payload's hash
 	if !msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
 		payloadHash := daghash.DoubleHashH(msgTx.Payload)
 		if !msgTx.PayloadHash.IsEqual(&payloadHash) {
@@ -261,41 +210,32 @@ func checkTransactionPayloadHash(tx *util.Tx) error {
 	} else if msgTx.PayloadHash != nil {
 		return ruleError(ErrInvalidPayloadHash, "unexpected non-empty payload hash in native subnetwork")
 	}
-	return nil
-}
 
-func checkGasInBuiltInOrNativeTransactions(tx *util.Tx) error {
 	// Transactions in native, registry and coinbase subnetworks must have Gas = 0
-	msgTx := tx.MsgTx()
-	if msgTx.SubnetworkID.IsBuiltInOrNative() && msgTx.Gas > 0 {
+	if (msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) ||
+		msgTx.SubnetworkID.IsBuiltIn()) &&
+		msgTx.Gas > 0 {
+
 		return ruleError(ErrInvalidGas, "transaction in the native or "+
 			"registry subnetworks has gas > 0 ")
 	}
-	return nil
-}
 
-func checkSubnetworkRegistryTransaction(tx *util.Tx) error {
-	if tx.MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) {
-		err := validateSubnetworkRegistryTransaction(tx.MsgTx())
+	if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) {
+		err := validateSubnetworkRegistryTransaction(msgTx)
 		if err != nil {
 			return err
 		}
 	}
-	return nil
-}
 
-func checkNativeTransactionPayload(tx *util.Tx) error {
-	msgTx := tx.MsgTx()
-	if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) && len(msgTx.Payload) > 0 {
-		return ruleError(ErrInvalidPayload, "transaction in the native subnetwork includes a payload")
+	if msgTx.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) &&
+		len(msgTx.Payload) > 0 {
+
+		return ruleError(ErrInvalidPayload,
+			"transaction in the native subnetwork includes a payload")
 	}
-	return nil
-}
 
-func checkTransactionSubnetwork(tx *util.Tx, subnetworkID *subnetworkid.SubnetworkID) error {
 	// If we are a partial node, only transactions on built in subnetworks
 	// or our own subnetwork may have a payload
-	msgTx := tx.MsgTx()
 	isLocalNodeFull := subnetworkID == nil
 	shouldTxBeFull := msgTx.SubnetworkID.IsBuiltIn() ||
 		msgTx.SubnetworkID.IsEqual(subnetworkID)
@@ -304,6 +244,7 @@ func checkTransactionSubnetwork(tx *util.Tx, subnetworkID *subnetworkid.Subnetwo
 			"transaction that was expected to be partial has a payload "+
 				"with length > 0")
 	}
+
 	return nil
 }
 
@@ -314,7 +255,7 @@ func checkTransactionSubnetwork(tx *util.Tx, subnetworkID *subnetworkid.Subnetwo
 // The flags modify the behavior of this function as follows:
 //  - BFNoPoWCheck: The check to ensure the block hash is less than the target
 //    difficulty is not performed.
-func (dag *BlockDAG) checkProofOfWork(header *appmessage.BlockHeader, flags BehaviorFlags) error {
+func (dag *BlockDAG) checkProofOfWork(header *domainmessage.BlockHeader, flags BehaviorFlags) error {
 	// The target difficulty must be larger than zero.
 	target := util.CompactToBig(header.Bits)
 	if target.Sign() <= 0 {
@@ -354,9 +295,9 @@ func ValidateTxMass(tx *util.Tx, utxoSet UTXOSet) error {
 	if err != nil {
 		return err
 	}
-	if txMass > appmessage.MaxMassPerBlock {
+	if txMass > domainmessage.MaxMassPerBlock {
 		str := fmt.Sprintf("tx %s has mass %d, which is above the "+
-			"allowed limit of %d", tx.ID(), txMass, appmessage.MaxMassPerBlock)
+			"allowed limit of %d", tx.ID(), txMass, domainmessage.MaxMassPerBlock)
 		return ruleError(ErrTxMassTooHigh, str)
 	}
 	return nil
@@ -380,9 +321,9 @@ func CalcBlockMass(pastUTXO UTXOSet, transactions []*util.Tx) (uint64, error) {
 
 		// We could potentially overflow the accumulator so check for
 		// overflow as well.
-		if totalMass < txMass || totalMass > appmessage.MaxMassPerBlock {
+		if totalMass < txMass || totalMass > domainmessage.MaxMassPerBlock {
 			str := fmt.Sprintf("block has total mass %d, which is "+
-				"above the allowed limit of %d", totalMass, appmessage.MaxMassPerBlock)
+				"above the allowed limit of %d", totalMass, domainmessage.MaxMassPerBlock)
 			return 0, ruleError(ErrBlockMassTooHigh, str)
 		}
 	}
@@ -451,32 +392,41 @@ func CalcTxMass(tx *util.Tx, previousScriptPubKeys [][]byte) uint64 {
 //
 // The flags do not modify the behavior of this function directly, however they
 // are needed to pass along to checkProofOfWork.
-func (dag *BlockDAG) checkBlockHeaderSanity(block *util.Block, flags BehaviorFlags) error {
+func (dag *BlockDAG) checkBlockHeaderSanity(block *util.Block, flags BehaviorFlags) (delay time.Duration, err error) {
 	// Ensure the proof of work bits in the block header is in min/max range
 	// and the block hash is less than the target value described by the
 	// bits.
 	header := &block.MsgBlock().Header
-	err := dag.checkProofOfWork(header, flags)
+	err = dag.checkProofOfWork(header, flags)
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	if len(header.ParentHashes) == 0 {
 		if !header.BlockHash().IsEqual(dag.Params.GenesisHash) {
-			return ruleError(ErrNoParents, "block has no parents")
+			return 0, ruleError(ErrNoParents, "block has no parents")
 		}
 	} else {
 		err = checkBlockParentsOrder(header)
 		if err != nil {
-			return err
+			return 0, err
 		}
 	}
 
-	return nil
+	// Ensure the block time is not too far in the future. If it's too far, return
+	// the duration of time that should be waited before the block becomes valid.
+	// This check needs to be last as it does not return an error but rather marks the
+	// header as delayed (and valid).
+	maxTimestamp := dag.Now().Add(time.Duration(dag.TimestampDeviationTolerance) * dag.Params.TargetTimePerBlock)
+	if header.Timestamp.After(maxTimestamp) {
+		return header.Timestamp.Sub(maxTimestamp), nil
+	}
+
+	return 0, nil
 }
 
 //checkBlockParentsOrder ensures that the block's parents are ordered by hash
-func checkBlockParentsOrder(header *appmessage.BlockHeader) error {
+func checkBlockParentsOrder(header *domainmessage.BlockHeader) error {
 	sortedHashes := make([]*daghash.Hash, header.NumParentBlocks())
 	for i, hash := range header.ParentHashes {
 		sortedHashes[i] = hash
@@ -495,56 +445,56 @@ func checkBlockParentsOrder(header *appmessage.BlockHeader) error {
 //
 // The flags do not modify the behavior of this function directly, however they
 // are needed to pass along to checkBlockHeaderSanity.
-func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) error {
-	err := dag.checkBlockHeaderSanity(block, flags)
+func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) (time.Duration, error) {
+	delay, err := dag.checkBlockHeaderSanity(block, flags)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockContainsAtLeastOneTransaction(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockContainsLessThanMaxBlockMassTransactions(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkFirstBlockTransactionIsCoinbase(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockContainsOnlyOneCoinbase(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockTransactionOrder(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkNoNonNativeTransactions(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockTransactionSanity(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	err = dag.checkBlockHashMerkleRoot(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	// The following check will be fairly quick since the transaction IDs
 	// are already cached due to building the merkle tree above.
 	err = dag.checkBlockDuplicateTransactions(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
 
 	err = dag.checkBlockDoubleSpends(block)
 	if err != nil {
-		return err
+		return 0, err
 	}
-	return nil
+	return delay, nil
 }
 
 func (dag *BlockDAG) checkBlockContainsAtLeastOneTransaction(block *util.Block) error {
@@ -562,9 +512,9 @@ func (dag *BlockDAG) checkBlockContainsLessThanMaxBlockMassTransactions(block *u
 	// else it is certainly over the block mass limit.
 	transactions := block.Transactions()
 	numTx := len(transactions)
-	if numTx > appmessage.MaxMassPerBlock {
+	if numTx > domainmessage.MaxMassPerBlock {
 		str := fmt.Sprintf("block contains too many transactions - "+
-			"got %d, max %d", numTx, appmessage.MaxMassPerBlock)
+			"got %d, max %d", numTx, domainmessage.MaxMassPerBlock)
 		return ruleError(ErrBlockMassTooHigh, str)
 	}
 	return nil
@@ -658,7 +608,7 @@ func (dag *BlockDAG) checkBlockDuplicateTransactions(block *util.Block) error {
 }
 
 func (dag *BlockDAG) checkBlockDoubleSpends(block *util.Block) error {
-	usedOutpoints := make(map[appmessage.Outpoint]*daghash.TxID)
+	usedOutpoints := make(map[domainmessage.Outpoint]*daghash.TxID)
 	transactions := block.Transactions()
 	for _, tx := range transactions {
 		for _, txIn := range tx.MsgTx().TxIn {
@@ -681,7 +631,7 @@ func (dag *BlockDAG) checkBlockDoubleSpends(block *util.Block) error {
 //  - BFFastAdd: No checks are performed.
 //
 // This function MUST be called with the dag state lock held (for writes).
-func (dag *BlockDAG) checkBlockHeaderContext(header *appmessage.BlockHeader, bluestParent *blockNode, fastAdd bool) error {
+func (dag *BlockDAG) checkBlockHeaderContext(header *domainmessage.BlockHeader, bluestParent *blockNode, fastAdd bool) error {
 	if !fastAdd {
 		if err := dag.validateDifficulty(header, bluestParent); err != nil {
 			return err
@@ -694,7 +644,7 @@ func (dag *BlockDAG) checkBlockHeaderContext(header *appmessage.BlockHeader, blu
 	return nil
 }
 
-func validateMedianTime(dag *BlockDAG, header *appmessage.BlockHeader, bluestParent *blockNode) error {
+func validateMedianTime(dag *BlockDAG, header *domainmessage.BlockHeader, bluestParent *blockNode) error {
 	if !header.IsGenesis() {
 		// Ensure the timestamp for the block header is not before the
 		// median time of the last several blocks (medianTimeBlocks).
@@ -708,7 +658,7 @@ func validateMedianTime(dag *BlockDAG, header *appmessage.BlockHeader, bluestPar
 	return nil
 }
 
-func (dag *BlockDAG) validateDifficulty(header *appmessage.BlockHeader, bluestParent *blockNode) error {
+func (dag *BlockDAG) validateDifficulty(header *domainmessage.BlockHeader, bluestParent *blockNode) error {
 	// Ensure the difficulty specified in the block header matches
 	// the calculated difficulty based on the previous block and
 	// difficulty retarget rules.
@@ -724,7 +674,7 @@ func (dag *BlockDAG) validateDifficulty(header *appmessage.BlockHeader, bluestPa
 }
 
 // validateParents validates that no parent is an ancestor of another parent, and no parent is finalized
-func (dag *BlockDAG) validateParents(blockHeader *appmessage.BlockHeader, parents blockSet) error {
+func (dag *BlockDAG) validateParents(blockHeader *domainmessage.BlockHeader, parents blockSet) error {
 	for parentA := range parents {
 		// isFinalized might be false-negative because node finality status is
 		// updated in a separate goroutine. This is why later the block is
@@ -767,16 +717,11 @@ func (dag *BlockDAG) validateParents(blockHeader *appmessage.BlockHeader, parent
 // for how the flags modify its behavior.
 //
 // This function MUST be called with the dag state lock held (for writes).
-func (dag *BlockDAG) checkBlockContext(block *util.Block, flags BehaviorFlags) error {
-	parents, err := lookupParentNodes(block, dag)
-	if err != nil {
-		return dag.handleLookupParentNodesError(block, err)
-	}
-
+func (dag *BlockDAG) checkBlockContext(block *util.Block, parents blockSet, flags BehaviorFlags) error {
 	bluestParent := parents.bluest()
 	fastAdd := flags&BFFastAdd == BFFastAdd
 
-	err = dag.validateParents(&block.MsgBlock().Header, parents)
+	err := dag.validateParents(&block.MsgBlock().Header, parents)
 	if err != nil {
 		return err
 	}
@@ -790,26 +735,10 @@ func (dag *BlockDAG) checkBlockContext(block *util.Block, flags BehaviorFlags) e
 	return nil
 }
 
-func (dag *BlockDAG) handleLookupParentNodesError(block *util.Block, err error) error {
-	var ruleErr RuleError
-	if ok := errors.As(err, &ruleErr); ok && ruleErr.ErrorCode == ErrInvalidAncestorBlock {
-		err := dag.addNodeToIndexWithInvalidAncestor(block)
-		if err != nil {
-			return err
-		}
-	}
-	return err
-}
-
-func (dag *BlockDAG) checkBlockTransactionsFinalized(block *util.Block, node *blockNode, flags BehaviorFlags) error {
-	fastAdd := flags&BFFastAdd == BFFastAdd || dag.index.NodeStatus(node).KnownValid()
-	if fastAdd {
-		return nil
-	}
-
+func (dag *BlockDAG) validateAllTxsFinalized(block *util.Block, node *blockNode, bluestParent *blockNode) error {
 	blockTime := block.MsgBlock().Header.Timestamp
 	if !block.IsGenesis() {
-		blockTime = node.selectedParent.PastMedianTime(dag)
+		blockTime = bluestParent.PastMedianTime(dag)
 	}
 
 	// Ensure all transactions in the block are finalized.
@@ -836,9 +765,9 @@ func (dag *BlockDAG) checkBlockTransactionsFinalized(block *util.Block, node *bl
 func ensureNoDuplicateTx(utxoSet UTXOSet, transactions []*util.Tx) error {
 	// Fetch utxos for all of the transaction ouputs in this block.
 	// Typically, there will not be any utxos for any of the outputs.
-	fetchSet := make(map[appmessage.Outpoint]struct{})
+	fetchSet := make(map[domainmessage.Outpoint]struct{})
 	for _, tx := range transactions {
-		prevOut := appmessage.Outpoint{TxID: *tx.ID()}
+		prevOut := domainmessage.Outpoint{TxID: *tx.ID()}
 		for txOutIdx := range tx.MsgTx().TxOut {
 			prevOut.Index = uint32(txOutIdx)
 			fetchSet[prevOut] = struct{}{}
@@ -945,7 +874,7 @@ func CheckTransactionInputsAndCalulateFee(tx *util.Tx, txBlueScore uint64, utxoS
 	return txFeeInSompi, nil
 }
 
-func validateCoinbaseMaturity(dagParams *dagconfig.Params, entry *UTXOEntry, txBlueScore uint64, txIn *appmessage.TxIn) error {
+func validateCoinbaseMaturity(dagParams *dagconfig.Params, entry *UTXOEntry, txBlueScore uint64, txIn *domainmessage.TxIn) error {
 	// Ensure the transaction is not spending coins which have not
 	// yet reached the required coinbase maturity.
 	if entry.IsCoinbase() {
@@ -1050,7 +979,7 @@ func (dag *BlockDAG) checkConnectToPastUTXO(block *blockNode, pastUTXO UTXOSet,
 			// A transaction can only be included within a block
 			// once the sequence locks of *all* its inputs are
 			// active.
-			sequenceLock, err := dag.calcSequenceLock(block, pastUTXO, tx)
+			sequenceLock, err := dag.calcSequenceLock(block, pastUTXO, tx, false)
 			if err != nil {
 				return nil, err
 			}
@@ -1075,18 +1004,6 @@ func (dag *BlockDAG) checkConnectToPastUTXO(block *blockNode, pastUTXO UTXOSet,
 	return feeData, nil
 }
 
-func (node *blockNode) validateUTXOCommitment(multiset *secp256k1.MultiSet) error {
-	calculatedMultisetHash := daghash.Hash(*multiset.Finalize())
-	if !calculatedMultisetHash.IsEqual(node.utxoCommitment) {
-		str := fmt.Sprintf("block %s UTXO commitment is invalid - block "+
-			"header indicates %s, but calculated value is %s", node.hash,
-			node.utxoCommitment, calculatedMultisetHash)
-		return ruleError(ErrBadUTXOCommitment, str)
-	}
-
-	return nil
-}
-
 // CheckConnectBlockTemplate fully validates that connecting the passed block to
 // the DAG does not violate any consensus rules, aside from the proof of
 // work requirement.
@@ -1108,17 +1025,21 @@ func (dag *BlockDAG) CheckConnectBlockTemplateNoLock(block *util.Block) error {
 
 	header := block.MsgBlock().Header
 
-	err := dag.checkBlockSanity(block, flags)
+	delay, err := dag.checkBlockSanity(block, flags)
 	if err != nil {
 		return err
 	}
 
-	_, isDelayed := dag.shouldBlockBeDelayed(block)
-	if isDelayed {
+	if delay != 0 {
 		return errors.Errorf("Block timestamp is too far in the future")
 	}
 
-	err = dag.checkBlockContext(block, flags)
+	parents, err := lookupParentNodes(block, dag)
+	if err != nil {
+		return err
+	}
+
+	err = dag.checkBlockContext(block, parents, flags)
 	if err != nil {
 		return err
 	}
@@ -1130,24 +1051,3 @@ func (dag *BlockDAG) CheckConnectBlockTemplateNoLock(block *util.Block) error {
 
 	return err
 }
-
-func (dag *BlockDAG) checkDuplicateBlock(blockHash *daghash.Hash, flags BehaviorFlags) error {
-	wasBlockStored := flags&BFWasStored == BFWasStored
-	if dag.IsInDAG(blockHash) && !wasBlockStored {
-		str := fmt.Sprintf("already have block %s", blockHash)
-		return ruleError(ErrDuplicateBlock, str)
-	}
-
-	// The block must not already exist as an orphan.
-	if _, exists := dag.orphans[*blockHash]; exists {
-		str := fmt.Sprintf("already have block (orphan) %s", blockHash)
-		return ruleError(ErrDuplicateBlock, str)
-	}
-
-	if dag.isKnownDelayedBlock(blockHash) {
-		str := fmt.Sprintf("already have block (delayed) %s", blockHash)
-		return ruleError(ErrDuplicateBlock, str)
-	}
-
-	return nil
-}

blockdag/validate_test.go

@@ -14,8 +14,8 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
@@ -172,13 +172,16 @@ func TestCheckBlockSanity(t *testing.T) {
 	if len(block.Transactions()) < 3 {
 		t.Fatalf("Too few transactions in block, expect at least 3, got %v", len(block.Transactions()))
 	}
-	err = dag.checkBlockSanity(block, BFNone)
+	delay, err := dag.checkBlockSanity(block, BFNone)
 	if err != nil {
 		t.Errorf("CheckBlockSanity: %v", err)
 	}
+	if delay != 0 {
+		t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
+	}
 	// Test with block with wrong transactions sorting order
 	blockWithWrongTxOrder := util.NewBlock(&BlockWithWrongTxOrder)
-	err = dag.checkBlockSanity(blockWithWrongTxOrder, BFNone)
+	delay, err = dag.checkBlockSanity(blockWithWrongTxOrder, BFNone)
 	if err == nil {
 		t.Errorf("CheckBlockSanity: transactions disorder is not detected")
 	}
@@ -189,9 +192,12 @@ func TestCheckBlockSanity(t *testing.T) {
 		t.Errorf("CheckBlockSanity: wrong error returned, expect ErrTransactionsNotSorted, got"+
 			" %v, err %s", ruleErr.ErrorCode, err)
 	}
+	if delay != 0 {
+		t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
+	}
 
-	var invalidParentsOrderBlock = appmessage.MsgBlock{
-		Header: appmessage.BlockHeader{
+	var invalidParentsOrderBlock = domainmessage.MsgBlock{
+		Header: domainmessage.BlockHeader{
 			Version: 0x10000000,
 			ParentHashes: []*daghash.Hash{
 				{
@@ -229,12 +235,12 @@ func TestCheckBlockSanity(t *testing.T) {
 			Bits:      0x207fffff,
 			Nonce:     0x1,
 		},
-		Transactions: []*appmessage.MsgTx{
+		Transactions: []*domainmessage.MsgTx{
 			{
 				Version: 1,
-				TxIn: []*appmessage.TxIn{
+				TxIn: []*domainmessage.TxIn{
 					{
-						PreviousOutpoint: appmessage.Outpoint{
+						PreviousOutpoint: domainmessage.Outpoint{
 							TxID:  daghash.TxID{},
 							Index: 0xffffffff,
 						},
@@ -246,7 +252,7 @@ func TestCheckBlockSanity(t *testing.T) {
 						Sequence: math.MaxUint64,
 					},
 				},
-				TxOut: []*appmessage.TxOut{
+				TxOut: []*domainmessage.TxOut{
 					{
 						Value: 0x12a05f200, // 5000000000
 						ScriptPubKey: []byte{
@@ -259,9 +265,9 @@ func TestCheckBlockSanity(t *testing.T) {
 			},
 			{
 				Version: 1,
-				TxIn: []*appmessage.TxIn{
+				TxIn: []*domainmessage.TxIn{
 					{
-						PreviousOutpoint: appmessage.Outpoint{
+						PreviousOutpoint: domainmessage.Outpoint{
 							TxID: daghash.TxID([32]byte{
 								0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
 								0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@@ -296,7 +302,7 @@ func TestCheckBlockSanity(t *testing.T) {
 						Sequence: math.MaxUint64,
 					},
 				},
-				TxOut: []*appmessage.TxOut{
+				TxOut: []*domainmessage.TxOut{
 					{
 						Value: 0x2123e300, // 556000000
 						ScriptPubKey: []byte{
@@ -329,9 +335,9 @@ func TestCheckBlockSanity(t *testing.T) {
 			},
 			{
 				Version: 1,
-				TxIn: []*appmessage.TxIn{
+				TxIn: []*domainmessage.TxIn{
 					{
-						PreviousOutpoint: appmessage.Outpoint{
+						PreviousOutpoint: domainmessage.Outpoint{
 							TxID: daghash.TxID([32]byte{
 								0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
 								0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@@ -365,7 +371,7 @@ func TestCheckBlockSanity(t *testing.T) {
 						Sequence: math.MaxUint64,
 					},
 				},
-				TxOut: []*appmessage.TxOut{
+				TxOut: []*domainmessage.TxOut{
 					{
 						Value: 0xf4240, // 1000000
 						ScriptPubKey: []byte{
@@ -398,9 +404,9 @@ func TestCheckBlockSanity(t *testing.T) {
 			},
 			{
 				Version: 1,
-				TxIn: []*appmessage.TxIn{
+				TxIn: []*domainmessage.TxIn{
 					{
-						PreviousOutpoint: appmessage.Outpoint{
+						PreviousOutpoint: domainmessage.Outpoint{
 							TxID: daghash.TxID([32]byte{
 								0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
 								0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@@ -435,7 +441,7 @@ func TestCheckBlockSanity(t *testing.T) {
 						Sequence: math.MaxUint64,
 					},
 				},
-				TxOut: []*appmessage.TxOut{
+				TxOut: []*domainmessage.TxOut{
 					{
 						Value: 0xf4240, // 1000000
 						ScriptPubKey: []byte{
@@ -457,7 +463,7 @@ func TestCheckBlockSanity(t *testing.T) {
 	}
 
 	utilInvalidBlock := util.NewBlock(&invalidParentsOrderBlock)
-	err = dag.checkBlockSanity(utilInvalidBlock, BFNone)
+	delay, err = dag.checkBlockSanity(utilInvalidBlock, BFNone)
 	if err == nil {
 		t.Errorf("CheckBlockSanity: error is nil when it shouldn't be")
 	}
@@ -467,6 +473,21 @@ func TestCheckBlockSanity(t *testing.T) {
 	} else if rError.ErrorCode != ErrWrongParentsOrder {
 		t.Errorf("CheckBlockSanity: Expected error was ErrWrongParentsOrder but got %v", err)
 	}
+	if delay != 0 {
+		t.Errorf("CheckBlockSanity: unexpected return %s delay", delay)
+	}
+
+	blockInTheFuture := Block100000
+	expectedDelay := 10 * time.Second
+	deviationTolerance := time.Duration(dag.TimestampDeviationTolerance) * dag.Params.TargetTimePerBlock
+	blockInTheFuture.Header.Timestamp = dag.Now().Add(deviationTolerance + expectedDelay)
+	delay, err = dag.checkBlockSanity(util.NewBlock(&blockInTheFuture), BFNoPoWCheck)
+	if err != nil {
+		t.Errorf("CheckBlockSanity: %v", err)
+	}
+	if delay != expectedDelay {
+		t.Errorf("CheckBlockSanity: expected %s delay but got %s", expectedDelay, delay)
+	}
 }
 
 func TestPastMedianTime(t *testing.T) {
@@ -542,7 +563,7 @@ func TestValidateParents(t *testing.T) {
 	bNode := nodeByMsgBlock(t, dag, b)
 	cNode := nodeByMsgBlock(t, dag, c)
 
-	fakeBlockHeader := &appmessage.BlockHeader{
+	fakeBlockHeader := &domainmessage.BlockHeader{
 		HashMerkleRoot:       &daghash.ZeroHash,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
@@ -575,7 +596,7 @@ func TestCheckTransactionSanity(t *testing.T) {
 		outputValue            uint64
 		nodeSubnetworkID       subnetworkid.SubnetworkID
 		txSubnetworkData       *txSubnetworkData
-		extraModificationsFunc func(*appmessage.MsgTx)
+		extraModificationsFunc func(*domainmessage.MsgTx)
 		expectedErr            error
 	}{
 		{"good one", 1, 1, 1, *subnetworkid.SubnetworkIDNative, nil, nil, nil},
@@ -594,7 +615,7 @@ func TestCheckTransactionSanity(t *testing.T) {
 		{"duplicate inputs", 2, 1, 1,
 			*subnetworkid.SubnetworkIDNative,
 			nil,
-			func(tx *appmessage.MsgTx) { tx.TxIn[1].PreviousOutpoint.Index = 0 },
+			func(tx *domainmessage.MsgTx) { tx.TxIn[1].PreviousOutpoint.Index = 0 },
 			ruleError(ErrDuplicateTxInputs, "")},
 		{"1 input coinbase",
 			1,
@@ -648,14 +669,14 @@ func TestCheckTransactionSanity(t *testing.T) {
 		{"invalid payload hash", 1, 1, 0,
 			subnetworkid.SubnetworkID{123},
 			&txSubnetworkData{&subnetworkid.SubnetworkID{123}, 0, []byte{1}},
-			func(tx *appmessage.MsgTx) {
+			func(tx *domainmessage.MsgTx) {
 				tx.PayloadHash = &daghash.Hash{}
 			},
 			ruleError(ErrInvalidPayloadHash, "")},
 		{"invalid payload hash in native subnetwork", 1, 1, 0,
 			*subnetworkid.SubnetworkIDNative,
 			nil,
-			func(tx *appmessage.MsgTx) {
+			func(tx *domainmessage.MsgTx) {
 				tx.PayloadHash = daghash.DoubleHashP(tx.Payload)
 			},
 			ruleError(ErrInvalidPayloadHash, "")},
@@ -678,8 +699,8 @@ func TestCheckTransactionSanity(t *testing.T) {
 
 // Block100000 defines block 100,000 of the block DAG. It is used to
 // test Block operations.
-var Block100000 = appmessage.MsgBlock{
-	Header: appmessage.BlockHeader{
+var Block100000 = domainmessage.MsgBlock{
+	Header: domainmessage.BlockHeader{
 		Version: 0x10000000,
 		ParentHashes: []*daghash.Hash{
 			{
@@ -712,12 +733,12 @@ var Block100000 = appmessage.MsgBlock{
 		Bits:           0x207fffff,
 		Nonce:          1,
 	},
-	Transactions: []*appmessage.MsgTx{
+	Transactions: []*domainmessage.MsgTx{
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
 							0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
@@ -730,7 +751,7 @@ var Block100000 = appmessage.MsgBlock{
 					Sequence:        math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0x12a05f200, // 5000000000
 					ScriptPubKey: []byte{
@@ -752,9 +773,9 @@ var Block100000 = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
 							0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
@@ -766,7 +787,7 @@ var Block100000 = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
 							0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
@@ -782,9 +803,9 @@ var Block100000 = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
 							0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@@ -819,7 +840,7 @@ var Block100000 = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0x2123e300, // 556000000
 					ScriptPubKey: []byte{
@@ -852,9 +873,9 @@ var Block100000 = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
 							0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@@ -888,7 +909,7 @@ var Block100000 = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0xf4240, // 1000000
 					ScriptPubKey: []byte{
@@ -921,9 +942,9 @@ var Block100000 = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
 							0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@@ -958,7 +979,7 @@ var Block100000 = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0xf4240, // 1000000
 					ScriptPubKey: []byte{
@@ -980,8 +1001,8 @@ var Block100000 = appmessage.MsgBlock{
 }
 
 // BlockWithWrongTxOrder defines invalid block 100,000 of the block DAG.
-var BlockWithWrongTxOrder = appmessage.MsgBlock{
-	Header: appmessage.BlockHeader{
+var BlockWithWrongTxOrder = domainmessage.MsgBlock{
+	Header: domainmessage.BlockHeader{
 		Version: 1,
 		ParentHashes: []*daghash.Hash{
 			{
@@ -1019,12 +1040,12 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 		Bits:      0x207fffff,
 		Nonce:     1,
 	},
-	Transactions: []*appmessage.MsgTx{
+	Transactions: []*domainmessage.MsgTx{
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
 							0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
@@ -1037,7 +1058,7 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 					Sequence:        math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0x12a05f200, // 5000000000
 					ScriptPubKey: []byte{
@@ -1059,9 +1080,9 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x16, 0x5e, 0x38, 0xe8, 0xb3, 0x91, 0x45, 0x95,
 							0xd9, 0xc6, 0x41, 0xf3, 0xb8, 0xee, 0xc2, 0xf3,
@@ -1073,7 +1094,7 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID{
 							0x4b, 0xb0, 0x75, 0x35, 0xdf, 0xd5, 0x8e, 0x0b,
 							0x3c, 0xd6, 0x4f, 0xd7, 0x15, 0x52, 0x80, 0x87,
@@ -1089,9 +1110,9 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
 							0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
@@ -1126,7 +1147,7 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0x2123e300, // 556000000
 					ScriptPubKey: []byte{
@@ -1161,9 +1182,9 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
 							0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
@@ -1197,7 +1218,7 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0xf4240, // 1000000
 					ScriptPubKey: []byte{
@@ -1230,9 +1251,9 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 		},
 		{
 			Version: 1,
-			TxIn: []*appmessage.TxIn{
+			TxIn: []*domainmessage.TxIn{
 				{
-					PreviousOutpoint: appmessage.Outpoint{
+					PreviousOutpoint: domainmessage.Outpoint{
 						TxID: daghash.TxID([32]byte{
 							0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
 							0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
@@ -1267,7 +1288,7 @@ var BlockWithWrongTxOrder = appmessage.MsgBlock{
 					Sequence: math.MaxUint64,
 				},
 			},
-			TxOut: []*appmessage.TxOut{
+			TxOut: []*domainmessage.TxOut{
 				{
 					Value: 0xf4240, // 1000000
 					ScriptPubKey: []byte{

blockdag/versionbits.go

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

blockdag/virtualblock_test.go

@@ -5,7 +5,7 @@
 package blockdag
 
 import (
-	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util"
 	"reflect"
 	"testing"

cmd/addblock/addblock.go

@@ -5,11 +5,11 @@
 package main
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"os"
 	"runtime"
 
-	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+	"github.com/kaspanet/kaspad/limits"
+	"github.com/kaspanet/kaspad/logs"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 
@@ -20,7 +20,7 @@ const (
 
 var (
 	cfg   *ConfigFlags
-	log   *logger.Logger
+	log   *logs.Logger
 	spawn func(string, func())
 )
 
@@ -35,7 +35,7 @@ func realMain() error {
 	cfg = tcfg
 
 	// Setup logging.
-	backendLogger := logger.NewBackend()
+	backendLogger := logs.NewBackend()
 	defer os.Stdout.Sync()
 	log = backendLogger.Logger("MAIN")
 	spawn = panics.GoroutineWrapperFunc(log)

cmd/addblock/config.go

@@ -7,7 +7,7 @@ package main
 import (
 	"fmt"
 	flags "github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/config"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 	"os"

cmd/addblock/import.go

@@ -6,15 +6,15 @@ package main
 
 import (
 	"encoding/binary"
-	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
+	"github.com/kaspanet/kaspad/blockdag/indexers"
 	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/pkg/errors"
 	"io"
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/blockdag"
+	"github.com/kaspanet/kaspad/domainmessage"
 	"github.com/kaspanet/kaspad/util"
 )
 
@@ -68,10 +68,10 @@ func (bi *blockImporter) readBlock() ([]byte, error) {
 	if err := binary.Read(bi.r, binary.LittleEndian, &blockLen); err != nil {
 		return nil, err
 	}
-	if blockLen > appmessage.MaxMessagePayload {
+	if blockLen > domainmessage.MaxMessagePayload {
 		return nil, errors.Errorf("block payload of %d bytes is larger "+
 			"than the max allowed %d bytes", blockLen,
-			appmessage.MaxMessagePayload)
+			domainmessage.MaxMessagePayload)
 	}
 
 	serializedBlock := make([]byte, blockLen)

cmd/kaspactl/config.go

@@ -6,7 +6,7 @@ package main
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/config"
 	"github.com/kaspanet/kaspad/version"
 	"github.com/pkg/errors"
 	"io/ioutil"
@@ -16,7 +16,7 @@ import (
 	"strings"
 
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc/model"
+	"github.com/kaspanet/kaspad/rpc/model"
 	"github.com/kaspanet/kaspad/util"
 )
 

cmd/kaspactl/httpclient.go

@@ -11,7 +11,7 @@ import (
 	"net/http"
 
 	"github.com/btcsuite/go-socks/socks"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc/model"
+	"github.com/kaspanet/kaspad/rpc/model"
 )
 
 // newHTTPClient returns a new HTTP client that is configured according to the