[NOD-1305] Close client connection on disconnect (#909)

* Add VirtualBlueHashes to BlockDAG

* Refactor TestGHOSTDAG to read DAGs from json files

* Added a new DAG for the ghostdag test suite

* Pass BehaviorFlags to delayed blocks

README.md

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

addrmgr/addrmanager_test.go

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

addrmgr/internal_test.go

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

addrmgr/knownaddress_test.go

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

app/app.go

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

app/appmessage/README.md

@@ -1,7 +1,7 @@
 wire
 ====
 
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/wire)
 =======
 
@@ -36,7 +36,7 @@ to a remote node running a kaspa peer. Example syntax is:
 
 	// Reads and validates the next kaspa message from conn using the
 	// protocol version pver and the kaspa network kaspanet. The returns
-	// are a wire.Message, a []byte which contains the unmarshalled
+	// are a appmessage.Message, a []byte which contains the unmarshalled
 	// raw payload, and a possible error.
 	msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspanet)
 	if err != nil {

app/appmessage/base_message.go

@@ -0,0 +1,24 @@
+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/bench_test.go

@@ -2,15 +2,13 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
 	"compress/bzip2"
-	"fmt"
 	"io/ioutil"
 	"math"
-	"net"
 	"os"
 	"testing"
 
@@ -18,7 +16,7 @@ import (
 )
 
 // genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
-// the main network, regression test network, and test network.
+// the main network and test network.
 var genesisCoinbaseTxIns = []*TxIn{
 	{
 		PreviousOutpoint: Outpoint{
@@ -354,7 +352,7 @@ func BenchmarkReadBlockHeader(b *testing.B) {
 		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, // MerkleRoot
 		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 		0x00, // TxnCount Varint
 	}
 	r := bytes.NewReader(buf)
@@ -374,218 +372,6 @@ func BenchmarkWriteBlockHeader(b *testing.B) {
 	}
 }
 
-// BenchmarkDecodeGetHeaders performs a benchmark on how long it takes to
-// decode a getheaders message.
-func BenchmarkDecodeGetHeaders(b *testing.B) {
-	pver := ProtocolVersion
-	var m MsgGetHeaders
-	m.LowHash = &daghash.Hash{1}
-	m.HighHash = &daghash.Hash{1}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetHeaders.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgGetHeaders
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeHeaders performs a benchmark on how long it takes to
-// decode a headers message with the maximum number of headers and maximum number of
-// parent hashes per header.
-func BenchmarkDecodeHeaders(b *testing.B) {
-	// Create a message with the maximum number of headers.
-	pver := ProtocolVersion
-	var m MsgHeaders
-	for i := 0; i < MaxBlockHeadersPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		parentHashes := make([]*daghash.Hash, MaxNumParentBlocks)
-		for j := byte(0); j < MaxNumParentBlocks; j++ {
-			hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x%x", i, j))
-			if err != nil {
-				b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-			}
-			parentHashes[i] = hash
-		}
-		m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, hash, hash, 0, uint64(i)))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgHeaders.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgHeaders
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeGetBlockInvs performs a benchmark on how long it takes to
-// decode a getblockinvs message.
-func BenchmarkDecodeGetBlockInvs(b *testing.B) {
-	pver := ProtocolVersion
-	var m MsgGetBlockInvs
-	m.LowHash = &daghash.Hash{1}
-	m.HighHash = &daghash.Hash{1}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetBlockInvs.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgGetBlockInvs
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeAddr performs a benchmark on how long it takes to decode an
-// addr message with the maximum number of addresses.
-func BenchmarkDecodeAddr(b *testing.B) {
-	// Create a message with the maximum number of addresses.
-	pver := ProtocolVersion
-	ip := net.ParseIP("127.0.0.1")
-	ma := NewMsgAddr(false, nil)
-	for port := uint16(0); port < MaxAddrPerMsg; port++ {
-		ma.AddAddress(NewNetAddressIPPort(ip, port, SFNodeNetwork))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := ma.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgAddr.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgAddr
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeInv performs a benchmark on how long it takes to decode an inv
-// message with the maximum number of entries.
-func BenchmarkDecodeInv(b *testing.B) {
-	// Create a message with the maximum number of entries.
-	pver := ProtocolVersion
-	var m MsgInv
-	for i := 0; i < MaxInvPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddInvVect(NewInvVect(InvTypeBlock, hash))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgInv.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgInv
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeNotFound performs a benchmark on how long it takes to decode
-// a notfound message with the maximum number of entries.
-func BenchmarkDecodeNotFound(b *testing.B) {
-	// Create a message with the maximum number of entries.
-	pver := ProtocolVersion
-	var m MsgNotFound
-	for i := 0; i < MaxInvPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddInvVect(NewInvVect(InvTypeBlock, hash))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgNotFound.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgNotFound
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeMerkleBlock performs a benchmark on how long it takes to
-// decode a reasonably sized merkleblock message.
-func BenchmarkDecodeMerkleBlock(b *testing.B) {
-	// Create a message with random data.
-	pver := ProtocolVersion
-	var m MsgMerkleBlock
-	hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", 10000))
-	if err != nil {
-		b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-	}
-	m.Header = *NewBlockHeader(1, []*daghash.Hash{hash}, hash, hash, hash, 0, uint64(10000))
-	for i := 0; i < 105; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddTxHash(hash)
-		if i%8 == 0 {
-			m.Flags = append(m.Flags, uint8(i))
-		}
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgMerkleBlock.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgMerkleBlock
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(r, pver)
-	}
-}
-
 // BenchmarkTxHash performs a benchmark on how long it takes to hash a
 // transaction.
 func BenchmarkTxHash(b *testing.B) {
@@ -625,3 +411,21 @@ func BenchmarkDoubleHashH(b *testing.B) {
 		_ = daghash.DoubleHashH(txBytes)
 	}
 }
+
+// BenchmarkDoubleHashWriter performs a benchmark on how long it takes to perform
+// a double hash via the writer returning a daghash.Hash.
+func BenchmarkDoubleHashWriter(b *testing.B) {
+	var buf bytes.Buffer
+	err := genesisCoinbaseTx.Serialize(&buf)
+	if err != nil {
+		b.Fatalf("Serialize: unexpected error: %+v", err)
+	}
+	txBytes := buf.Bytes()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		writer := daghash.NewDoubleHashWriter()
+		_, _ = writer.Write(txBytes)
+		writer.Finalize()
+	}
+}

app/appmessage/blockheader.go

@@ -2,14 +2,14 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
-	"bytes"
+	"fmt"
 	"io"
-	"time"
 
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 // BaseBlockHeaderPayload is the base number of bytes a block header can be,
@@ -49,7 +49,7 @@ type BlockHeader struct {
 	UTXOCommitment *daghash.Hash
 
 	// Time the block was created.
-	Timestamp time.Time
+	Timestamp mstime.Time
 
 	// Difficulty target for the block.
 	Bits uint32
@@ -66,13 +66,18 @@ func (h *BlockHeader) NumParentBlocks() byte {
 // BlockHash computes the block identifier hash for the given block header.
 func (h *BlockHeader) BlockHash() *daghash.Hash {
 	// Encode the header and double sha256 everything prior to the number of
-	// transactions. Ignore the error returns since there is no way the
-	// encode could fail except being out of memory which would cause a
-	// run-time panic.
-	buf := bytes.NewBuffer(make([]byte, 0, BaseBlockHeaderPayload+h.NumParentBlocks()))
-	_ = writeBlockHeader(buf, 0, h)
+	// transactions.
+	writer := daghash.NewDoubleHashWriter()
+	err := writeBlockHeader(writer, 0, h)
+	if err != nil {
+		// It seems like this could only happen if the writer returned an error.
+		// and this writer should never return an error (no allocations or possible failures)
+		// the only non-writer error path here is unknown types in `WriteElement`
+		panic(fmt.Sprintf("BlockHash() failed. this should never fail unless BlockHeader was changed. err: %+v", err))
+	}
 
-	return daghash.DoubleHashP(buf.Bytes())
+	res := writer.Finalize()
+	return &res
 }
 
 // IsGenesis returns true iff this block is a genesis block
@@ -83,7 +88,7 @@ func (h *BlockHeader) IsGenesis() bool {
 // KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding block headers stored to disk, such as in a
-// database, as opposed to decoding block headers from the wire.
+// database, as opposed to decoding block headers from the appmessage.
 func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
 	return readBlockHeader(r, pver, h)
 }
@@ -91,7 +96,7 @@ func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
 // KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding block headers to be stored to disk, such as in a
-// database, as opposed to encoding block headers for the wire.
+// database, as opposed to encoding block headers for the appmessage.
 func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
 	return writeBlockHeader(w, pver, h)
 }
@@ -100,7 +105,7 @@ func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
 // that is suitable for long-term storage such as a database while respecting
 // the Version field.
 func (h *BlockHeader) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of readBlockHeader.
 	return readBlockHeader(r, 0, h)
@@ -110,7 +115,7 @@ func (h *BlockHeader) Deserialize(r io.Reader) error {
 // that is suitable for long-term storage such as a database while respecting
 // the Version field.
 func (h *BlockHeader) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of writeBlockHeader.
 	return writeBlockHeader(w, 0, h)
@@ -128,7 +133,7 @@ func (h *BlockHeader) SerializeSize() int {
 func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot *daghash.Hash,
 	acceptedIDMerkleRoot *daghash.Hash, utxoCommitment *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
 
-	// Limit the timestamp to one second precision since the protocol
+	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
 	return &BlockHeader{
 		Version:              version,
@@ -136,7 +141,7 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
 		HashMerkleRoot:       hashMerkleRoot,
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 		UTXOCommitment:       utxoCommitment,
-		Timestamp:            time.Unix(time.Now().Unix(), 0),
+		Timestamp:            mstime.Now(),
 		Bits:                 bits,
 		Nonce:                nonce,
 	}
@@ -144,7 +149,7 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
 
 // readBlockHeader reads a kaspa block header from r. See Deserialize for
 // decoding block headers stored to disk, such as in a database, as opposed to
-// decoding from the wire.
+// decoding from the appmessage.
 func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 	var numParentBlocks byte
 	err := readElements(r, &bh.Version, &numParentBlocks)
@@ -170,9 +175,9 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 
 // writeBlockHeader writes a kaspa block header to w. See Serialize for
 // encoding block headers to be stored to disk, such as in a database, as
-// opposed to encoding for the wire.
+// opposed to encoding for the appmessage.
 func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
-	sec := int64(bh.Timestamp.Unix())
+	timestamp := bh.Timestamp.UnixMilliseconds()
 	if err := writeElements(w, bh.Version, bh.NumParentBlocks()); err != nil {
 		return err
 	}
@@ -181,5 +186,5 @@ func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
 			return err
 		}
 	}
-	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, sec, bh.Bits, bh.Nonce)
+	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, timestamp, bh.Bits, bh.Nonce)
 }

app/appmessage/blockheader_test.go

@@ -2,17 +2,16 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
-	"reflect"
-	"testing"
-	"time"
-
 	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/kaspanet/kaspad/util/random"
+	"reflect"
+	"testing"
 )
 
 // TestBlockHeader tests the BlockHeader API.
@@ -48,9 +47,9 @@ func TestBlockHeader(t *testing.T) {
 	}
 }
 
-// TestBlockHeaderWire tests the BlockHeader wire encode and decode for various
+// TestBlockHeaderEncoding tests the BlockHeader appmessage encode and decode for various
 // protocol versions.
-func TestBlockHeaderWire(t *testing.T) {
+func TestBlockHeaderEncoding(t *testing.T) {
 	nonce := uint64(123123) // 0x000000000001e0f3
 	pver := ProtocolVersion
 
@@ -62,12 +61,12 @@ func TestBlockHeaderWire(t *testing.T) {
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
 		Bits:                 bits,
 		Nonce:                nonce,
 	}
 
-	// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
+	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
@@ -91,16 +90,16 @@ func TestBlockHeaderWire(t *testing.T) {
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	}
 
 	tests := []struct {
 		in   *BlockHeader // Data to encode
 		out  *BlockHeader // Expected decoded data
-		buf  []byte       // Wire encoding
-		pver uint32       // Protocol version for wire encoding
+		buf  []byte       // Encoded data
+		pver uint32       // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		{
@@ -113,7 +112,7 @@ func TestBlockHeaderWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := writeBlockHeader(&buf, test.pver, test.in)
 		if err != nil {
@@ -138,7 +137,7 @@ func TestBlockHeaderWire(t *testing.T) {
 			continue
 		}
 
-		// Decode the block header from wire format.
+		// Decode the block header from appmessage format.
 		var bh BlockHeader
 		rbuf := bytes.NewReader(test.buf)
 		err = readBlockHeader(rbuf, test.pver, &bh)
@@ -178,12 +177,12 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
 		Bits:                 bits,
 		Nonce:                nonce,
 	}
 
-	// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
+	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
@@ -207,9 +206,9 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	}
 
 	tests := []struct {
@@ -260,7 +259,7 @@ func TestBlockHeaderSerialize(t *testing.T) {
 func TestBlockHeaderSerializeSize(t *testing.T) {
 	nonce := uint64(123123) // 0x1e0f3
 	bits := uint32(0x1d00ffff)
-	timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
+	timestamp := mstime.UnixMilliseconds(0x495fab29000)
 	baseBlockHdr := &BlockHeader{
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
@@ -308,7 +307,7 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 func TestIsGenesis(t *testing.T) {
 	nonce := uint64(123123) // 0x1e0f3
 	bits := uint32(0x1d00ffff)
-	timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
+	timestamp := mstime.UnixMilliseconds(0x495fab29000)
 
 	baseBlockHdr := &BlockHeader{
 		Version:        1,

app/appmessage/common.go

@@ -2,23 +2,27 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"encoding/binary"
 	"fmt"
-	"io"
-	"math"
-	"time"
-
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 	"github.com/kaspanet/kaspad/util/binaryserializer"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
 	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/pkg/errors"
+	"io"
+	"math"
 )
 
 // MaxVarIntPayload is the maximum payload size for a variable length integer.
 const MaxVarIntPayload = 9
 
+// MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
+const MaxInvPerMsg = 1 << 17
+
 var (
 	// littleEndian is a convenience variable since binary.LittleEndian is
 	// quite long.
@@ -34,10 +38,13 @@ var (
 var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
 	"encode a value greater than %x"
 
-// int64Time represents a unix timestamp encoded with an int64. It is used as
-// a way to signal the readElement function how to decode a timestamp into a Go
-// time.Time since it is otherwise ambiguous.
-type int64Time time.Time
+// errNoEncodingForType signifies that there's no encoding for the given type.
+var errNoEncodingForType = errors.New("there's no encoding for this type")
+
+// int64Time represents a unix timestamp with milliseconds precision encoded with
+// an int64. It is used as a way to signal the readElement function how to decode
+// a timestamp into a Go mstime.Time since it is otherwise ambiguous.
+type int64Time mstime.Time
 
 // ReadElement reads the next sequence of bytes from r using little endian
 // depending on the concrete type of element pointed to.
@@ -77,6 +84,14 @@ func ReadElement(r io.Reader, element interface{}) error {
 		*e = rv
 		return nil
 
+	case *uint8:
+		rv, err := binaryserializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
 	case *bool:
 		rv, err := binaryserializer.Uint8(r)
 		if err != nil {
@@ -95,7 +110,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		if err != nil {
 			return err
 		}
-		*e = int64Time(time.Unix(int64(rv), 0))
+		*e = int64Time(mstime.UnixMilliseconds(int64(rv)))
 		return nil
 
 	// Message header checksum.
@@ -107,11 +122,12 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	// Message header command.
-	case *[CommandSize]uint8:
-		_, err := io.ReadFull(r, e[:])
+	case *MessageCommand:
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
+		*e = MessageCommand(rv)
 		return nil
 
 	// IP address.
@@ -129,6 +145,9 @@ func ReadElement(r io.Reader, element interface{}) error {
 		}
 		return nil
 
+	case *id.ID:
+		return e.Deserialize(r)
+
 	case *subnetworkid.SubnetworkID:
 		_, err := io.ReadFull(r, e[:])
 		if err != nil {
@@ -144,14 +163,6 @@ func ReadElement(r io.Reader, element interface{}) error {
 		*e = ServiceFlag(rv)
 		return nil
 
-	case *InvType:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = InvType(rv)
-		return nil
-
 	case *KaspaNet:
 		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
@@ -159,27 +170,9 @@ func ReadElement(r io.Reader, element interface{}) error {
 		}
 		*e = KaspaNet(rv)
 		return nil
-
-	case *BloomUpdateType:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		*e = BloomUpdateType(rv)
-		return nil
-
-	case *RejectCode:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		*e = RejectCode(rv)
-		return nil
 	}
 
-	// Fall back to the slower binary.Read if a fast path was not available
-	// above.
-	return binary.Read(r, littleEndian, element)
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to read type %T", element)
 }
 
 // readElements reads multiple items from r. It is equivalent to multiple
@@ -227,6 +220,13 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
+	case uint8:
+		err := binaryserializer.PutUint8(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case bool:
 		var err error
 		if e {
@@ -248,8 +248,8 @@ func WriteElement(w io.Writer, element interface{}) error {
 		return nil
 
 	// Message header command.
-	case [CommandSize]uint8:
-		_, err := w.Write(e[:])
+	case MessageCommand:
+		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -270,6 +270,9 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
+	case *id.ID:
+		return e.Serialize(w)
+
 	case *subnetworkid.SubnetworkID:
 		_, err := w.Write(e[:])
 		if err != nil {
@@ -284,38 +287,15 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
-	case InvType:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
 	case KaspaNet:
 		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
 		return nil
-
-	case BloomUpdateType:
-		err := binaryserializer.PutUint8(w, uint8(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case RejectCode:
-		err := binaryserializer.PutUint8(w, uint8(e))
-		if err != nil {
-			return err
-		}
-		return nil
 	}
 
-	// Fall back to the slower binary.Write if a fast path was not available
-	// above.
-	return binary.Write(w, littleEndian, element)
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to write type %T", element)
 }
 
 // writeElements writes multiple items to w. It is equivalent to multiple
@@ -350,7 +330,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0x100000000)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}
 
@@ -365,7 +345,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0x10000)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}
 
@@ -380,7 +360,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0xfd)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}
 

app/appmessage/common_test.go

@@ -2,10 +2,11 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
+	"github.com/pkg/errors"
 	"io"
 	"reflect"
 	"strings"
@@ -56,15 +57,13 @@ var exampleUTXOCommitment = &daghash.Hash{
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 }
 
-// TestElementWire tests wire encode and decode for various element types. This
+// TestElementEncoding tests appmessage encode and decode for various element types. This
 // is mainly to test the "fast" paths in readElement and writeElement which use
 // type assertions to avoid reflection when possible.
-func TestElementWire(t *testing.T) {
-	type writeElementReflect int32
-
+func TestElementEncoding(t *testing.T) {
 	tests := []struct {
 		in  interface{} // Value to encode
-		buf []byte      // Wire encoding
+		buf []byte      // Encoded value
 	}{
 		{int32(1), []byte{0x01, 0x00, 0x00, 0x00}},
 		{uint32(256), []byte{0x00, 0x01, 0x00, 0x00}},
@@ -89,13 +88,9 @@ func TestElementWire(t *testing.T) {
 			[]byte{0x01, 0x02, 0x03, 0x04},
 		},
 		{
-			[CommandSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
-			},
+			MessageCommand(0x10),
 			[]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
+				0x10, 0x00, 0x00, 0x00,
 			},
 		},
 		{
@@ -126,24 +121,15 @@ func TestElementWire(t *testing.T) {
 			ServiceFlag(SFNodeNetwork),
 			[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 		},
-		{
-			InvType(InvTypeTx),
-			[]byte{0x01, 0x00, 0x00, 0x00},
-		},
 		{
 			KaspaNet(Mainnet),
 			[]byte{0x1d, 0xf7, 0xdc, 0x3d},
 		},
-		// Type not supported by the "fast" path and requires reflection.
-		{
-			writeElementReflect(1),
-			[]byte{0x01, 0x00, 0x00, 0x00},
-		},
 	}
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Write to wire format.
+		// Write to appmessage format.
 		var buf bytes.Buffer
 		err := WriteElement(&buf, test.in)
 		if err != nil {
@@ -156,7 +142,7 @@ func TestElementWire(t *testing.T) {
 			continue
 		}
 
-		// Read from wire format.
+		// Read from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val := test.in
 		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
@@ -179,9 +165,11 @@ func TestElementWire(t *testing.T) {
 	}
 }
 
-// TestElementWireErrors performs negative tests against wire encode and decode
+// TestElementEncodingErrors performs negative tests against appmessage encode and decode
 // of various element types to confirm error paths work correctly.
-func TestElementWireErrors(t *testing.T) {
+func TestElementEncodingErrors(t *testing.T) {
+	type writeElementReflect int32
+
 	tests := []struct {
 		in       interface{} // Value to encode
 		max      int         // Max size of fixed buffer to induce errors
@@ -194,10 +182,7 @@ func TestElementWireErrors(t *testing.T) {
 		{true, 0, io.ErrShortWrite, io.EOF},
 		{[4]byte{0x01, 0x02, 0x03, 0x04}, 0, io.ErrShortWrite, io.EOF},
 		{
-			[CommandSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
-			},
+			MessageCommand(10),
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{
@@ -217,29 +202,30 @@ func TestElementWireErrors(t *testing.T) {
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF},
-		{InvType(InvTypeTx), 0, io.ErrShortWrite, io.EOF},
 		{KaspaNet(Mainnet), 0, io.ErrShortWrite, io.EOF},
+		// Type with no supported encoding.
+		{writeElementReflect(0), 0, errNoEncodingForType, errNoEncodingForType},
 	}
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteElement(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("writeElement #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, nil)
 		val := test.in
 		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
 			val = reflect.New(reflect.TypeOf(test.in)).Interface()
 		}
 		err = ReadElement(r, val)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("readElement #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -247,43 +233,42 @@ func TestElementWireErrors(t *testing.T) {
 	}
 }
 
-// TestVarIntWire tests wire encode and decode for variable length integers.
-func TestVarIntWire(t *testing.T) {
+// TestVarIntEncoding tests appmessage encode and decode for variable length integers.
+func TestVarIntEncoding(t *testing.T) {
 	tests := []struct {
-		in  uint64 // Value to encode
-		out uint64 // Expected decoded value
-		buf []byte // Wire encoding
+		value uint64 // Value to encode
+		buf   []byte // Encoded value
 	}{
 		// Latest protocol version.
 		// Single byte
-		{0, 0, []byte{0x00}},
+		{0, []byte{0x00}},
 		// Max single byte
-		{0xfc, 0xfc, []byte{0xfc}},
+		{0xfc, []byte{0xfc}},
 		// Min 2-byte
-		{0xfd, 0xfd, []byte{0xfd, 0x0fd, 0x00}},
+		{0xfd, []byte{0xfd, 0x0fd, 0x00}},
 		// Max 2-byte
-		{0xffff, 0xffff, []byte{0xfd, 0xff, 0xff}},
+		{0xffff, []byte{0xfd, 0xff, 0xff}},
 		// Min 4-byte
-		{0x10000, 0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
+		{0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
 		// Max 4-byte
-		{0xffffffff, 0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
+		{0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
 		// Min 8-byte
 		{
-			0x100000000, 0x100000000,
+			0x100000000,
 			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
 		},
 		// Max 8-byte
 		{
-			0xffffffffffffffff, 0xffffffffffffffff,
+			0xffffffffffffffff,
 			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 		},
 	}
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
-		var buf bytes.Buffer
-		err := WriteVarInt(&buf, test.in)
+		// Encode to appmessage format.
+		buf := &bytes.Buffer{}
+		err := WriteVarInt(buf, test.value)
 		if err != nil {
 			t.Errorf("WriteVarInt #%d error %v", i, err)
 			continue
@@ -294,27 +279,27 @@ func TestVarIntWire(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarInt(rbuf)
 		if err != nil {
 			t.Errorf("ReadVarInt #%d error %v", i, err)
 			continue
 		}
-		if val != test.out {
-			t.Errorf("ReadVarInt #%d\n got: %d want: %d", i,
-				val, test.out)
+		if val != test.value {
+			t.Errorf("ReadVarInt #%d\n got: %x want: %x", i,
+				val, test.value)
 			continue
 		}
 	}
 }
 
-// TestVarIntWireErrors performs negative tests against wire encode and decode
+// TestVarIntEncodingErrors performs negative tests against appmessage encode and decode
 // of variable length integers to confirm error paths work correctly.
-func TestVarIntWireErrors(t *testing.T) {
+func TestVarIntEncodingErrors(t *testing.T) {
 	tests := []struct {
 		in       uint64 // Value to encode
-		buf      []byte // Wire encoding
+		buf      []byte // Encoded value
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -334,19 +319,19 @@ func TestVarIntWireErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarInt(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarInt(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -362,7 +347,7 @@ func TestVarIntNonCanonical(t *testing.T) {
 	tests := []struct {
 		name string // Test name for easier identification
 		in   []byte // Value to decode
-		pver uint32 // Protocol version for wire encoding
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		{
 			"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
@@ -394,10 +379,10 @@ func TestVarIntNonCanonical(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.in)
 		val, err := ReadVarInt(rbuf)
-		if _, ok := err.(*MessageError); !ok {
+		if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
 			t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i,
 				test.name, err)
 			continue
@@ -410,7 +395,7 @@ func TestVarIntNonCanonical(t *testing.T) {
 	}
 }
 
-// TestVarIntWire tests the serialize size for variable length integers.
+// TestVarIntEncoding tests the serialize size for variable length integers.
 func TestVarIntSerializeSize(t *testing.T) {
 	tests := []struct {
 		val  uint64 // Value to get the serialized size for
@@ -445,8 +430,8 @@ func TestVarIntSerializeSize(t *testing.T) {
 	}
 }
 
-// TestVarStringWire tests wire encode and decode for variable length strings.
-func TestVarStringWire(t *testing.T) {
+// TestVarStringEncoding tests appmessage encode and decode for variable length strings.
+func TestVarStringEncoding(t *testing.T) {
 	pver := ProtocolVersion
 
 	// str256 is a string that takes a 2-byte varint to encode.
@@ -455,8 +440,8 @@ func TestVarStringWire(t *testing.T) {
 	tests := []struct {
 		in   string // String to encode
 		out  string // String to decoded value
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		// Empty string
@@ -469,7 +454,7 @@ func TestVarStringWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := WriteVarString(&buf, test.in)
 		if err != nil {
@@ -482,7 +467,7 @@ func TestVarStringWire(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarString(rbuf, test.pver)
 		if err != nil {
@@ -497,9 +482,9 @@ func TestVarStringWire(t *testing.T) {
 	}
 }
 
-// TestVarStringWireErrors performs negative tests against wire encode and
+// TestVarStringEncodingErrors performs negative tests against appmessage encode and
 // decode of variable length strings to confirm error paths work correctly.
-func TestVarStringWireErrors(t *testing.T) {
+func TestVarStringEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	// str256 is a string that takes a 2-byte varint to encode.
@@ -507,8 +492,8 @@ func TestVarStringWireErrors(t *testing.T) {
 
 	tests := []struct {
 		in       string // Value to encode
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -524,19 +509,19 @@ func TestVarStringWireErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarString(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarString #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarString(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarString #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -552,8 +537,8 @@ func TestVarStringOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@@ -564,7 +549,7 @@ func TestVarStringOverflowErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		_, err := ReadVarString(rbuf, test.pver)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -576,8 +561,8 @@ func TestVarStringOverflowErrors(t *testing.T) {
 
 }
 
-// TestVarBytesWire tests wire encode and decode for variable length byte array.
-func TestVarBytesWire(t *testing.T) {
+// TestVarBytesEncoding tests appmessage encode and decode for variable length byte array.
+func TestVarBytesEncoding(t *testing.T) {
 	pver := ProtocolVersion
 
 	// bytes256 is a byte array that takes a 2-byte varint to encode.
@@ -585,8 +570,8 @@ func TestVarBytesWire(t *testing.T) {
 
 	tests := []struct {
 		in   []byte // Byte Array to write
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		// Empty byte array
@@ -599,7 +584,7 @@ func TestVarBytesWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := WriteVarBytes(&buf, test.pver, test.in)
 		if err != nil {
@@ -612,7 +597,7 @@ func TestVarBytesWire(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
 			"test payload")
@@ -628,9 +613,9 @@ func TestVarBytesWire(t *testing.T) {
 	}
 }
 
-// TestVarBytesWireErrors performs negative tests against wire encode and
+// TestVarBytesEncodingErrors performs negative tests against appmessage encode and
 // decode of variable length byte arrays to confirm error paths work correctly.
-func TestVarBytesWireErrors(t *testing.T) {
+func TestVarBytesEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	// bytes256 is a byte array that takes a 2-byte varint to encode.
@@ -638,8 +623,8 @@ func TestVarBytesWireErrors(t *testing.T) {
 
 	tests := []struct {
 		in       []byte // Byte Array to write
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -655,20 +640,20 @@ func TestVarBytesWireErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarBytes(w, test.pver, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
 			"test payload")
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -684,8 +669,8 @@ func TestVarBytesOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@@ -696,7 +681,7 @@ func TestVarBytesOverflowErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
 			"test payload")

app/appmessage/doc.go

@@ -1,8 +1,8 @@
 /*
-Package wire implements the kaspa wire protocol.
+Package appmessage implements the kaspa appmessage protocol.
 
 At a high level, this package provides support for marshalling and unmarshalling
-supported kaspa messages to and from the wire. This package does not deal
+supported kaspa messages to and from the appmessage. This package does not deal
 with the specifics of message handling such as what to do when a message is
 received. This provides the caller with a high level of flexibility.
 
@@ -19,7 +19,7 @@ Message which allows messages of any type to be read, written, or passed around
 through channels, functions, etc. In addition, concrete implementations of most
 of the currently supported kaspa messages are provided. For these supported
 messages, all of the details of marshalling and unmarshalling to and from the
-wire using kaspa encoding are handled so the caller doesn't have to concern
+appmessage using kaspa encoding are handled so the caller doesn't have to concern
 themselves with the specifics.
 
 Message Interaction
@@ -37,7 +37,7 @@ interactions in no particular order.
 
 	Peer A Sends                            Peer B Responds
 	----------------------------------------------------------------------------
-	getaddr message (MsgGetAddr)            addr message (MsgAddr)
+	getaddr message (MsgRequestAddresses)       addr message (MsgAddresses)
 	getblockinvs message (MsgGetBlockInvs)  inv message (MsgInv)
 	inv message (MsgInv)                    getdata message (MsgGetData)
 	getdata message (MsgGetData)            block message (MsgBlock) -or-
@@ -55,7 +55,7 @@ Protocol Version
 
 The protocol version should be negotiated with the remote peer at a higher
 level than this package via the version (MsgVersion) message exchange, however,
-this package provides the wire.ProtocolVersion constant which indicates the
+this package provides the appmessage.ProtocolVersion constant which indicates the
 latest protocol version this package supports and is typically the value to use
 for all outbound connections before a potentially lower protocol version is
 negotiated.
@@ -66,11 +66,10 @@ The kaspa network is a magic number which is used to identify the start of a
 message and which kaspa network the message applies to. This package provides
 the following constants:
 
-    wire.Mainnet
-    wire.Testnet (Test network)
-    wire.Regtest (Regression test network)
-    wire.Simnet  (Simulation test network)
-    wire.Devnet  (Development network)
+    appmessage.Mainnet
+    appmessage.Testnet (Test network)
+    appmessage.Simnet  (Simulation test network)
+    appmessage.Devnet  (Development network)
 
 Determining Message Type
 
@@ -82,43 +81,43 @@ switch or type assertion. An example of a type switch follows:
 	// Assumes msg is already a valid concrete message such as one created
 	// via NewMsgVersion or read via ReadMessage.
 	switch msg := msg.(type) {
-	case *wire.MsgVersion:
+	case *appmessage.MsgVersion:
 		// The message is a pointer to a MsgVersion struct.
 		fmt.Printf("Protocol version: %d", msg.ProtocolVersion)
-	case *wire.MsgBlock:
+	case *appmessage.MsgBlock:
 		// The message is a pointer to a MsgBlock struct.
 		fmt.Printf("Number of tx in block: %d", msg.Header.TxnCount)
 	}
 
 Reading Messages
 
-In order to unmarshall kaspa messages from the wire, use the ReadMessage
+In order to unmarshall kaspa messages from the appmessage, use the ReadMessage
 function. It accepts any io.Reader, but typically this will be a net.Conn to
 a remote node running a kaspa peer. Example syntax is:
 
 	// Reads and validates the next kaspa message from conn using the
 	// protocol version pver and the kaspa network kaspaNet. The returns
-	// are a wire.Message, a []byte which contains the unmarshalled
+	// are a appmessage.Message, a []byte which contains the unmarshalled
 	// raw payload, and a possible error.
-	msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspaNet)
+	msg, rawPayload, err := appmessage.ReadMessage(conn, pver, kaspaNet)
 	if err != nil {
 		// Log and handle the error
 	}
 
 Writing Messages
 
-In order to marshall kaspa messages to the wire, use the WriteMessage
+In order to marshall kaspa messages to the appmessage, use the WriteMessage
 function. It accepts any io.Writer, but typically this will be a net.Conn to
 a remote node running a kaspa peer. Example syntax to request addresses
 from a remote peer is:
 
 	// Create a new getaddr kaspa message.
-	msg := wire.NewMsgGetAddr()
+	msg := appmessage.NewMsgRequestAddresses()
 
 	// Writes a kaspa message msg to conn using the protocol version
 	// pver, and the kaspa network kaspaNet. The return is a possible
 	// error.
-	err := wire.WriteMessage(conn, msg, pver, kaspaNet)
+	err := appmessage.WriteMessage(conn, msg, pver, kaspaNet)
 	if err != nil {
 		// Log and handle the error
 	}
@@ -127,8 +126,8 @@ Errors
 
 Errors returned by this package are either the raw errors provided by underlying
 calls to read/write from streams such as io.EOF, io.ErrUnexpectedEOF, and
-io.ErrShortWrite, or of type wire.MessageError. This allows the caller to
+io.ErrShortWrite, or of type appmessage.MessageError. This allows the caller to
 differentiate between general IO errors and malformed messages through type
 assertions.
 */
-package wire
+package appmessage

app/appmessage/error.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"fmt"

app/appmessage/fakemessage_test.go

@@ -2,20 +2,20 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import "io"
 
 // fakeMessage implements the Message interface and is used to force encode
 // errors in messages.
 type fakeMessage struct {
-	command        string
+	command        MessageCommand
 	payload        []byte
 	forceEncodeErr bool
 	forceLenErr    bool
 }
 
-// KaspaDecode doesn't do anything. It just satisfies the wire.Message
+// KaspaDecode doesn't do anything. It just satisfies the appmessage.Message
 // interface.
 func (msg *fakeMessage) KaspaDecode(r io.Reader, pver uint32) error {
 	return nil
@@ -23,7 +23,7 @@ func (msg *fakeMessage) KaspaDecode(r io.Reader, pver uint32) error {
 
 // KaspaEncode writes the payload field of the fake message or forces an error
 // if the forceEncodeErr flag of the fake message is set. It also satisfies the
-// wire.Message interface.
+// appmessage.Message interface.
 func (msg *fakeMessage) KaspaEncode(w io.Writer, pver uint32) error {
 	if msg.forceEncodeErr {
 		err := &MessageError{
@@ -39,7 +39,7 @@ func (msg *fakeMessage) KaspaEncode(w io.Writer, pver uint32) error {
 
 // Command returns the command field of the fake message and satisfies the
 // Message interface.
-func (msg *fakeMessage) Command() string {
+func (msg *fakeMessage) Command() MessageCommand {
 	return msg.command
 }
 

app/appmessage/fixedIO_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"

app/appmessage/message.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"time"
+)
+
+// MaxMessagePayload is the maximum bytes a message can be regardless of other
+// individual limits imposed by messages themselves.
+const MaxMessagePayload = (1024 * 1024 * 32) // 32MB
+
+// MessageCommand is a number in the header of a message that represents its type.
+type MessageCommand uint32
+
+func (cmd MessageCommand) String() string {
+	cmdString, ok := MessageCommandToString[cmd]
+	if !ok {
+		cmdString = "unknown command"
+	}
+	return fmt.Sprintf("%s [code %d]", cmdString, uint8(cmd))
+}
+
+// Commands used in kaspa message headers which describe the type of message.
+const (
+	CmdVersion MessageCommand = iota
+	CmdVerAck
+	CmdRequestAddresses
+	CmdAddresses
+	CmdRequestIBDBlocks
+	CmdBlock
+	CmdTx
+	CmdPing
+	CmdPong
+	CmdRequestBlockLocator
+	CmdBlockLocator
+	CmdSelectedTip
+	CmdRequestSelectedTip
+	CmdInvRelayBlock
+	CmdRequestRelayBlocks
+	CmdInvTransaction
+	CmdRequestTransactions
+	CmdIBDBlock
+	CmdRequestNextIBDBlocks
+	CmdDoneIBDBlocks
+	CmdTransactionNotFound
+	CmdReject
+)
+
+// MessageCommandToString maps all MessageCommands to their string representation
+var MessageCommandToString = map[MessageCommand]string{
+	CmdVersion:              "Version",
+	CmdVerAck:               "VerAck",
+	CmdRequestAddresses:     "RequestAddresses",
+	CmdAddresses:            "Addresses",
+	CmdRequestIBDBlocks:     "RequestBlocks",
+	CmdBlock:                "Block",
+	CmdTx:                   "Tx",
+	CmdPing:                 "Ping",
+	CmdPong:                 "Pong",
+	CmdRequestBlockLocator:  "RequestBlockLocator",
+	CmdBlockLocator:         "BlockLocator",
+	CmdSelectedTip:          "SelectedTip",
+	CmdRequestSelectedTip:   "RequestSelectedTip",
+	CmdInvRelayBlock:        "InvRelayBlock",
+	CmdRequestRelayBlocks:   "RequestRelayBlocks",
+	CmdInvTransaction:       "InvTransaction",
+	CmdRequestTransactions:  "RequestTransactions",
+	CmdIBDBlock:             "IBDBlock",
+	CmdRequestNextIBDBlocks: "RequestNextIBDBlocks",
+	CmdDoneIBDBlocks:        "DoneIBDBlocks",
+	CmdTransactionNotFound:  "TransactionNotFound",
+	CmdReject:               "Reject",
+}
+
+// Message is an interface that describes a kaspa message. A type that
+// implements Message has complete control over the representation of its data
+// and may therefore contain additional or fewer fields than those which
+// are used directly in the protocol encoded message.
+type Message interface {
+	Command() MessageCommand
+	MessageNumber() uint64
+	SetMessageNumber(index uint64)
+	ReceivedAt() time.Time
+	SetReceivedAt(receivedAt time.Time)
+}

app/appmessage/msgaddresses.go

@@ -0,0 +1,75 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MaxAddressesPerMsg is the maximum number of addresses that can be in a single
+// kaspa Addresses message (MsgAddresses).
+const MaxAddressesPerMsg = 1000
+
+// MsgAddresses implements the Message interface and represents a kaspa
+// Addresses message. It is used to provide a list of known active peers on the
+// network. An active peer is considered one that has transmitted a message
+// within the last 3 hours. Nodes which have not transmitted in that time
+// frame should be forgotten. Each message is limited to a maximum number of
+// addresses, which is currently 1000. As a result, multiple messages must
+// be used to relay the full list.
+//
+// Use the AddAddress function to build up the list of known addresses when
+// sending an Addresses message to another peer.
+type MsgAddresses struct {
+	baseMessage
+	IncludeAllSubnetworks bool
+	SubnetworkID          *subnetworkid.SubnetworkID
+	AddrList              []*NetAddress
+}
+
+// AddAddress adds a known active peer to the message.
+func (msg *MsgAddresses) AddAddress(na *NetAddress) error {
+	if len(msg.AddrList)+1 > MaxAddressesPerMsg {
+		str := fmt.Sprintf("too many addresses in message [max %d]",
+			MaxAddressesPerMsg)
+		return messageError("MsgAddresses.AddAddress", str)
+	}
+
+	msg.AddrList = append(msg.AddrList, na)
+	return nil
+}
+
+// AddAddresses adds multiple known active peers to the message.
+func (msg *MsgAddresses) AddAddresses(netAddrs ...*NetAddress) error {
+	for _, na := range netAddrs {
+		err := msg.AddAddress(na)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ClearAddresses removes all addresses from the message.
+func (msg *MsgAddresses) ClearAddresses() {
+	msg.AddrList = []*NetAddress{}
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgAddresses) Command() MessageCommand {
+	return CmdAddresses
+}
+
+// NewMsgAddresses returns a new kaspa Addresses message that conforms to the
+// Message interface. See MsgAddresses for details.
+func NewMsgAddresses(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) *MsgAddresses {
+	return &MsgAddresses{
+		IncludeAllSubnetworks: includeAllSubnetworks,
+		SubnetworkID:          subnetworkID,
+		AddrList:              make([]*NetAddress, 0, MaxAddressesPerMsg),
+	}
+}

app/appmessage/msgaddresses_test.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"net"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestAddresses tests the MsgAddresses API.
+func TestAddresses(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(3)
+	msg := NewMsgAddresses(false, nil)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure NetAddresses are added properly.
+	tcpAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
+	na := NewNetAddress(tcpAddr, SFNodeNetwork)
+	err := msg.AddAddress(na)
+	if err != nil {
+		t.Errorf("AddAddress: %v", err)
+	}
+	if msg.AddrList[0] != na {
+		t.Errorf("AddAddress: wrong address added - got %v, want %v",
+			spew.Sprint(msg.AddrList[0]), spew.Sprint(na))
+	}
+
+	// Ensure the address list is cleared properly.
+	msg.ClearAddresses()
+	if len(msg.AddrList) != 0 {
+		t.Errorf("ClearAddresses: address list is not empty - "+
+			"got %v [%v], want %v", len(msg.AddrList),
+			spew.Sprint(msg.AddrList[0]), 0)
+	}
+
+	// Ensure adding more than the max allowed addresses per message returns
+	// error.
+	for i := 0; i < MaxAddressesPerMsg+1; i++ {
+		err = msg.AddAddress(na)
+	}
+	if err == nil {
+		t.Errorf("AddAddress: expected error on too many addresses " +
+			"not received")
+	}
+	err = msg.AddAddresses(na)
+	if err == nil {
+		t.Errorf("AddAddresses: expected error on too many addresses " +
+			"not received")
+	}
+}

app/appmessage/msgblock.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
@@ -27,9 +27,9 @@ const MaxMassPerBlock = 10000000
 // MaxMassPerTx is the maximum total mass a transaction may have.
 const MaxMassPerTx = MaxMassPerBlock / 2
 
-// maxTxPerBlock is the maximum number of transactions that could
+// MaxTxPerBlock is the maximum number of transactions that could
 // possibly fit into a block.
-const maxTxPerBlock = (MaxMassPerBlock / minTxPayload) + 1
+const MaxTxPerBlock = (MaxMassPerBlock / minTxPayload) + 1
 
 // TxLoc holds locator data for the offset and length of where a transaction is
 // located within a MsgBlock data buffer.
@@ -42,6 +42,7 @@ type TxLoc struct {
 // block message. It is used to deliver block and transaction information in
 // response to a getdata message (MsgGetData) for a given block hash.
 type MsgBlock struct {
+	baseMessage
 	Header       BlockHeader
 	Transactions []*MsgTx
 }
@@ -59,7 +60,7 @@ func (msg *MsgBlock) ClearTransactions() {
 // KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding blocks stored to disk, such as in a database, as
-// opposed to decoding blocks from the wire.
+// opposed to decoding blocks from the appmessage.
 func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
 	err := readBlockHeader(r, pver, &msg.Header)
 	if err != nil {
@@ -74,9 +75,9 @@ func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
 	// Prevent more transactions than could possibly fit into a block.
 	// It would be possible to cause memory exhaustion and panics without
 	// a sane upper bound on this count.
-	if txCount > maxTxPerBlock {
+	if txCount > MaxTxPerBlock {
 		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, maxTxPerBlock)
+			"[count %d, max %d]", txCount, MaxTxPerBlock)
 		return messageError("MsgBlock.KaspaDecode", str)
 	}
 
@@ -96,14 +97,14 @@ func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
 // Deserialize decodes a block from r into the receiver using a format that is
 // suitable for long-term storage such as a database while respecting the
 // Version field in the block. This function differs from KaspaDecode in that
-// KaspaDecode decodes from the kaspa wire protocol as it was sent across the
-// network. The wire encoding can technically differ depending on the protocol
+// KaspaDecode decodes from the kaspa appmessage protocol as it was sent across the
+// network. The appmessage encoding can technically differ depending on the protocol
 // version and doesn't even really need to match the format of a stored block at
 // all. As of the time this comment was written, the encoded block is the same
 // in both instances, but there is a distinct difference and separating the two
 // allows the API to be flexible enough to deal with changes.
 func (msg *MsgBlock) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of KaspaDecode.
 	return msg.KaspaDecode(r, 0)
@@ -116,9 +117,9 @@ func (msg *MsgBlock) Deserialize(r io.Reader) error {
 func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 	fullLen := r.Len()
 
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of existing wire protocol functions.
+	// a result, make use of existing appmessage protocol functions.
 	err := readBlockHeader(r, 0, &msg.Header)
 	if err != nil {
 		return nil, err
@@ -132,9 +133,9 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 	// Prevent more transactions than could possibly fit into a block.
 	// It would be possible to cause memory exhaustion and panics without
 	// a sane upper bound on this count.
-	if txCount > maxTxPerBlock {
+	if txCount > MaxTxPerBlock {
 		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, maxTxPerBlock)
+			"[count %d, max %d]", txCount, MaxTxPerBlock)
 		return nil, messageError("MsgBlock.DeserializeTxLoc", str)
 	}
 
@@ -159,7 +160,7 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 // KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding blocks to be stored to disk, such as in a
-// database, as opposed to encoding blocks for the wire.
+// database, as opposed to encoding blocks for the appmessage.
 func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
 	err := writeBlockHeader(w, pver, &msg.Header)
 	if err != nil {
@@ -184,14 +185,14 @@ func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
 // Serialize encodes the block to w using a format that suitable for long-term
 // storage such as a database while respecting the Version field in the block.
 // This function differs from KaspaEncode in that KaspaEncode encodes the block to
-// the kaspa wire protocol in order to be sent across the network. The wire
+// the kaspa appmessage protocol in order to be sent across the network. The appmessage
 // encoding can technically differ depending on the protocol version and doesn't
 // even really need to match the format of a stored block at all. As of the
 // time this comment was written, the encoded block is the same in both
 // instances, but there is a distinct difference and separating the two allows
 // the API to be flexible enough to deal with changes.
 func (msg *MsgBlock) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of KaspaEncode.
 	return msg.KaspaEncode(w, 0)
@@ -213,7 +214,7 @@ func (msg *MsgBlock) SerializeSize() int {
 
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgBlock) Command() string {
+func (msg *MsgBlock) Command() MessageCommand {
 	return CmdBlock
 }
 

app/appmessage/msgblock_test.go

@@ -2,17 +2,17 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/pkg/errors"
 	"io"
 	"math"
 	"reflect"
 	"testing"
-	"time"
-
-	"github.com/kaspanet/kaspad/util/subnetworkid"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -32,7 +32,7 @@ func TestBlock(t *testing.T) {
 	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
-	wantCmd := "block"
+	wantCmd := MessageCommand(5)
 	msg := NewMsgBlock(bh)
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgBlock: wrong command - got %v want %v",
@@ -74,7 +74,7 @@ func TestBlock(t *testing.T) {
 // TestBlockHash tests the ability to generate the hash of a block accurately.
 func TestBlockHash(t *testing.T) {
 	// Block 1 hash.
-	hashStr := "22e72b61a572bfb32b8739f4e5db3eebe9870e394288467958e93e4a3d3b749f"
+	hashStr := "55d71bd49a8233bc9f0edbcbd0ad5d3eaebffe1fc6a6443a1c1f310fd02c11a5"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -144,15 +144,15 @@ func TestConvertToPartial(t *testing.T) {
 	}
 }
 
-// TestBlockWire tests the MsgBlock wire encode and decode for various numbers
+// TestBlockEncoding tests the MsgBlock appmessage encode and decode for various numbers
 // of transaction inputs and outputs and protocol versions.
-func TestBlockWire(t *testing.T) {
+func TestBlockEncoding(t *testing.T) {
 	tests := []struct {
 		in     *MsgBlock // Message to encode
 		out    *MsgBlock // Expected decoded message
-		buf    []byte    // Wire encoding
+		buf    []byte    // Encoded value
 		txLocs []TxLoc   // Expected transaction locations
-		pver   uint32    // Protocol version for wire encoding
+		pver   uint32    // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		{
@@ -166,7 +166,7 @@ func TestBlockWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode the message to wire format.
+		// Encode the message to appmessage format.
 		var buf bytes.Buffer
 		err := test.in.KaspaEncode(&buf, test.pver)
 		if err != nil {
@@ -179,7 +179,7 @@ func TestBlockWire(t *testing.T) {
 			continue
 		}
 
-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgBlock
 		rbuf := bytes.NewReader(test.buf)
 		err = msg.KaspaDecode(rbuf, test.pver)
@@ -195,15 +195,15 @@ func TestBlockWire(t *testing.T) {
 	}
 }
 
-// TestBlockWireErrors performs negative tests against wire encode and decode
+// TestBlockEncodingErrors performs negative tests against appmessage encode and decode
 // of MsgBlock to confirm error paths work correctly.
-func TestBlockWireErrors(t *testing.T) {
+func TestBlockEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	tests := []struct {
 		in       *MsgBlock // Value to encode
-		buf      []byte    // Wire encoding
-		pver     uint32    // Protocol version for wire encoding
+		buf      []byte    // Encoded value
+		pver     uint32    // Protocol version for appmessage encoding
 		max      int       // Max size of fixed buffer to induce errors
 		writeErr error     // Expected write error
 		readErr  error     // Expected read error
@@ -236,20 +236,20 @@ func TestBlockWireErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := test.in.KaspaEncode(w, test.pver)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgBlock
 		r := newFixedReader(test.max, test.buf)
 		err = msg.KaspaDecode(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -324,7 +324,7 @@ func TestBlockSerialize(t *testing.T) {
 	}
 }
 
-// TestBlockSerializeErrors performs negative tests against wire encode and
+// TestBlockSerializeErrors performs negative tests against appmessage encode and
 // decode of MsgBlock to confirm error paths work correctly.
 func TestBlockSerializeErrors(t *testing.T) {
 	tests := []struct {
@@ -365,7 +365,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		// Serialize the block.
 		w := newFixedWriter(test.max)
 		err := test.in.Serialize(w)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
@@ -375,7 +375,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		var block MsgBlock
 		r := newFixedReader(test.max, test.buf)
 		err = block.Deserialize(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -384,7 +384,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		var txLocBlock MsgBlock
 		br := bytes.NewBuffer(test.buf[0:test.max])
 		_, err = txLocBlock.DeserializeTxLoc(br)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -400,8 +400,8 @@ func TestBlockOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		// Block that claims to have ~uint64(0) transactions.
@@ -431,7 +431,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 				0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 				0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 				0xff, 0xff, 0x00, 0x1d, // Bits
-				0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+				0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 				0xff, // TxnCount
 			}, pver, &MessageError{},
@@ -440,7 +440,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgBlock
 		r := bytes.NewReader(test.buf)
 		err := msg.KaspaDecode(r, test.pver)
@@ -450,7 +450,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 			continue
 		}
 
-		// Deserialize from wire format.
+		// Deserialize from appmessage format.
 		r = bytes.NewReader(test.buf)
 		err = msg.Deserialize(r)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -459,7 +459,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 			continue
 		}
 
-		// Deserialize with transaction location info from wire format.
+		// Deserialize with transaction location info from appmessage format.
 		br := bytes.NewBuffer(test.buf)
 		_, err = msg.DeserializeTxLoc(br)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -507,9 +507,9 @@ var blockOne = MsgBlock{
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
-		Bits:                 0x1d00ffff,               // 486604799
-		Nonce:                0x9962e301,               // 2573394689
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
+		Bits:                 0x1d00ffff, // 486604799
+		Nonce:                0x9962e301, // 2573394689
 	},
 	Transactions: []*MsgTx{
 		NewNativeMsgTx(1,
@@ -570,9 +570,9 @@ var blockOneBytes = []byte{
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+	0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 	0xff, 0xff, 0x00, 0x1d, // Bits
-	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	0x01,                   // TxnCount
 	0x01, 0x00, 0x00, 0x00, // Version
 	0x01, // Varint for number of transaction inputs

app/appmessage/msgblocklocator.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxBlockLocatorsPerMsg is the maximum number of block locator hashes allowed
+// per message.
+const MaxBlockLocatorsPerMsg = 500
+
+// MsgBlockLocator implements the Message interface and represents a kaspa
+// locator message. It is used to find the blockLocator of a peer that is
+// syncing with you.
+type MsgBlockLocator struct {
+	baseMessage
+	BlockLocatorHashes []*daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgBlockLocator) Command() MessageCommand {
+	return CmdBlockLocator
+}
+
+// NewMsgBlockLocator returns a new kaspa locator message that conforms to
+// the Message interface. See MsgBlockLocator for details.
+func NewMsgBlockLocator(locatorHashes []*daghash.Hash) *MsgBlockLocator {
+	return &MsgBlockLocator{
+		BlockLocatorHashes: locatorHashes,
+	}
+}

app/appmessage/msgblocklocator_test.go

@@ -0,0 +1,34 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestBlockLocator tests the MsgBlockLocator API.
+func TestBlockLocator(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	locatorHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	msg := NewMsgBlockLocator([]*daghash.Hash{locatorHash})
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(10)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgBlockLocator: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure block locator hashes are added properly.
+	if msg.BlockLocatorHashes[0] != locatorHash {
+		t.Errorf("AddBlockLocatorHash: wrong block locator added - "+
+			"got %v, want %v",
+			spew.Sprint(msg.BlockLocatorHashes[0]),
+			spew.Sprint(locatorHash))
+	}
+}

app/appmessage/msgdoneibdblocks.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgDoneIBDBlocks implements the Message interface and represents a kaspa
+// DoneIBDBlocks message. It is used to notify the IBD syncing peer that the
+// syncer sent all the requested blocks.
+//
+// This message has no payload.
+type MsgDoneIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgDoneIBDBlocks) Command() MessageCommand {
+	return CmdDoneIBDBlocks
+}
+
+// NewMsgDoneIBDBlocks returns a new kaspa DoneIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgDoneIBDBlocks() *MsgDoneIBDBlocks {
+	return &MsgDoneIBDBlocks{}
+}

app/appmessage/msgibdblock.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgIBDBlock implements the Message interface and represents a kaspa
+// ibdblock message. It is used to deliver block and transaction information in
+// response to a RequestIBDBlocks message (MsgRequestIBDBlocks).
+type MsgIBDBlock struct {
+	baseMessage
+	*MsgBlock
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDBlock) Command() MessageCommand {
+	return CmdIBDBlock
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver. This is part of the Message interface implementation.
+func (msg *MsgIBDBlock) MaxPayloadLength(pver uint32) uint32 {
+	return MaxMessagePayload
+}
+
+// NewMsgIBDBlock returns a new kaspa ibdblock message that conforms to the
+// Message interface. See MsgIBDBlock for details.
+func NewMsgIBDBlock(msgBlock *MsgBlock) *MsgIBDBlock {
+	return &MsgIBDBlock{MsgBlock: msgBlock}
+}

app/appmessage/msgibdblock_test.go

@@ -0,0 +1,118 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestIBDBlock tests the MsgIBDBlock API.
+func TestIBDBlock(t *testing.T) {
+	pver := ProtocolVersion
+
+	// Block 1 header.
+	parentHashes := blockOne.Header.ParentHashes
+	hashMerkleRoot := blockOne.Header.HashMerkleRoot
+	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
+	utxoCommitment := blockOne.Header.UTXOCommitment
+	bits := blockOne.Header.Bits
+	nonce := blockOne.Header.Nonce
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(17)
+	msg := NewMsgIBDBlock(NewMsgBlock(bh))
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure max payload is expected value for latest protocol version.
+	wantPayload := uint32(1024 * 1024 * 32)
+	maxPayload := msg.MaxPayloadLength(pver)
+	if maxPayload != wantPayload {
+		t.Errorf("MaxPayloadLength: wrong max payload length for "+
+			"protocol version %d - got %v, want %v", pver,
+			maxPayload, wantPayload)
+	}
+
+	// Ensure we get the same block header data back out.
+	if !reflect.DeepEqual(&msg.Header, bh) {
+		t.Errorf("NewMsgIBDBlock: wrong block header - got %v, want %v",
+			spew.Sdump(&msg.Header), spew.Sdump(bh))
+	}
+
+	// Ensure transactions are added properly.
+	tx := blockOne.Transactions[0].Copy()
+	msg.AddTransaction(tx)
+	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
+		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
+			spew.Sdump(msg.Transactions),
+			spew.Sdump(blockOne.Transactions))
+	}
+
+	// Ensure transactions are properly cleared.
+	msg.ClearTransactions()
+	if len(msg.Transactions) != 0 {
+		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
+			len(msg.Transactions), 0)
+	}
+}
+
+// TestIBDBlockEncoding tests the MsgIBDBlock appmessage encode and decode for various numbers
+// of transaction inputs and outputs and protocol versions.
+func TestIBDBlockEncoding(t *testing.T) {
+	tests := []struct {
+		in     *MsgIBDBlock // Message to encode
+		out    *MsgIBDBlock // Expected decoded message
+		buf    []byte       // Encoded value
+		txLocs []TxLoc      // Expected transaction locations
+		pver   uint32       // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		{
+			&MsgIBDBlock{MsgBlock: &blockOne},
+			&MsgIBDBlock{MsgBlock: &blockOne},
+			blockOneBytes,
+			blockOneTxLocs,
+			ProtocolVersion,
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode the message to appmessage format.
+		var buf bytes.Buffer
+		err := test.in.KaspaEncode(&buf, test.pver)
+		if err != nil {
+			t.Errorf("KaspaEncode #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode the message from appmessage format.
+		var msg MsgIBDBlock
+		msg.MsgBlock = new(MsgBlock)
+		rbuf := bytes.NewReader(test.buf)
+		err = msg.KaspaDecode(rbuf, test.pver)
+		if err != nil {
+			t.Errorf("KaspaDecode #%d error %v", i, err)
+			continue
+		}
+		if !reflect.DeepEqual(&msg, test.out) {
+			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
+				spew.Sdump(&msg), spew.Sdump(test.out))
+			continue
+		}
+	}
+}

app/appmessage/msginvrelayblock.go

@@ -0,0 +1,27 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgInvRelayBlock implements the Message interface and represents a kaspa
+// block inventory message. It is used to notify the network about new block
+// by sending their hash, and let the receiving node decide if it needs it.
+type MsgInvRelayBlock struct {
+	baseMessage
+	Hash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgInvRelayBlock) Command() MessageCommand {
+	return CmdInvRelayBlock
+}
+
+// NewMsgInvBlock returns a new kaspa invrelblk message that conforms to
+// the Message interface. See MsgInvRelayBlock for details.
+func NewMsgInvBlock(hash *daghash.Hash) *MsgInvRelayBlock {
+	return &MsgInvRelayBlock{
+		Hash: hash,
+	}
+}

app/appmessage/msginvtransaction.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxInvPerTxInvMsg is the maximum number of hashes that can
+// be in a single CmdInvTransaction message.
+const MaxInvPerTxInvMsg = MaxInvPerMsg
+
+// MsgInvTransaction implements the Message interface and represents a kaspa
+// TxInv message. It is used to notify the network about new transactions
+// by sending their ID, and let the receiving node decide if it needs it.
+type MsgInvTransaction struct {
+	baseMessage
+	TxIDs []*daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgInvTransaction) Command() MessageCommand {
+	return CmdInvTransaction
+}
+
+// NewMsgInvTransaction returns a new kaspa TxInv message that conforms to
+// the Message interface. See MsgInvTransaction for details.
+func NewMsgInvTransaction(ids []*daghash.TxID) *MsgInvTransaction {
+	return &MsgInvTransaction{
+		TxIDs: ids,
+	}
+}

app/appmessage/msgping.go

@@ -2,11 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
-
-import (
-	"io"
-)
+package appmessage
 
 // MsgPing implements the Message interface and represents a kaspa ping
 // message.
@@ -20,46 +16,18 @@ import (
 // The payload for this message just consists of a nonce used for identifying
 // it later.
 type MsgPing struct {
+	baseMessage
 	// Unique value associated with message that is used to identify
 	// specific ping message.
 	Nonce uint64
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-func (msg *MsgPing) KaspaDecode(r io.Reader, pver uint32) error {
-	err := ReadElement(r, &msg.Nonce)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-func (msg *MsgPing) KaspaEncode(w io.Writer, pver uint32) error {
-	err := WriteElement(w, msg.Nonce)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgPing) Command() string {
+func (msg *MsgPing) Command() MessageCommand {
 	return CmdPing
 }
 
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgPing) MaxPayloadLength(pver uint32) uint32 {
-	// Nonce 8 bytes.
-	return uint32(8)
-}
-
 // NewMsgPing returns a new kaspa ping message that conforms to the Message
 // interface. See MsgPing for details.
 func NewMsgPing(nonce uint64) *MsgPing {

app/appmessage/msgping_test.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/random"
+)
+
+// TestPing tests the MsgPing API against the latest protocol version.
+func TestPing(t *testing.T) {
+	// Ensure we get the same nonce back out.
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: Error generating nonce: %v", err)
+	}
+	msg := NewMsgPing(nonce)
+	if msg.Nonce != nonce {
+		t.Errorf("NewMsgPing: wrong nonce - got %v, want %v",
+			msg.Nonce, nonce)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(7)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgPing: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgpong.go

@@ -2,11 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
-
-import (
-	"io"
-)
+package appmessage
 
 // MsgPong implements the Message interface and represents a kaspa pong
 // message which is used primarily to confirm that a connection is still valid
@@ -14,36 +10,18 @@ import (
 //
 // This message was not added until protocol versions AFTER BIP0031Version.
 type MsgPong struct {
+	baseMessage
 	// Unique value associated with message that is used to identify
 	// specific ping message.
 	Nonce uint64
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-func (msg *MsgPong) KaspaDecode(r io.Reader, pver uint32) error {
-	return ReadElement(r, &msg.Nonce)
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-func (msg *MsgPong) KaspaEncode(w io.Writer, pver uint32) error {
-	return WriteElement(w, msg.Nonce)
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgPong) Command() string {
+func (msg *MsgPong) Command() MessageCommand {
 	return CmdPong
 }
 
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgPong) MaxPayloadLength(pver uint32) uint32 {
-	// Nonce 8 bytes.
-	return uint32(8)
-}
-
 // NewMsgPong returns a new kaspa pong message that conforms to the Message
 // interface. See MsgPong for details.
 func NewMsgPong(nonce uint64) *MsgPong {

app/appmessage/msgpong_test.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/random"
+)
+
+// TestPongLatest tests the MsgPong API against the latest protocol version.
+func TestPongLatest(t *testing.T) {
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: error generating nonce: %v", err)
+	}
+	msg := NewMsgPong(nonce)
+	if msg.Nonce != nonce {
+		t.Errorf("NewMsgPong: wrong nonce - got %v, want %v",
+			msg.Nonce, nonce)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(8)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgPong: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgreject.go

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

app/appmessage/msgrequestaddresses.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MsgRequestAddresses implements the Message interface and represents a kaspa
+// RequestAddresses message. It is used to request a list of known active peers on the
+// network from a peer to help identify potential nodes. The list is returned
+// via one or more addr messages (MsgAddresses).
+//
+// This message has no payload.
+type MsgRequestAddresses struct {
+	baseMessage
+	IncludeAllSubnetworks bool
+	SubnetworkID          *subnetworkid.SubnetworkID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestAddresses) Command() MessageCommand {
+	return CmdRequestAddresses
+}
+
+// NewMsgRequestAddresses returns a new kaspa RequestAddresses message that conforms to the
+// Message interface. See MsgRequestAddresses for details.
+func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) *MsgRequestAddresses {
+	return &MsgRequestAddresses{
+		IncludeAllSubnetworks: includeAllSubnetworks,
+		SubnetworkID:          subnetworkID,
+	}
+}

app/appmessage/msgrequestaddresses_test.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestRequestAddresses tests the MsgRequestAddresses API.
+func TestRequestAddresses(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(2)
+	msg := NewMsgRequestAddresses(false, nil)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestAddresses: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgrequestblocklocator.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestBlockLocator implements the Message interface and represents a kaspa
+// RequestBlockLocator message. It is used to request a block locator between high
+// and low hash.
+// The locator is returned via a locator message (MsgBlockLocator).
+type MsgRequestBlockLocator struct {
+	baseMessage
+	HighHash *daghash.Hash
+	LowHash  *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestBlockLocator) Command() MessageCommand {
+	return CmdRequestBlockLocator
+}
+
+// NewMsgRequestBlockLocator returns a new RequestBlockLocator message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequestBlockLocator(highHash, lowHash *daghash.Hash) *MsgRequestBlockLocator {
+	return &MsgRequestBlockLocator{
+		HighHash: highHash,
+		LowHash:  lowHash,
+	}
+}

app/appmessage/msgrequestblocklocator_test.go

@@ -0,0 +1,24 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestRequestBlockLocator tests the MsgRequestBlockLocator API.
+func TestRequestBlockLocator(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	highHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(9)
+	msg := NewMsgRequestBlockLocator(highHash, &daghash.ZeroHash)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestBlockLocator: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgrequestibdblocks.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestIBDBlocks implements the Message interface and represents a kaspa
+// RequestIBDBlocks message. It is used to request a list of blocks starting after the
+// low hash and until the high hash.
+type MsgRequestIBDBlocks struct {
+	baseMessage
+	LowHash  *daghash.Hash
+	HighHash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDBlocks) Command() MessageCommand {
+	return CmdRequestIBDBlocks
+}
+
+// NewMsgRequstIBDBlocks returns a new kaspa RequestIBDBlocks message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequstIBDBlocks(lowHash, highHash *daghash.Hash) *MsgRequestIBDBlocks {
+	return &MsgRequestIBDBlocks{
+		LowHash:  lowHash,
+		HighHash: highHash,
+	}
+}

app/appmessage/msgrequestibdblocks_test.go

@@ -0,0 +1,40 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
+func TestRequstIBDBlocks(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	lowHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	hashStr = "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	highHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	// Ensure we get the same data back out.
+	msg := NewMsgRequstIBDBlocks(lowHash, highHash)
+	if !msg.HighHash.IsEqual(highHash) {
+		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
+			msg.HighHash, highHash)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(4)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequstIBDBlocks: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgrequestnextibdblocks.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgRequestNextIBDBlocks implements the Message interface and represents a kaspa
+// RequestNextIBDBlocks message. It is used to notify the IBD syncer peer to send
+// more blocks.
+//
+// This message has no payload.
+type MsgRequestNextIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestNextIBDBlocks) Command() MessageCommand {
+	return CmdRequestNextIBDBlocks
+}
+
+// NewMsgRequestNextIBDBlocks returns a new kaspa RequestNextIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgRequestNextIBDBlocks() *MsgRequestNextIBDBlocks {
+	return &MsgRequestNextIBDBlocks{}
+}

app/appmessage/msgrequestrelayblocks.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestRelayBlocksHashes is the maximum number of hashes that can
+// be in a single RequestRelayBlocks message.
+const MsgRequestRelayBlocksHashes = MaxInvPerMsg
+
+// MsgRequestRelayBlocks implements the Message interface and represents a kaspa
+// RequestRelayBlocks message. It is used to request blocks as part of the block
+// relay protocol.
+type MsgRequestRelayBlocks struct {
+	baseMessage
+	Hashes []*daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestRelayBlocks) Command() MessageCommand {
+	return CmdRequestRelayBlocks
+}
+
+// NewMsgRequestRelayBlocks returns a new kaspa RequestRelayBlocks message that conforms to
+// the Message interface. See MsgRequestRelayBlocks for details.
+func NewMsgRequestRelayBlocks(hashes []*daghash.Hash) *MsgRequestRelayBlocks {
+	return &MsgRequestRelayBlocks{
+		Hashes: hashes,
+	}
+}

app/appmessage/msgrequestselectedtip.go

@@ -0,0 +1,21 @@
+package appmessage
+
+// MsgRequestSelectedTip implements the Message interface and represents a kaspa
+// RequestSelectedTip message. It is used to request the selected tip of another peer.
+//
+// This message has no payload.
+type MsgRequestSelectedTip struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestSelectedTip) Command() MessageCommand {
+	return CmdRequestSelectedTip
+}
+
+// NewMsgRequestSelectedTip returns a new kaspa RequestSelectedTip message that conforms to the
+// Message interface.
+func NewMsgRequestSelectedTip() *MsgRequestSelectedTip {
+	return &MsgRequestSelectedTip{}
+}

app/appmessage/msgrequestselectedtip_test.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestRequestSelectedTip tests the MsgRequestSelectedTip API.
+func TestRequestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(12)
+	msg := NewMsgRequestSelectedTip()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgrequesttransactions.go

@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxInvPerRequestTransactionsMsg is the maximum number of hashes that can
+// be in a single CmdInvTransaction message.
+const MaxInvPerRequestTransactionsMsg = MaxInvPerMsg
+
+// MsgRequestTransactions implements the Message interface and represents a kaspa
+// RequestTransactions message. It is used to request transactions as part of the
+// transactions relay protocol.
+type MsgRequestTransactions struct {
+	baseMessage
+	IDs []*daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestTransactions) Command() MessageCommand {
+	return CmdRequestTransactions
+}
+
+// NewMsgRequestTransactions returns a new kaspa RequestTransactions message that conforms to
+// the Message interface. See MsgRequestTransactions for details.
+func NewMsgRequestTransactions(ids []*daghash.TxID) *MsgRequestTransactions {
+	return &MsgRequestTransactions{
+		IDs: ids,
+	}
+}

app/appmessage/msgselectedtip.go

@@ -0,0 +1,28 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgSelectedTip implements the Message interface and represents a kaspa
+// selectedtip message. It is used to answer getseltip messages and tell
+// the asking peer what is the selected tip of this peer.
+type MsgSelectedTip struct {
+	baseMessage
+	// The selected tip hash of the generator of the message.
+	SelectedTipHash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgSelectedTip) Command() MessageCommand {
+	return CmdSelectedTip
+}
+
+// NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
+// Message interface.
+func NewMsgSelectedTip(selectedTipHash *daghash.Hash) *MsgSelectedTip {
+	return &MsgSelectedTip{
+		SelectedTipHash: selectedTipHash,
+	}
+}

app/appmessage/msgselectedtip_test.go

@@ -0,0 +1,18 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+	"testing"
+)
+
+// TestSelectedTip tests the MsgSelectedTip API.
+func TestSelectedTip(t *testing.T) {
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(11)
+	msg := NewMsgSelectedTip(&daghash.ZeroHash)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgtransactionnotfound.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgTransactionNotFound defines a kaspa TransactionNotFound message which is sent in response to
+// a RequestTransactions message if any of the requested data in not available on the peer.
+type MsgTransactionNotFound struct {
+	baseMessage
+	ID *daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgTransactionNotFound) Command() MessageCommand {
+	return CmdTransactionNotFound
+}
+
+// NewMsgTransactionNotFound returns a new kaspa transactionsnotfound message that conforms to the
+// Message interface. See MsgTransactionNotFound for details.
+func NewMsgTransactionNotFound(id *daghash.TxID) *MsgTransactionNotFound {
+	return &MsgTransactionNotFound{
+		ID: id,
+	}
+}

app/appmessage/msgtx.go

@@ -2,10 +2,9 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
-	"bytes"
 	"encoding/binary"
 	"fmt"
 	"io"
@@ -44,11 +43,11 @@ const (
 	SequenceLockTimeMask = 0x0000ffff
 
 	// SequenceLockTimeGranularity is the defined time based granularity
-	// for seconds-based relative time locks. When converting from seconds
+	// for milliseconds-based relative time locks. When converting from milliseconds
 	// to a sequence number, the value is right shifted by this amount,
-	// therefore the granularity of relative time locks in 512 or 2^9
-	// seconds. Enforced relative lock times are multiples of 512 seconds.
-	SequenceLockTimeGranularity = 9
+	// therefore the granularity of relative time locks in 524288 or 2^19
+	// seconds. Enforced relative lock times are multiples of 524288 milliseconds.
+	SequenceLockTimeGranularity = 19
 
 	// defaultTxInOutAlloc is the default size used for the backing array for
 	// transaction inputs and outputs. The array will dynamically grow as needed,
@@ -84,7 +83,7 @@ const (
 	minTxPayload = 10
 
 	// freeListMaxScriptSize is the size of each buffer in the free list
-	// that	is used for deserializing scripts from the wire before they are
+	// that	is used for deserializing scripts from the appmessage before they are
 	// concatenated into a single contiguous buffers. This value was chosen
 	// because it is slightly more than twice the size of the vast majority
 	// of all "standard" scripts. Larger scripts are still deserialized
@@ -268,6 +267,7 @@ func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
 // Use the AddTxIn and AddTxOut functions to build up the list of transaction
 // inputs and outputs.
 type MsgTx struct {
+	baseMessage
 	Version      int32
 	TxIn         []*TxIn
 	TxOut        []*TxOut
@@ -301,29 +301,34 @@ func (msg *MsgTx) IsCoinBase() bool {
 // TxHash generates the Hash for the transaction.
 func (msg *MsgTx) TxHash() *daghash.Hash {
 	// Encode the transaction and calculate double sha256 on the result.
-	// Ignore the error returns since the only way the encode could fail
-	// is being out of memory or due to nil pointers, both of which would
-	// cause a run-time panic.
-	buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(txEncodingExcludePayload)))
-	_ = msg.serialize(buf, txEncodingExcludePayload)
+	writer := daghash.NewDoubleHashWriter()
+	err := msg.serialize(writer, txEncodingExcludePayload)
+	if err != nil {
+		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
+		// and we assume we never construct malformed transactions.
+		panic(fmt.Sprintf("TxHash() failed. this should never fail for structurally-valid transactions. err: %+v", err))
+	}
 
-	hash := daghash.Hash(daghash.DoubleHashH(buf.Bytes()))
+	hash := writer.Finalize()
 	return &hash
 }
 
 // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
 func (msg *MsgTx) TxID() *daghash.TxID {
 	// Encode the transaction, replace signature script with zeroes, cut off
-	// payload and calculate double sha256 on the result. Ignore the error
-	// returns since the only way the encode could fail is being out of memory or
-	// due to nil pointers, both of which would cause a run-time panic.
+	// payload and calculate double sha256 on the result.
 	var encodingFlags txEncoding
 	if !msg.IsCoinBase() {
 		encodingFlags = txEncodingExcludeSignatureScript | txEncodingExcludePayload
 	}
-	buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(encodingFlags)))
-	_ = msg.serialize(buf, encodingFlags)
-	txID := daghash.TxID(daghash.DoubleHashH(buf.Bytes()))
+	writer := daghash.NewDoubleHashWriter()
+	err := msg.serialize(writer, encodingFlags)
+	if err != nil {
+		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
+		// and we assume we never construct malformed transactions.
+		panic(fmt.Sprintf("TxID() failed. this should never fail for structurally-valid transactions. err: %+v", err))
+	}
+	txID := daghash.TxID(writer.Finalize())
 	return &txID
 }
 
@@ -401,7 +406,7 @@ func (msg *MsgTx) Copy() *MsgTx {
 // KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding transactions stored to disk, such as in a
-// database, as opposed to decoding transactions from the wire.
+// database, as opposed to decoding transactions from the appmessage.
 func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
 	version, err := binaryserializer.Uint32(r, littleEndian)
 	if err != nil {
@@ -530,6 +535,10 @@ func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
 
 		msg.Payload = make([]byte, payloadLength)
 		_, err = io.ReadFull(r, msg.Payload)
+		if err != nil {
+			returnScriptBuffers()
+			return err
+		}
 	}
 
 	// Create a single allocation to house all of the scripts and set each
@@ -587,15 +596,15 @@ func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
 // Deserialize decodes a transaction from r into the receiver using a format
 // that is suitable for long-term storage such as a database while respecting
 // the Version field in the transaction. This function differs from KaspaDecode
-// in that KaspaDecode decodes from the kaspa wire protocol as it was sent
-// across the network. The wire encoding can technically differ depending on
+// in that KaspaDecode decodes from the kaspa appmessage protocol as it was sent
+// across the network. The appmessage encoding can technically differ depending on
 // the protocol version and doesn't even really need to match the format of a
 // stored transaction at all. As of the time this comment was written, the
 // encoded transaction is the same in both instances, but there is a distinct
 // difference and separating the two allows the API to be flexible enough to
 // deal with changes.
 func (msg *MsgTx) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of KaspaDecode.
 	return msg.KaspaDecode(r, 0)
@@ -604,7 +613,7 @@ func (msg *MsgTx) Deserialize(r io.Reader) error {
 // KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding transactions to be stored to disk, such as in a
-// database, as opposed to encoding transactions for the wire.
+// database, as opposed to encoding transactions for the appmessage.
 func (msg *MsgTx) KaspaEncode(w io.Writer, pver uint32) error {
 	return msg.encode(w, pver, txEncodingFull)
 }
@@ -693,22 +702,22 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err
 // Serialize encodes the transaction to w using a format that suitable for
 // long-term storage such as a database while respecting the Version field in
 // the transaction. This function differs from KaspaEncode in that KaspaEncode
-// encodes the transaction to the kaspa wire protocol in order to be sent
-// across the network. The wire encoding can technically differ depending on
+// encodes the transaction to the kaspa appmessage protocol in order to be sent
+// across the network. The appmessage encoding can technically differ depending on
 // the protocol version and doesn't even really need to match the format of a
 // stored transaction at all. As of the time this comment was written, the
 // encoded transaction is the same in both instances, but there is a distinct
 // difference and separating the two allows the API to be flexible enough to
 // deal with changes.
 func (msg *MsgTx) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of KaspaEncode.
 	return msg.KaspaEncode(w, 0)
 }
 
 func (msg *MsgTx) serialize(w io.Writer, encodingFlags txEncoding) error {
-	// At the current time, there is no difference between the wire encoding
+	// At the current time, there is no difference between the appmessage encoding
 	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of `encode`.
 	return msg.encode(w, 0, encodingFlags)
@@ -758,7 +767,7 @@ func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
 
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgTx) Command() string {
+func (msg *MsgTx) Command() MessageCommand {
 	return CmdTx
 }
 

app/appmessage/msgtx_test.go

@@ -2,11 +2,12 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"bytes"
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
 	"math"
 	"reflect"
@@ -29,10 +30,10 @@ func TestTx(t *testing.T) {
 	}
 
 	// Ensure the command is expected value.
-	wantCmd := "tx"
+	wantCmd := MessageCommand(6)
 	msg := NewNativeMsgTx(1, nil, nil)
 	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgAddr: wrong command - got %v want %v",
+		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}
 
@@ -191,7 +192,7 @@ func TestTxHashAndID(t *testing.T) {
 		return
 	}
 	payload := []byte{1, 2, 3}
-	txIns := []*TxIn{&TxIn{
+	txIns := []*TxIn{{
 		PreviousOutpoint: Outpoint{
 			Index: 0,
 			TxID:  daghash.TxID{1, 2, 3},
@@ -252,9 +253,9 @@ func TestTxHashAndID(t *testing.T) {
 	}
 }
 
-// TestTxWire tests the MsgTx wire encode and decode for various numbers
+// TestTxEncoding tests the MsgTx appmessage encode and decode for various numbers
 // of transaction inputs and outputs and protocol versions.
-func TestTxWire(t *testing.T) {
+func TestTxEncoding(t *testing.T) {
 	// Empty tx message.
 	noTx := NewNativeMsgTx(1, nil, nil)
 	noTxEncoded := []byte{
@@ -270,8 +271,8 @@ func TestTxWire(t *testing.T) {
 	tests := []struct {
 		in   *MsgTx // Message to encode
 		out  *MsgTx // Expected decoded message
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version with no transactions.
 		{
@@ -292,7 +293,7 @@ func TestTxWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode the message to wire format.
+		// Encode the message to appmessage format.
 		var buf bytes.Buffer
 		err := test.in.KaspaEncode(&buf, test.pver)
 		if err != nil {
@@ -305,7 +306,7 @@ func TestTxWire(t *testing.T) {
 			continue
 		}
 
-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgTx
 		rbuf := bytes.NewReader(test.buf)
 		err = msg.KaspaDecode(rbuf, test.pver)
@@ -321,15 +322,15 @@ func TestTxWire(t *testing.T) {
 	}
 }
 
-// TestTxWireErrors performs negative tests against wire encode and decode
+// TestTxEncodingErrors performs negative tests against appmessage encode and decode
 // of MsgTx to confirm error paths work correctly.
-func TestTxWireErrors(t *testing.T) {
+func TestTxEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion
 
 	tests := []struct {
 		in       *MsgTx // Value to encode
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -362,20 +363,20 @@ func TestTxWireErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := test.in.KaspaEncode(w, test.pver)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgTx
 		r := newFixedReader(test.max, test.buf)
 		err = msg.KaspaDecode(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -527,7 +528,7 @@ func TestTxSerialize(t *testing.T) {
 	}
 }
 
-// TestTxSerializeErrors performs negative tests against wire encode and decode
+// TestTxSerializeErrors performs negative tests against appmessage encode and decode
 // of MsgTx to confirm error paths work correctly.
 func TestTxSerializeErrors(t *testing.T) {
 	tests := []struct {
@@ -568,7 +569,7 @@ func TestTxSerializeErrors(t *testing.T) {
 		// Serialize the transaction.
 		w := newFixedWriter(test.max)
 		err := test.in.Serialize(w)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
@@ -578,7 +579,7 @@ func TestTxSerializeErrors(t *testing.T) {
 		var tx MsgTx
 		r := newFixedReader(test.max, test.buf)
 		err = tx.Deserialize(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -627,8 +628,8 @@ func TestTxOverflowErrors(t *testing.T) {
 	txVer := uint32(1)
 
 	tests := []struct {
-		buf     []byte // Wire encoding
-		pver    uint32 // Protocol version for wire encoding
+		buf     []byte // Encoded value
+		pver    uint32 // Protocol version for appmessage encoding
 		version uint32 // Transaction version
 		err     error  // Expected error
 	}{
@@ -690,7 +691,7 @@ func TestTxOverflowErrors(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgTx
 		r := bytes.NewReader(test.buf)
 		err := msg.KaspaDecode(r, test.pver)
@@ -700,7 +701,7 @@ func TestTxOverflowErrors(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r = bytes.NewReader(test.buf)
 		err = msg.Deserialize(r)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -890,7 +891,7 @@ var multiTxOuts = []*TxOut{
 }
 var multiTx = NewNativeMsgTx(1, multiTxIns, multiTxOuts)
 
-// multiTxEncoded is the wire encoded bytes for multiTx using protocol version
+// multiTxEncoded is the appmessage encoded bytes for multiTx using protocol version
 // 60002 and is used in the various tests.
 var multiTxEncoded = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version

app/appmessage/msgverack.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgVerAck defines a kaspa verack message which is used for a peer to
+// acknowledge a version message (MsgVersion) after it has used the information
+// to negotiate parameters. It implements the Message interface.
+//
+// This message has no payload.
+type MsgVerAck struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgVerAck) Command() MessageCommand {
+	return CmdVerAck
+}
+
+// NewMsgVerAck returns a new kaspa verack message that conforms to the
+// Message interface.
+func NewMsgVerAck() *MsgVerAck {
+	return &MsgVerAck{}
+}

app/appmessage/msgverack_test.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestVerAck tests the MsgVerAck API.
+func TestVerAck(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(1)
+	msg := NewMsgVerAck()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgVerAck: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/msgversion.go

@@ -0,0 +1,130 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/version"
+	"strings"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/mstime"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MaxUserAgentLen is the maximum allowed length for the user agent field in a
+// version message (MsgVersion).
+const MaxUserAgentLen = 256
+
+// DefaultUserAgent for appmessage in the stack
+var DefaultUserAgent = fmt.Sprintf("/kaspad:%s/", version.Version())
+
+// MsgVersion implements the Message interface and represents a kaspa version
+// message. It is used for a peer to advertise itself as soon as an outbound
+// connection is made. The remote peer then uses this information along with
+// its own to negotiate. The remote peer must then respond with a version
+// message of its own containing the negotiated values followed by a verack
+// message (MsgVerAck). This exchange must take place before any further
+// communication is allowed to proceed.
+type MsgVersion struct {
+	baseMessage
+	// Version of the protocol the node is using.
+	ProtocolVersion uint32
+
+	// The peer's network (mainnet, testnet, etc.)
+	Network string
+
+	// Bitfield which identifies the enabled services.
+	Services ServiceFlag
+
+	// Time the message was generated. This is encoded as an int64 on the appmessage.
+	Timestamp mstime.Time
+
+	// Address of the local peer.
+	Address *NetAddress
+
+	// The peer unique ID
+	ID *id.ID
+
+	// The user agent that generated messsage. This is a encoded as a varString
+	// on the appmessage. This has a max length of MaxUserAgentLen.
+	UserAgent string
+
+	// The selected tip hash of the generator of the version message.
+	SelectedTipHash *daghash.Hash
+
+	// Don't announce transactions to peer.
+	DisableRelayTx bool
+
+	// The subnetwork of the generator of the version message. Should be nil in full nodes
+	SubnetworkID *subnetworkid.SubnetworkID
+}
+
+// HasService returns whether the specified service is supported by the peer
+// that generated the message.
+func (msg *MsgVersion) HasService(service ServiceFlag) bool {
+	return msg.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (msg *MsgVersion) AddService(service ServiceFlag) {
+	msg.Services |= service
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgVersion) Command() MessageCommand {
+	return CmdVersion
+}
+
+// NewMsgVersion returns a new kaspa version message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
+	selectedTipHash *daghash.Hash, subnetworkID *subnetworkid.SubnetworkID) *MsgVersion {
+
+	// Limit the timestamp to one millisecond precision since the protocol
+	// doesn't support better.
+	return &MsgVersion{
+		ProtocolVersion: ProtocolVersion,
+		Network:         network,
+		Services:        0,
+		Timestamp:       mstime.Now(),
+		Address:         addr,
+		ID:              id,
+		UserAgent:       DefaultUserAgent,
+		SelectedTipHash: selectedTipHash,
+		DisableRelayTx:  false,
+		SubnetworkID:    subnetworkID,
+	}
+}
+
+// ValidateUserAgent checks userAgent length against MaxUserAgentLen
+func ValidateUserAgent(userAgent string) error {
+	if len(userAgent) > MaxUserAgentLen {
+		str := fmt.Sprintf("user agent too long [len %d, max %d]",
+			len(userAgent), MaxUserAgentLen)
+		return messageError("MsgVersion", str)
+	}
+	return nil
+}
+
+// AddUserAgent adds a user agent to the user agent string for the version
+// message. The version string is not defined to any strict format, although
+// it is recommended to use the form "major.minor.revision" e.g. "2.6.41".
+func (msg *MsgVersion) AddUserAgent(name string, version string,
+	comments ...string) {
+
+	newUserAgent := fmt.Sprintf("%s:%s", name, version)
+	if len(comments) != 0 {
+		newUserAgent = fmt.Sprintf("%s(%s)", newUserAgent,
+			strings.Join(comments, "; "))
+	}
+	newUserAgent = fmt.Sprintf("%s%s/", msg.UserAgent, newUserAgent)
+	msg.UserAgent = newUserAgent
+}

app/appmessage/msgversion_test.go

@@ -0,0 +1,96 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"net"
+	"reflect"
+	"testing"
+)
+
+// TestVersion tests the MsgVersion API.
+func TestVersion(t *testing.T) {
+	pver := ProtocolVersion
+
+	// Create version message data.
+	selectedTipHash := &daghash.Hash{12, 34}
+	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
+	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
+	generatedID, err := id.GenerateID()
+	if err != nil {
+		t.Fatalf("id.GenerateID: %s", err)
+	}
+
+	// Ensure we get the correct data back out.
+	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
+	if msg.ProtocolVersion != pver {
+		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
+			msg.ProtocolVersion, pver)
+	}
+	if !reflect.DeepEqual(msg.Address, me) {
+		t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
+			spew.Sdump(&msg.Address), spew.Sdump(me))
+	}
+	if msg.ID.String() != generatedID.String() {
+		t.Errorf("NewMsgVersion: wrong nonce - got %s, want %s",
+			msg.ID, generatedID)
+	}
+	if msg.UserAgent != DefaultUserAgent {
+		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
+			msg.UserAgent, DefaultUserAgent)
+	}
+	if !msg.SelectedTipHash.IsEqual(selectedTipHash) {
+		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
+			msg.SelectedTipHash, selectedTipHash)
+	}
+	if msg.DisableRelayTx {
+		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
+			"default - got %v, want %v", msg.DisableRelayTx, false)
+	}
+
+	msg.AddUserAgent("myclient", "1.2.3", "optional", "comments")
+	customUserAgent := DefaultUserAgent + "myclient:1.2.3(optional; comments)/"
+	if msg.UserAgent != customUserAgent {
+		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
+			msg.UserAgent, customUserAgent)
+	}
+
+	msg.AddUserAgent("mygui", "3.4.5")
+	customUserAgent += "mygui:3.4.5/"
+	if msg.UserAgent != customUserAgent {
+		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
+			msg.UserAgent, customUserAgent)
+	}
+
+	// Version message should not have any services set by default.
+	if msg.Services != 0 {
+		t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
+			msg.Services, 0)
+
+	}
+	if msg.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service is set")
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(0)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgVersion: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure adding the full service node flag works.
+	msg.AddService(SFNodeNetwork)
+	if msg.Services != SFNodeNetwork {
+		t.Errorf("AddService: wrong services - got %v, want %v",
+			msg.Services, SFNodeNetwork)
+	}
+	if !msg.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service not set")
+	}
+}

app/appmessage/netaddress.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"net"
+)
+
+// NetAddress defines information about a peer on the network including the time
+// it was last seen, the services it supports, its IP address, and port.
+type NetAddress struct {
+	// Last time the address was seen.
+	Timestamp mstime.Time
+
+	// Bitfield which identifies the services supported by the address.
+	Services ServiceFlag
+
+	// IP address of the peer.
+	IP net.IP
+
+	// Port the peer is using. This is encoded in big endian on the appmessage
+	// which differs from most everything else.
+	Port uint16
+}
+
+// HasService returns whether the specified service is supported by the address.
+func (na *NetAddress) HasService(service ServiceFlag) bool {
+	return na.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (na *NetAddress) AddService(service ServiceFlag) {
+	na.Services |= service
+}
+
+// TCPAddress converts the NetAddress to *net.TCPAddr
+func (na *NetAddress) TCPAddress() *net.TCPAddr {
+	return &net.TCPAddr{
+		IP:   na.IP,
+		Port: int(na.Port),
+	}
+}
+
+// NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and
+// supported services with defaults for the remaining fields.
+func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
+	return NewNetAddressTimestamp(mstime.Now(), services, ip, port)
+}
+
+// NewNetAddressTimestamp returns a new NetAddress using the provided
+// timestamp, IP, port, and supported services. The timestamp is rounded to
+// single millisecond precision.
+func NewNetAddressTimestamp(
+	timestamp mstime.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
+	// Limit the timestamp to one millisecond precision since the protocol
+	// doesn't support better.
+	na := NetAddress{
+		Timestamp: timestamp,
+		Services:  services,
+		IP:        ip,
+		Port:      port,
+	}
+	return &na
+}
+
+// NewNetAddress returns a new NetAddress using the provided TCP address and
+// supported services with defaults for the remaining fields.
+func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
+	return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
+}

app/appmessage/netaddress_test.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"net"
+	"testing"
+)
+
+// TestNetAddress tests the NetAddress API.
+func TestNetAddress(t *testing.T) {
+	ip := net.ParseIP("127.0.0.1")
+	port := 16111
+
+	// Test NewNetAddress.
+	na := NewNetAddress(&net.TCPAddr{IP: ip, Port: port}, 0)
+
+	// Ensure we get the same ip, port, and services back out.
+	if !na.IP.Equal(ip) {
+		t.Errorf("NetNetAddress: wrong ip - got %v, want %v", na.IP, ip)
+	}
+	if na.Port != uint16(port) {
+		t.Errorf("NetNetAddress: wrong port - got %v, want %v", na.Port,
+			port)
+	}
+	if na.Services != 0 {
+		t.Errorf("NetNetAddress: wrong services - got %v, want %v",
+			na.Services, 0)
+	}
+	if na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service is set")
+	}
+
+	// Ensure adding the full service node flag works.
+	na.AddService(SFNodeNetwork)
+	if na.Services != SFNodeNetwork {
+		t.Errorf("AddService: wrong services - got %v, want %v",
+			na.Services, SFNodeNetwork)
+	}
+	if !na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service not set")
+	}
+}

app/appmessage/protocol.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
 	"fmt"
@@ -10,10 +10,13 @@ import (
 	"strings"
 )
 
-// XXX pedro: we will probably need to bump this.
 const (
 	// ProtocolVersion is the latest protocol version this package supports.
 	ProtocolVersion uint32 = 1
+
+	// DefaultServices describes the default services that are supported by
+	// the server.
+	DefaultServices = SFNodeNetwork | SFNodeBloom | SFNodeCF
 )
 
 // ServiceFlag identifies services supported by a kaspa peer.
@@ -103,9 +106,6 @@ const (
 	// Testnet represents the test network.
 	Testnet KaspaNet = 0xddb8af8f
 
-	// Regtest represents the regression test network.
-	Regtest KaspaNet = 0xf396cdd6
-
 	// Simnet represents the simulation test network.
 	Simnet KaspaNet = 0x374dcf1c
 
@@ -118,7 +118,6 @@ const (
 var bnStrings = map[KaspaNet]string{
 	Mainnet: "Mainnet",
 	Testnet: "Testnet",
-	Regtest: "Regtest",
 	Simnet:  "Simnet",
 	Devnet:  "Devnet",
 }

app/appmessage/protocol_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import "testing"
 
@@ -40,7 +40,6 @@ func TestKaspaNetStringer(t *testing.T) {
 		want string
 	}{
 		{Mainnet, "Mainnet"},
-		{Regtest, "Regtest"},
 		{Testnet, "Testnet"},
 		{Simnet, "Simnet"},
 		{0xffffffff, "Unknown KaspaNet (4294967295)"},

app/log.go

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

app/protocol/blocklogger/blocklogger.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2015-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blocklogger
+
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"sync"
+	"time"
+
+	"github.com/kaspanet/kaspad/util"
+)
+
+var (
+	receivedLogBlocks int64
+	receivedLogTx     int64
+	lastBlockLogTime  = mstime.Now()
+	mtx               sync.Mutex
+)
+
+// LogBlock logs a new block blue score as an information message
+// to show progress to the user. In order to prevent spam, it limits logging to
+// one message every 10 seconds with duration and totals included.
+func LogBlock(block *util.Block) error {
+	mtx.Lock()
+	defer mtx.Unlock()
+
+	receivedLogBlocks++
+	receivedLogTx += int64(len(block.MsgBlock().Transactions))
+
+	now := mstime.Now()
+	duration := now.Sub(lastBlockLogTime)
+	if duration < time.Second*10 {
+		return nil
+	}
+
+	// Truncate the duration to 10s of milliseconds.
+	tDuration := duration.Round(10 * time.Millisecond)
+
+	// Log information about new block blue score.
+	blockStr := "blocks"
+	if receivedLogBlocks == 1 {
+		blockStr = "block"
+	}
+	txStr := "transactions"
+	if receivedLogTx == 1 {
+		txStr = "transaction"
+	}
+
+	blueScore, err := block.BlueScore()
+	if err != nil {
+		return err
+	}
+
+	log.Infof("Processed %d %s in the last %s (%d %s, blue score %d, %s)",
+		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
+		txStr, blueScore, block.MsgBlock().Header.Timestamp)
+
+	receivedLogBlocks = 0
+	receivedLogTx = 0
+	lastBlockLogTime = now
+	return nil
+}

app/protocol/blocklogger/log.go

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

app/protocol/common/common.go

@@ -0,0 +1,14 @@
+package common
+
+import (
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// DefaultTimeout is the default duration to wait for enqueuing/dequeuing
+// to/from routes.
+const DefaultTimeout = 30 * time.Second
+
+// ErrPeerWithSameIDExists signifies that a peer with the same ID already exist.
+var ErrPeerWithSameIDExists = errors.New("ready peer with the same ID already exists")

app/protocol/flowcontext/addresses.go

@@ -0,0 +1,10 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+)
+
+// AddressManager returns the address manager associated to the flow context.
+func (f *FlowContext) AddressManager() *addressmanager.AddressManager {
+	return f.addressManager
+}

app/protocol/flowcontext/blocks.go

@@ -0,0 +1,74 @@
+package flowcontext
+
+import (
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// OnNewBlock updates the mempool after a new block arrival, and
+// relays newly unorphaned transactions and possibly rebroadcast
+// manually added transactions when not in IBD.
+func (f *FlowContext) OnNewBlock(block *util.Block) error {
+	transactionsAcceptedToMempool, err := f.txPool.HandleNewBlock(block)
+	if err != nil {
+		return err
+	}
+
+	return f.broadcastTransactionsAfterBlockAdded(block, transactionsAcceptedToMempool)
+}
+
+func (f *FlowContext) broadcastTransactionsAfterBlockAdded(block *util.Block, transactionsAcceptedToMempool []*util.Tx) error {
+	f.updateTransactionsToRebroadcast(block)
+
+	// Don't relay transactions when in IBD.
+	if atomic.LoadUint32(&f.isInIBD) != 0 {
+		return nil
+	}
+
+	var txIDsToRebroadcast []*daghash.TxID
+	if f.shouldRebroadcastTransactions() {
+		txIDsToRebroadcast = f.txIDsToRebroadcast()
+	}
+
+	txIDsToBroadcast := make([]*daghash.TxID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
+	for i, tx := range transactionsAcceptedToMempool {
+		txIDsToBroadcast[i] = tx.ID()
+	}
+	offset := len(transactionsAcceptedToMempool)
+	for i, txID := range txIDsToRebroadcast {
+		txIDsToBroadcast[offset+i] = txID
+	}
+
+	if len(txIDsToBroadcast) == 0 {
+		return nil
+	}
+	if len(txIDsToBroadcast) > appmessage.MaxInvPerTxInvMsg {
+		txIDsToBroadcast = txIDsToBroadcast[:appmessage.MaxInvPerTxInvMsg]
+	}
+	inv := appmessage.NewMsgInvTransaction(txIDsToBroadcast)
+	return f.Broadcast(inv)
+}
+
+// SharedRequestedBlocks returns a *blockrelay.SharedRequestedBlocks for sharing
+// data about requested blocks between different peers.
+func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks {
+	return f.sharedRequestedBlocks
+}
+
+// AddBlock adds the given block to the DAG and propagates it.
+func (f *FlowContext) AddBlock(block *util.Block, flags blockdag.BehaviorFlags) error {
+	_, _, err := f.DAG().ProcessBlock(block, flags)
+	if err != nil {
+		return err
+	}
+	err = f.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+	return f.Broadcast(appmessage.NewMsgInvBlock(block.Hash()))
+}

app/protocol/flowcontext/config.go

@@ -0,0 +1,8 @@
+package flowcontext
+
+import "github.com/kaspanet/kaspad/infrastructure/config"
+
+// Config returns an instance of *config.Config associated to the flow context.
+func (f *FlowContext) Config() *config.Config {
+	return f.cfg
+}

app/protocol/flowcontext/consensus.go

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

app/protocol/flowcontext/errors.go

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

app/protocol/flowcontext/flow_context.go

@@ -0,0 +1,63 @@
+package flowcontext
+
+import (
+	"sync"
+	"time"
+
+	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// FlowContext holds state that is relevant to more than one flow or one peer, and allows communication between
+// different flows that can be associated to different peers.
+type FlowContext struct {
+	cfg               *config.Config
+	netAdapter        *netadapter.NetAdapter
+	txPool            *mempool.TxPool
+	dag               *blockdag.BlockDAG
+	addressManager    *addressmanager.AddressManager
+	connectionManager *connmanager.ConnectionManager
+
+	transactionsToRebroadcastLock sync.Mutex
+	transactionsToRebroadcast     map[daghash.TxID]*util.Tx
+	lastRebroadcastTime           time.Time
+	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
+
+	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
+
+	isInIBD       uint32
+	startIBDMutex sync.Mutex
+	ibdPeer       *peerpkg.Peer
+
+	peers      map[id.ID]*peerpkg.Peer
+	peersMutex sync.RWMutex
+}
+
+// New returns a new instance of FlowContext.
+func New(cfg *config.Config, dag *blockdag.BlockDAG, addressManager *addressmanager.AddressManager,
+	txPool *mempool.TxPool, netAdapter *netadapter.NetAdapter,
+	connectionManager *connmanager.ConnectionManager) *FlowContext {
+
+	return &FlowContext{
+		cfg:                         cfg,
+		netAdapter:                  netAdapter,
+		dag:                         dag,
+		addressManager:              addressManager,
+		connectionManager:           connectionManager,
+		txPool:                      txPool,
+		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
+		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
+		peers:                       make(map[id.ID]*peerpkg.Peer),
+		transactionsToRebroadcast:   make(map[daghash.TxID]*util.Tx),
+	}
+}

app/protocol/flowcontext/ibd.go

@@ -0,0 +1,89 @@
+package flowcontext
+
+import (
+	"sync/atomic"
+	"time"
+
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+)
+
+// StartIBDIfRequired selects a peer and starts IBD against it
+// if required
+func (f *FlowContext) StartIBDIfRequired() {
+	f.startIBDMutex.Lock()
+	defer f.startIBDMutex.Unlock()
+
+	if f.IsInIBD() {
+		return
+	}
+
+	peer := f.selectPeerForIBD(f.dag)
+	if peer == nil {
+		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
+		return
+	}
+
+	atomic.StoreUint32(&f.isInIBD, 1)
+	f.ibdPeer = peer
+	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+}
+
+// IsInIBD is true if IBD is currently running
+func (f *FlowContext) IsInIBD() bool {
+	return atomic.LoadUint32(&f.isInIBD) != 0
+}
+
+// selectPeerForIBD returns the first peer whose selected tip
+// hash is not in our DAG
+func (f *FlowContext) selectPeerForIBD(dag *blockdag.BlockDAG) *peerpkg.Peer {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peerSelectedTipHash := peer.SelectedTipHash()
+		if !dag.IsInDAG(peerSelectedTipHash) {
+			return peer
+		}
+	}
+	return nil
+}
+
+func (f *FlowContext) requestSelectedTipsIfRequired() {
+	if f.isDAGTimeCurrent() {
+		return
+	}
+	f.requestSelectedTips()
+}
+
+func (f *FlowContext) isDAGTimeCurrent() bool {
+	const minDurationToRequestSelectedTips = time.Minute
+	return f.dag.Now().Sub(f.dag.SelectedTipHeader().Timestamp) > minDurationToRequestSelectedTips
+}
+
+func (f *FlowContext) requestSelectedTips() {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peer.RequestSelectedTipIfRequired()
+	}
+}
+
+// FinishIBD finishes the current IBD flow and starts a new one if required.
+func (f *FlowContext) FinishIBD() {
+	f.ibdPeer = nil
+
+	atomic.StoreUint32(&f.isInIBD, 0)
+
+	f.StartIBDIfRequired()
+}
+
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	if !f.IsInIBD() {
+		return nil
+	}
+	return f.ibdPeer
+}

app/protocol/flowcontext/log.go

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

app/protocol/flowcontext/network.go

@@ -0,0 +1,74 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/pkg/errors"
+)
+
+// NetAdapter returns the net adapter that is associated to the flow context.
+func (f *FlowContext) NetAdapter() *netadapter.NetAdapter {
+	return f.netAdapter
+}
+
+// ConnectionManager returns the connection manager that is associated to the flow context.
+func (f *FlowContext) ConnectionManager() *connmanager.ConnectionManager {
+	return f.connectionManager
+}
+
+// AddToPeers marks this peer as ready and adds it to the ready peers list.
+func (f *FlowContext) AddToPeers(peer *peerpkg.Peer) error {
+	f.peersMutex.Lock()
+	defer f.peersMutex.Unlock()
+
+	if _, ok := f.peers[*peer.ID()]; ok {
+		return errors.Wrapf(common.ErrPeerWithSameIDExists, "peer with ID %s already exists", peer.ID())
+	}
+
+	f.peers[*peer.ID()] = peer
+
+	return nil
+}
+
+// RemoveFromPeers remove this peer from the peers list.
+func (f *FlowContext) RemoveFromPeers(peer *peerpkg.Peer) {
+	f.peersMutex.Lock()
+	defer f.peersMutex.Unlock()
+
+	delete(f.peers, *peer.ID())
+}
+
+// readyPeerConnections returns the NetConnections of all the ready peers.
+func (f *FlowContext) readyPeerConnections() []*netadapter.NetConnection {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+	peerConnections := make([]*netadapter.NetConnection, len(f.peers))
+	i := 0
+	for _, peer := range f.peers {
+		peerConnections[i] = peer.Connection()
+		i++
+	}
+	return peerConnections
+}
+
+// Broadcast broadcast the given message to all the ready peers.
+func (f *FlowContext) Broadcast(message appmessage.Message) error {
+	return f.netAdapter.Broadcast(f.readyPeerConnections(), message)
+}
+
+// Peers returns the currently active peers
+func (f *FlowContext) Peers() []*peerpkg.Peer {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	peers := make([]*peerpkg.Peer, len(f.peers))
+	i := 0
+	for _, peer := range f.peers {
+		peers[i] = peer
+		i++
+	}
+	return peers
+}

app/protocol/flowcontext/transactions.go

@@ -0,0 +1,70 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+	"time"
+)
+
+// AddTransaction adds transaction to the mempool and propagates it.
+func (f *FlowContext) AddTransaction(tx *util.Tx) error {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	transactionsAcceptedToMempool, err := f.txPool.ProcessTransaction(tx, false)
+	if err != nil {
+		return err
+	}
+
+	if len(transactionsAcceptedToMempool) > 1 {
+		return errors.New("got more than one accepted transactions when no orphans were allowed")
+	}
+
+	f.transactionsToRebroadcast[*tx.ID()] = tx
+	inv := appmessage.NewMsgInvTransaction([]*daghash.TxID{tx.ID()})
+	return f.Broadcast(inv)
+}
+
+func (f *FlowContext) updateTransactionsToRebroadcast(block *util.Block) {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+	// Note: if the block is red, its transactions won't be rebroadcasted
+	// anymore, although they are not included in the UTXO set.
+	// This is probably ok, since red blocks are quite rare.
+	for _, tx := range block.Transactions() {
+		delete(f.transactionsToRebroadcast, *tx.ID())
+	}
+}
+
+func (f *FlowContext) shouldRebroadcastTransactions() bool {
+	const rebroadcastInterval = 30 * time.Second
+	return time.Since(f.lastRebroadcastTime) > rebroadcastInterval
+}
+
+func (f *FlowContext) txIDsToRebroadcast() []*daghash.TxID {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	txIDs := make([]*daghash.TxID, len(f.transactionsToRebroadcast))
+	i := 0
+	for _, tx := range f.transactionsToRebroadcast {
+		txIDs[i] = tx.ID()
+		i++
+	}
+	return txIDs
+}
+
+// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
+// data about requested transactions between different peers.
+func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
+	return f.sharedRequestedTransactions
+}
+
+// TxPool returns the transaction pool associated to the manager.
+func (f *FlowContext) TxPool() *mempool.TxPool {
+	return f.txPool
+}

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -0,0 +1,57 @@
+package addressexchange
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// ReceiveAddressesContext is the interface for the context needed for the ReceiveAddresses flow.
+type ReceiveAddressesContext interface {
+	Config() *config.Config
+	AddressManager() *addressmanager.AddressManager
+}
+
+// ReceiveAddresses asks a peer for more addresses if needed.
+func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	if !context.AddressManager().NeedMoreAddresses() {
+		return nil
+	}
+
+	subnetworkID := peer.SubnetworkID()
+	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
+	err := outgoingRoute.Enqueue(msgGetAddresses)
+	if err != nil {
+		return err
+	}
+
+	message, err := incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return err
+	}
+
+	msgAddresses := message.(*appmessage.MsgAddresses)
+	if len(msgAddresses.AddrList) > addressmanager.GetAddressesMax {
+		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
+	}
+
+	if msgAddresses.IncludeAllSubnetworks {
+		return protocolerrors.Errorf(true, "got unexpected "+
+			"IncludeAllSubnetworks=true in [%s] command", msgAddresses.Command())
+	}
+	if !msgAddresses.SubnetworkID.IsEqual(context.Config().SubnetworkID) && msgAddresses.SubnetworkID != nil {
+		return protocolerrors.Errorf(false, "only full nodes and %s subnetwork IDs "+
+			"are allowed in [%s] command, but got subnetwork ID %s",
+			context.Config().SubnetworkID, msgAddresses.Command(), msgAddresses.SubnetworkID)
+	}
+
+	sourceAddress := peer.Connection().NetAddress()
+	context.AddressManager().AddAddresses(msgAddresses.AddrList, sourceAddress, msgAddresses.SubnetworkID)
+	return nil
+}

app/protocol/flows/addressexchange/sendaddresses.go

@@ -0,0 +1,52 @@
+package addressexchange
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"math/rand"
+)
+
+// SendAddressesContext is the interface for the context needed for the SendAddresses flow.
+type SendAddressesContext interface {
+	AddressManager() *addressmanager.AddressManager
+}
+
+// SendAddresses sends addresses to a peer that requests it.
+func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return err
+	}
+
+	msgGetAddresses := message.(*appmessage.MsgRequestAddresses)
+	addresses := context.AddressManager().AddressCache(msgGetAddresses.IncludeAllSubnetworks,
+		msgGetAddresses.SubnetworkID)
+	msgAddresses := appmessage.NewMsgAddresses(msgGetAddresses.IncludeAllSubnetworks, msgGetAddresses.SubnetworkID)
+	err = msgAddresses.AddAddresses(shuffleAddresses(addresses)...)
+	if err != nil {
+		return err
+	}
+
+	return outgoingRoute.Enqueue(msgAddresses)
+}
+
+// shuffleAddresses randomizes the given addresses sent if there are more than the maximum allowed in one message.
+func shuffleAddresses(addresses []*appmessage.NetAddress) []*appmessage.NetAddress {
+	addressCount := len(addresses)
+
+	if addressCount < appmessage.MaxAddressesPerMsg {
+		return addresses
+	}
+
+	shuffleAddresses := make([]*appmessage.NetAddress, addressCount)
+	copy(shuffleAddresses, addresses)
+
+	rand.Shuffle(addressCount, func(i, j int) {
+		shuffleAddresses[i], shuffleAddresses[j] = shuffleAddresses[j], shuffleAddresses[i]
+	})
+
+	// Truncate it to the maximum size.
+	shuffleAddresses = shuffleAddresses[:appmessage.MaxAddressesPerMsg]
+	return shuffleAddresses
+}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -0,0 +1,55 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// RelayBlockRequestsContext is the interface for the context needed for the HandleRelayBlockRequests flow.
+type RelayBlockRequestsContext interface {
+	DAG() *blockdag.BlockDAG
+}
+
+// HandleRelayBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
+// their corresponding blocks to the requesting peer.
+func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	for {
+		message, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
+		for _, hash := range getRelayBlocksMessage.Hashes {
+			// Fetch the block from the database.
+			block, err := context.DAG().BlockByHash(hash)
+			if blockdag.IsNotInDAGErr(err) {
+				return protocolerrors.Errorf(true, "block %s not found", hash)
+			} else if err != nil {
+				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
+			}
+			msgBlock := block.MsgBlock()
+
+			// If we are a full node and the peer is a partial node, we must convert
+			// the block to a partial block.
+			nodeSubnetworkID := context.DAG().SubnetworkID()
+			peerSubnetworkID := peer.SubnetworkID()
+
+			isNodeFull := nodeSubnetworkID == nil
+			isPeerFull := peerSubnetworkID == nil
+			if isNodeFull && !isPeerFull {
+				msgBlock.ConvertToPartial(peerSubnetworkID)
+			}
+
+			err = outgoingRoute.Enqueue(msgBlock)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -0,0 +1,245 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	mathUtil "github.com/kaspanet/kaspad/util/math"
+	"github.com/pkg/errors"
+)
+
+// RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
+type RelayInvsContext interface {
+	NetAdapter() *netadapter.NetAdapter
+	DAG() *blockdag.BlockDAG
+	OnNewBlock(block *util.Block) error
+	SharedRequestedBlocks() *SharedRequestedBlocks
+	StartIBDIfRequired()
+	IsInIBD() bool
+	Broadcast(message appmessage.Message) error
+}
+
+type handleRelayInvsFlow struct {
+	RelayInvsContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+	invsQueue                    []*appmessage.MsgInvRelayBlock
+}
+
+// HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
+// are missing, adds them to the DAG and propagates them to the rest of the network.
+func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	flow := &handleRelayInvsFlow{
+		RelayInvsContext: context,
+		incomingRoute:    incomingRoute,
+		outgoingRoute:    outgoingRoute,
+		peer:             peer,
+		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
+	}
+	return flow.start()
+}
+
+func (flow *handleRelayInvsFlow) start() error {
+	for {
+		inv, err := flow.readInv()
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("Got relay inv for block %s", inv.Hash)
+
+		if flow.DAG().IsKnownBlock(inv.Hash) {
+			if flow.DAG().IsKnownInvalid(inv.Hash) {
+				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
+					inv.Hash)
+			}
+			continue
+		}
+
+		flow.StartIBDIfRequired()
+		if flow.IsInIBD() {
+			// Block relay is disabled during IBD
+			continue
+		}
+
+		requestQueue := newHashesQueueSet()
+		requestQueue.enqueueIfNotExists(inv.Hash)
+
+		for requestQueue.len() > 0 {
+			err := flow.requestBlocks(requestQueue)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
+
+	if len(flow.invsQueue) > 0 {
+		var inv *appmessage.MsgInvRelayBlock
+		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
+		return inv, nil
+	}
+
+	msg, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, err
+	}
+
+	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
+			"expecting an inv message", msg.Command())
+	}
+	return inv, nil
+}
+
+func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
+	numHashesToRequest := mathUtil.MinInt(appmessage.MsgRequestRelayBlocksHashes, requestQueue.len())
+	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
+
+	pendingBlocks := map[daghash.Hash]struct{}{}
+	var filteredHashesToRequest []*daghash.Hash
+	for _, hash := range hashesToRequest {
+		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
+		if exists {
+			continue
+		}
+
+		// The block can become known from another peer in the process of orphan resolution
+		if flow.DAG().IsKnownBlock(hash) {
+			continue
+		}
+
+		pendingBlocks[*hash] = struct{}{}
+		filteredHashesToRequest = append(filteredHashesToRequest, hash)
+	}
+
+	// Exit early if we've filtered out all the hashes
+	if len(filteredHashesToRequest) == 0 {
+		return nil
+	}
+
+	// In case the function returns earlier than expected, we want to make sure requestedBlocks is
+	// clean from any pending blocks.
+	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
+	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
+	if err != nil {
+		return err
+	}
+
+	for len(pendingBlocks) > 0 {
+		msgBlock, err := flow.readMsgBlock()
+		if err != nil {
+			return err
+		}
+
+		block := util.NewBlock(msgBlock)
+		blockHash := block.Hash()
+
+		if _, ok := pendingBlocks[*blockHash]; !ok {
+			return protocolerrors.Errorf(true, "got unrequested block %s", block.Hash())
+		}
+
+		err = flow.processAndRelayBlock(requestQueue, block)
+		if err != nil {
+			return err
+		}
+
+		delete(pendingBlocks, *blockHash)
+		flow.SharedRequestedBlocks().remove(blockHash)
+	}
+	return nil
+}
+
+// readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
+//
+// Note: this function assumes msgChan can contain only appmessage.MsgInvRelayBlock and appmessage.MsgBlock messages.
+func (flow *handleRelayInvsFlow) readMsgBlock() (
+	msgBlock *appmessage.MsgBlock, err error) {
+
+	for {
+		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+		if err != nil {
+			return nil, err
+		}
+
+		switch message := message.(type) {
+		case *appmessage.MsgInvRelayBlock:
+			flow.invsQueue = append(flow.invsQueue, message)
+		case *appmessage.MsgBlock:
+			return message, nil
+		default:
+			return nil, errors.Errorf("unexpected message %s", message.Command())
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *util.Block) error {
+	blockHash := block.Hash()
+	isOrphan, isDelayed, err := flow.DAG().ProcessBlock(block, blockdag.BFNone)
+	if err != nil {
+		if !errors.As(err, &blockdag.RuleError{}) {
+			return errors.Wrapf(err, "failed to process block %s", blockHash)
+		}
+		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+
+		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+	}
+
+	if isDelayed {
+		return nil
+	}
+
+	if isOrphan {
+		blueScore, err := block.BlueScore()
+		if err != nil {
+			return protocolerrors.Errorf(true, "received an orphan "+
+				"block %s with malformed blue score", blockHash)
+		}
+
+		const maxOrphanBlueScoreDiff = 10000
+		selectedTipBlueScore := flow.DAG().SelectedTipBlueScore()
+		if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
+			log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
+				"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
+				blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
+			return nil
+		}
+
+		// Request the parents for the orphan block from the peer that sent it.
+		missingAncestors := flow.DAG().GetOrphanMissingAncestorHashes(blockHash)
+		for _, missingAncestor := range missingAncestors {
+			requestQueue.enqueueIfNotExists(missingAncestor)
+		}
+		return nil
+	}
+	err = blocklogger.LogBlock(block)
+	if err != nil {
+		return err
+	}
+	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
+	if err != nil {
+		return err
+	}
+
+	flow.StartIBDIfRequired()
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

app/protocol/flows/blockrelay/hashes_queue_set.go

@@ -0,0 +1,35 @@
+package blockrelay
+
+import "github.com/kaspanet/kaspad/util/daghash"
+
+type hashesQueueSet struct {
+	queue []*daghash.Hash
+	set   map[daghash.Hash]struct{}
+}
+
+func (r *hashesQueueSet) enqueueIfNotExists(hash *daghash.Hash) {
+	if _, ok := r.set[*hash]; ok {
+		return
+	}
+	r.queue = append(r.queue, hash)
+	r.set[*hash] = struct{}{}
+}
+
+func (r *hashesQueueSet) dequeue(numItems int) []*daghash.Hash {
+	var hashes []*daghash.Hash
+	hashes, r.queue = r.queue[:numItems], r.queue[numItems:]
+	for _, hash := range hashes {
+		delete(r.set, *hash)
+	}
+	return hashes
+}
+
+func (r *hashesQueueSet) len() int {
+	return len(r.queue)
+}
+
+func newHashesQueueSet() *hashesQueueSet {
+	return &hashesQueueSet{
+		set: make(map[daghash.Hash]struct{}),
+	}
+}

app/protocol/flows/blockrelay/log.go

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

app/protocol/flows/blockrelay/shared_requested_blocks.go

@@ -0,0 +1,46 @@
+package blockrelay
+
+import (
+	"sync"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// SharedRequestedBlocks is a data structure that is shared between peers that
+// holds the hashes of all the requested blocks to prevent redundant requests.
+type SharedRequestedBlocks struct {
+	blocks map[daghash.Hash]struct{}
+	sync.Mutex
+}
+
+func (s *SharedRequestedBlocks) remove(hash *daghash.Hash) {
+	s.Lock()
+	defer s.Unlock()
+	delete(s.blocks, *hash)
+}
+
+func (s *SharedRequestedBlocks) removeSet(blockHashes map[daghash.Hash]struct{}) {
+	s.Lock()
+	defer s.Unlock()
+	for hash := range blockHashes {
+		delete(s.blocks, hash)
+	}
+}
+
+func (s *SharedRequestedBlocks) addIfNotExists(hash *daghash.Hash) (exists bool) {
+	s.Lock()
+	defer s.Unlock()
+	_, ok := s.blocks[*hash]
+	if ok {
+		return true
+	}
+	s.blocks[*hash] = struct{}{}
+	return false
+}
+
+// NewSharedRequestedBlocks returns a new instance of SharedRequestedBlocks.
+func NewSharedRequestedBlocks() *SharedRequestedBlocks {
+	return &SharedRequestedBlocks{
+		blocks: make(map[daghash.Hash]struct{}),
+	}
+}

app/protocol/flows/handshake/handshake.go

@@ -0,0 +1,116 @@
+package handshake
+
+import (
+	"sync"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/locks"
+	"github.com/pkg/errors"
+)
+
+// HandleHandshakeContext is the interface for the context needed for the HandleHandshake flow.
+type HandleHandshakeContext interface {
+	Config() *config.Config
+	NetAdapter() *netadapter.NetAdapter
+	DAG() *blockdag.BlockDAG
+	AddressManager() *addressmanager.AddressManager
+	StartIBDIfRequired()
+	AddToPeers(peer *peerpkg.Peer) error
+	HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error)
+}
+
+// HandleHandshake sets up the handshake protocol - It sends a version message and waits for an incoming
+// version message, as well as a verack for the sent version
+func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.NetConnection,
+	receiveVersionRoute *routerpkg.Route, sendVersionRoute *routerpkg.Route, outgoingRoute *routerpkg.Route,
+) (*peerpkg.Peer, error) {
+
+	// For HandleHandshake to finish, we need to get from the other node
+	// a version and verack messages, so we increase the wait group by 2
+	// and block HandleHandshake with wg.Wait().
+	wg := sync.WaitGroup{}
+	wg.Add(2)
+
+	isStopping := uint32(0)
+	errChan := make(chan error)
+
+	peer := peerpkg.New(netConnection)
+
+	var peerAddress *appmessage.NetAddress
+	spawn("HandleHandshake-ReceiveVersion", func() {
+		address, err := ReceiveVersion(context, receiveVersionRoute, outgoingRoute, peer)
+		if err != nil {
+			handleError(err, "ReceiveVersion", &isStopping, errChan)
+			return
+		}
+		peerAddress = address
+		wg.Done()
+	})
+
+	spawn("HandleHandshake-SendVersion", func() {
+		err := SendVersion(context, sendVersionRoute, outgoingRoute, peer)
+		if err != nil {
+			handleError(err, "SendVersion", &isStopping, errChan)
+			return
+		}
+		wg.Done()
+	})
+
+	select {
+	case err := <-errChan:
+		if err != nil {
+			return nil, err
+		}
+		return nil, nil
+	case <-locks.ReceiveFromChanWhenDone(func() { wg.Wait() }):
+	}
+
+	err := context.AddToPeers(peer)
+	if err != nil {
+		if errors.As(err, &common.ErrPeerWithSameIDExists) {
+			return nil, protocolerrors.Wrap(false, err, "peer already exists")
+		}
+		return nil, err
+	}
+
+	if peerAddress != nil {
+		subnetworkID := peer.SubnetworkID()
+		context.AddressManager().AddAddress(peerAddress, peerAddress, subnetworkID)
+		context.AddressManager().Good(peerAddress, subnetworkID)
+	}
+
+	context.StartIBDIfRequired()
+
+	return peer, nil
+}
+
+// Handshake is different from other flows, since in it should forward router.ErrRouteClosed to errChan
+// Therefore we implement a separate handleError for handshake
+func handleError(err error, flowName string, isStopping *uint32, errChan chan error) {
+	if errors.Is(err, routerpkg.ErrRouteClosed) {
+		if atomic.AddUint32(isStopping, 1) == 1 {
+			errChan <- err
+		}
+		return
+	}
+
+	if protocolErr := &(protocolerrors.ProtocolError{}); errors.As(err, &protocolErr) {
+		log.Errorf("Handshake protocol error from %s: %s", flowName, err)
+		if atomic.AddUint32(isStopping, 1) == 1 {
+			errChan <- err
+		}
+		return
+	}
+	panic(err)
+}

app/protocol/flows/handshake/log.go

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

app/protocol/flows/handshake/receiveversion.go

@@ -0,0 +1,101 @@
+package handshake
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+var (
+	// allowSelfConnections is only used to allow the tests to bypass the self
+	// connection detecting and disconnect logic since they intentionally
+	// do so for testing purposes.
+	allowSelfConnections bool
+
+	// minAcceptableProtocolVersion is the lowest protocol version that a
+	// connected peer may support.
+	minAcceptableProtocolVersion = appmessage.ProtocolVersion
+)
+
+type receiveVersionFlow struct {
+	HandleHandshakeContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// ReceiveVersion waits for the peer to send a version message, sends a
+// verack in response, and updates its info accordingly.
+func ReceiveVersion(context HandleHandshakeContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) (*appmessage.NetAddress, error) {
+
+	flow := &receiveVersionFlow{
+		HandleHandshakeContext: context,
+		incomingRoute:          incomingRoute,
+		outgoingRoute:          outgoingRoute,
+		peer:                   peer,
+	}
+
+	return flow.start()
+}
+
+func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	msgVersion, ok := message.(*appmessage.MsgVersion)
+	if !ok {
+		return nil, protocolerrors.New(true, "a version message must precede all others")
+	}
+
+	if !allowSelfConnections && flow.NetAdapter().ID().IsEqual(msgVersion.ID) {
+		return nil, protocolerrors.New(true, "connected to self")
+	}
+
+	// Disconnect and ban peers from a different network
+	if msgVersion.Network != flow.Config().ActiveNetParams.Name {
+		return nil, protocolerrors.Errorf(true, "wrong network")
+	}
+
+	// Notify and disconnect clients that have a protocol version that is
+	// too old.
+	//
+	// NOTE: If minAcceptableProtocolVersion is raised to be higher than
+	// appmessage.RejectVersion, this should send a reject packet before
+	// disconnecting.
+	if msgVersion.ProtocolVersion < minAcceptableProtocolVersion {
+		return nil, protocolerrors.Errorf(false, "protocol version must be %d or greater",
+			minAcceptableProtocolVersion)
+	}
+
+	// Disconnect from partial nodes in networks that don't allow them
+	if !flow.DAG().Params.EnableNonNativeSubnetworks && msgVersion.SubnetworkID != nil {
+		return nil, protocolerrors.New(true, "partial nodes are not allowed")
+	}
+
+	// Disconnect if:
+	// - we are a full node and the outbound connection we've initiated is a partial node
+	// - the remote node is partial and our subnetwork doesn't match their subnetwork
+	localSubnetworkID := flow.Config().SubnetworkID
+	isLocalNodeFull := localSubnetworkID == nil
+	isRemoteNodeFull := msgVersion.SubnetworkID == nil
+	isOutbound := flow.peer.Connection().IsOutbound()
+	if (isLocalNodeFull && !isRemoteNodeFull && isOutbound) ||
+		(!isLocalNodeFull && !isRemoteNodeFull && !msgVersion.SubnetworkID.IsEqual(localSubnetworkID)) {
+
+		return nil, protocolerrors.New(false, "incompatible subnetworks")
+	}
+
+	flow.peer.UpdateFieldsFromMsgVersion(msgVersion)
+	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgVerAck())
+	if err != nil {
+		return nil, err
+	}
+
+	flow.peer.Connection().SetID(msgVersion.ID)
+
+	return msgVersion.Address, nil
+}

app/protocol/flows/handshake/sendversion.go

@@ -0,0 +1,78 @@
+package handshake
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/version"
+)
+
+var (
+	// userAgentName is the user agent name and is used to help identify
+	// ourselves to other kaspa peers.
+	userAgentName = "kaspad"
+
+	// userAgentVersion is the user agent version and is used to help
+	// identify ourselves to other kaspa peers.
+	userAgentVersion = version.Version()
+
+	// defaultServices describes the default services that are supported by
+	// the server.
+	defaultServices = appmessage.DefaultServices
+
+	// defaultRequiredServices describes the default services that are
+	// required to be supported by outbound peers.
+	defaultRequiredServices = appmessage.SFNodeNetwork
+)
+
+type sendVersionFlow struct {
+	HandleHandshakeContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// SendVersion sends a version to a peer and waits for verack.
+func SendVersion(context HandleHandshakeContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	flow := &sendVersionFlow{
+		HandleHandshakeContext: context,
+		incomingRoute:          incomingRoute,
+		outgoingRoute:          outgoingRoute,
+		peer:                   peer,
+	}
+	return flow.start()
+}
+
+func (flow *sendVersionFlow) start() error {
+	selectedTipHash := flow.DAG().SelectedTipHash()
+	subnetworkID := flow.Config().SubnetworkID
+
+	// Version message.
+	localAddress := flow.AddressManager().GetBestLocalAddress(flow.peer.Connection().NetAddress())
+	msg := appmessage.NewMsgVersion(localAddress, flow.NetAdapter().ID(),
+		flow.Config().ActiveNetParams.Name, selectedTipHash, subnetworkID)
+	msg.AddUserAgent(userAgentName, userAgentVersion, flow.Config().UserAgentComments...)
+
+	// Advertise the services flag
+	msg.Services = defaultServices
+
+	// Advertise our max supported protocol version.
+	msg.ProtocolVersion = appmessage.ProtocolVersion
+
+	// Advertise if inv messages for transactions are desired.
+	msg.DisableRelayTx = flow.Config().BlocksOnly
+
+	err := flow.outgoingRoute.Enqueue(msg)
+	if err != nil {
+		return err
+	}
+
+	// Wait for verack
+	_, err = flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/protocol/flows/ibd/handle_request_block_locator.go

@@ -0,0 +1,72 @@
+package ibd
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// RequestBlockLocatorContext is the interface for the context needed for the HandleRequestBlockLocator flow.
+type RequestBlockLocatorContext interface {
+	DAG() *blockdag.BlockDAG
+}
+
+type handleRequestBlockLocatorFlow struct {
+	RequestBlockLocatorContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestBlockLocator handles getBlockLocator messages
+func HandleRequestBlockLocator(context RequestBlockLocatorContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route) error {
+
+	flow := &handleRequestBlockLocatorFlow{
+		RequestBlockLocatorContext: context,
+		incomingRoute:              incomingRoute,
+		outgoingRoute:              outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestBlockLocatorFlow) start() error {
+	for {
+		lowHash, highHash, err := flow.receiveGetBlockLocator()
+		if err != nil {
+			return err
+		}
+
+		locator, err := flow.DAG().BlockLocatorFromHashes(highHash, lowHash)
+		if err != nil || len(locator) == 0 {
+			return protocolerrors.Errorf(true, "couldn't build a block "+
+				"locator between blocks %s and %s", lowHash, highHash)
+		}
+
+		err = flow.sendBlockLocator(locator)
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *daghash.Hash,
+	highHash *daghash.Hash, err error) {
+
+	message, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, nil, err
+	}
+	msgGetBlockLocator := message.(*appmessage.MsgRequestBlockLocator)
+
+	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, nil
+}
+
+func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator blockdag.BlockLocator) error {
+	msgBlockLocator := appmessage.NewMsgBlockLocator(locator)
+	err := flow.outgoingRoute.Enqueue(msgBlockLocator)
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/protocol/flows/ibd/handle_request_ibd_blocks.go

@@ -0,0 +1,126 @@
+package ibd
+
+import (
+	"errors"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+const ibdBatchSize = router.DefaultMaxMessages
+
+// RequestIBDBlocksContext is the interface for the context needed for the HandleRequestIBDBlocks flow.
+type RequestIBDBlocksContext interface {
+	DAG() *blockdag.BlockDAG
+}
+
+type handleRequestBlocksFlow struct {
+	RequestIBDBlocksContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestIBDBlocks handles getBlocks messages
+func HandleRequestIBDBlocks(context RequestIBDBlocksContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &handleRequestBlocksFlow{
+		RequestIBDBlocksContext: context,
+		incomingRoute:           incomingRoute,
+		outgoingRoute:           outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestBlocksFlow) start() error {
+	for {
+		lowHash, highHash, err := receiveRequestIBDBlocks(flow.incomingRoute)
+		if err != nil {
+			return err
+		}
+
+		msgIBDBlocks, err := flow.buildMsgIBDBlocks(lowHash, highHash)
+		if err != nil {
+			return err
+		}
+
+		for offset := 0; offset < len(msgIBDBlocks); offset += ibdBatchSize {
+			end := offset + ibdBatchSize
+			if end > len(msgIBDBlocks) {
+				end = len(msgIBDBlocks)
+			}
+
+			blocksToSend := msgIBDBlocks[offset:end]
+			err = flow.sendMsgIBDBlocks(blocksToSend)
+			if err != nil {
+				return nil
+			}
+
+			// Exit the loop and don't wait for the GetNextIBDBlocks message if the last batch was
+			// less than ibdBatchSize.
+			if len(blocksToSend) < ibdBatchSize {
+				break
+			}
+
+			message, err := flow.incomingRoute.Dequeue()
+			if err != nil {
+				return err
+			}
+
+			if _, ok := message.(*appmessage.MsgRequestNextIBDBlocks); !ok {
+				return protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s, got: %s", appmessage.CmdRequestNextIBDBlocks, message.Command())
+			}
+		}
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneIBDBlocks())
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func receiveRequestIBDBlocks(incomingRoute *router.Route) (lowHash *daghash.Hash,
+	highHash *daghash.Hash, err error) {
+
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return nil, nil, err
+	}
+	msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
+
+	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
+}
+
+func (flow *handleRequestBlocksFlow) buildMsgIBDBlocks(lowHash *daghash.Hash,
+	highHash *daghash.Hash) ([]*appmessage.MsgIBDBlock, error) {
+
+	const maxHashesInMsgIBDBlocks = appmessage.MaxInvPerMsg
+	blockHashes, err := flow.DAG().AntiPastHashesBetween(lowHash, highHash, maxHashesInMsgIBDBlocks)
+	if err != nil {
+		if errors.Is(err, blockdag.ErrInvalidParameter) {
+			return nil, protocolerrors.Wrapf(true, err, "could not get antiPast between "+
+				"%s and %s", lowHash, highHash)
+		}
+		return nil, err
+	}
+
+	msgIBDBlocks := make([]*appmessage.MsgIBDBlock, len(blockHashes))
+	for i, blockHash := range blockHashes {
+		block, err := flow.DAG().BlockByHash(blockHash)
+		if err != nil {
+			return nil, err
+		}
+		msgIBDBlocks[i] = appmessage.NewMsgIBDBlock(block.MsgBlock())
+	}
+
+	return msgIBDBlocks, nil
+}
+
+func (flow *handleRequestBlocksFlow) sendMsgIBDBlocks(msgIBDBlocks []*appmessage.MsgIBDBlock) error {
+	for _, msgIBDBlock := range msgIBDBlocks {
+		err := flow.outgoingRoute.Enqueue(msgIBDBlock)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

app/protocol/flows/ibd/ibd.go

@@ -0,0 +1,212 @@
+package ibd
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+)
+
+// HandleIBDContext is the interface for the context needed for the HandleIBD flow.
+type HandleIBDContext interface {
+	DAG() *blockdag.BlockDAG
+	OnNewBlock(block *util.Block) error
+	StartIBDIfRequired()
+	FinishIBD()
+}
+
+type handleIBDFlow struct {
+	HandleIBDContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// HandleIBD waits for IBD start and handles it when IBD is triggered for this peer
+func HandleIBD(context HandleIBDContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	flow := &handleIBDFlow{
+		HandleIBDContext: context,
+		incomingRoute:    incomingRoute,
+		outgoingRoute:    outgoingRoute,
+		peer:             peer,
+	}
+	return flow.start()
+}
+
+func (flow *handleIBDFlow) start() error {
+	for {
+		err := flow.runIBD()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleIBDFlow) runIBD() error {
+	flow.peer.WaitForIBDStart()
+	defer flow.FinishIBD()
+
+	peerSelectedTipHash := flow.peer.SelectedTipHash()
+	log.Debugf("Trying to find highest shared chain block with peer %s with selected tip %s", flow.peer, peerSelectedTipHash)
+	highestSharedBlockHash, err := flow.findHighestSharedBlockHash(peerSelectedTipHash)
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+	if flow.DAG().IsKnownFinalizedBlock(highestSharedBlockHash) {
+		return protocolerrors.Errorf(false, "cannot initiate "+
+			"IBD with peer %s because the highest shared chain block (%s) is "+
+			"below the finality point", flow.peer, highestSharedBlockHash)
+	}
+
+	return flow.downloadBlocks(highestSharedBlockHash, peerSelectedTipHash)
+}
+
+func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *daghash.Hash) (lowHash *daghash.Hash,
+	err error) {
+
+	lowHash = flow.DAG().Params.GenesisHash
+	highHash := peerSelectedTipHash
+
+	for {
+		err := flow.sendGetBlockLocator(lowHash, highHash)
+		if err != nil {
+			return nil, err
+		}
+
+		blockLocatorHashes, err := flow.receiveBlockLocator()
+		if err != nil {
+			return nil, err
+		}
+
+		// We check whether the locator's highest hash is in the local DAG.
+		// If it is, return it. If it isn't, we need to narrow our
+		// getBlockLocator request and try again.
+		locatorHighHash := blockLocatorHashes[0]
+		if flow.DAG().IsInDAG(locatorHighHash) {
+			return locatorHighHash, nil
+		}
+
+		highHash, lowHash = flow.DAG().FindNextLocatorBoundaries(blockLocatorHashes)
+	}
+}
+
+func (flow *handleIBDFlow) sendGetBlockLocator(lowHash *daghash.Hash, highHash *daghash.Hash) error {
+
+	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, lowHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
+}
+
+func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*daghash.Hash, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
+	if !ok {
+		return nil,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
+	}
+	return msgBlockLocator.BlockLocatorHashes, nil
+}
+
+func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *daghash.Hash,
+	peerSelectedTipHash *daghash.Hash) error {
+
+	err := flow.sendGetBlocks(highestSharedBlockHash, peerSelectedTipHash)
+	if err != nil {
+		return err
+	}
+
+	blocksReceived := 0
+	for {
+		msgIBDBlock, doneIBD, err := flow.receiveIBDBlock()
+		if err != nil {
+			return err
+		}
+
+		if doneIBD {
+			return nil
+		}
+
+		err = flow.processIBDBlock(msgIBDBlock)
+		if err != nil {
+			return err
+		}
+
+		blocksReceived++
+		if blocksReceived%ibdBatchSize == 0 {
+			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextIBDBlocks())
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (flow *handleIBDFlow) sendGetBlocks(highestSharedBlockHash *daghash.Hash,
+	peerSelectedTipHash *daghash.Hash) error {
+
+	msgGetBlockInvs := appmessage.NewMsgRequstIBDBlocks(highestSharedBlockHash, peerSelectedTipHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
+}
+
+func (flow *handleIBDFlow) receiveIBDBlock() (msgIBDBlock *appmessage.MsgIBDBlock, doneIBD bool, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, false, err
+	}
+	switch message := message.(type) {
+	case *appmessage.MsgIBDBlock:
+		return message, false, nil
+	case *appmessage.MsgDoneIBDBlocks:
+		return nil, true, nil
+	default:
+		return nil, false,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
+	}
+}
+
+func (flow *handleIBDFlow) processIBDBlock(msgIBDBlock *appmessage.MsgIBDBlock) error {
+	block := util.NewBlock(msgIBDBlock.MsgBlock)
+	if flow.DAG().IsInDAG(block.Hash()) {
+		log.Debugf("IBD block %s is already in the DAG. Skipping...", block.Hash())
+		return nil
+	}
+	isOrphan, isDelayed, err := flow.DAG().ProcessBlock(block, blockdag.BFNone)
+	if err != nil {
+		if !errors.As(err, &blockdag.RuleError{}) {
+			return errors.Wrapf(err, "failed to process block %s during IBD", block.Hash())
+		}
+		log.Infof("Rejected block %s from %s during IBD: %s", block.Hash(), flow.peer, err)
+
+		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", block.Hash())
+	}
+	if isOrphan {
+		return protocolerrors.Errorf(true, "received orphan block %s "+
+			"during IBD", block.Hash())
+	}
+	if isDelayed {
+		return protocolerrors.Errorf(false, "received delayed block %s "+
+			"during IBD", block.Hash())
+	}
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+	err = blocklogger.LogBlock(block)
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/protocol/flows/ibd/log.go

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

app/protocol/flows/ibd/selectedtip/handle_request_selected_tip.go

@@ -0,0 +1,61 @@
+package selectedtip
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// HandleRequestSelectedTipContext is the interface for the context needed for the HandleRequestSelectedTip flow.
+type HandleRequestSelectedTipContext interface {
+	DAG() *blockdag.BlockDAG
+}
+
+type handleRequestSelectedTipFlow struct {
+	HandleRequestSelectedTipContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestSelectedTip handles getSelectedTip messages
+func HandleRequestSelectedTip(context HandleRequestSelectedTipContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &handleRequestSelectedTipFlow{
+		HandleRequestSelectedTipContext: context,
+		incomingRoute:                   incomingRoute,
+		outgoingRoute:                   outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestSelectedTipFlow) start() error {
+	for {
+		err := flow.receiveGetSelectedTip()
+		if err != nil {
+			return err
+		}
+
+		err = flow.sendSelectedTipHash()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRequestSelectedTipFlow) receiveGetSelectedTip() error {
+	message, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return err
+	}
+	_, ok := message.(*appmessage.MsgRequestSelectedTip)
+	if !ok {
+		return errors.Errorf("received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdRequestSelectedTip, message.Command())
+	}
+
+	return nil
+}
+
+func (flow *handleRequestSelectedTipFlow) sendSelectedTipHash() error {
+	msgSelectedTip := appmessage.NewMsgSelectedTip(flow.DAG().SelectedTipHash())
+	return flow.outgoingRoute.Enqueue(msgSelectedTip)
+}

app/protocol/flows/ibd/selectedtip/request_selected_tip.go

@@ -0,0 +1,79 @@
+package selectedtip
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// RequestSelectedTipContext is the interface for the context needed for the RequestSelectedTip flow.
+type RequestSelectedTipContext interface {
+	DAG() *blockdag.BlockDAG
+	StartIBDIfRequired()
+}
+
+type requestSelectedTipFlow struct {
+	RequestSelectedTipContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// RequestSelectedTip waits for selected tip requests and handles them
+func RequestSelectedTip(context RequestSelectedTipContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	flow := &requestSelectedTipFlow{
+		RequestSelectedTipContext: context,
+		incomingRoute:             incomingRoute,
+		outgoingRoute:             outgoingRoute,
+		peer:                      peer,
+	}
+	return flow.start()
+}
+
+func (flow *requestSelectedTipFlow) start() error {
+	for {
+		err := flow.runSelectedTipRequest()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *requestSelectedTipFlow) runSelectedTipRequest() error {
+
+	flow.peer.WaitForSelectedTipRequests()
+	defer flow.peer.FinishRequestingSelectedTip()
+
+	err := flow.requestSelectedTip()
+	if err != nil {
+		return err
+	}
+
+	peerSelectedTipHash, err := flow.receiveSelectedTip()
+	if err != nil {
+		return err
+	}
+
+	flow.peer.SetSelectedTipHash(peerSelectedTipHash)
+	flow.StartIBDIfRequired()
+	return nil
+}
+
+func (flow *requestSelectedTipFlow) requestSelectedTip() error {
+	msgGetSelectedTip := appmessage.NewMsgRequestSelectedTip()
+	return flow.outgoingRoute.Enqueue(msgGetSelectedTip)
+}
+
+func (flow *requestSelectedTipFlow) receiveSelectedTip() (selectedTipHash *daghash.Hash, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	msgSelectedTip := message.(*appmessage.MsgSelectedTip)
+
+	return msgSelectedTip.SelectedTipHash, nil
+}

app/protocol/flows/ping/receive.go

@@ -0,0 +1,42 @@
+package ping
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// ReceivePingsContext is the interface for the context needed for the ReceivePings flow.
+type ReceivePingsContext interface {
+}
+
+type receivePingsFlow struct {
+	ReceivePingsContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// ReceivePings handles all ping messages coming through incomingRoute.
+// This function assumes that incomingRoute will only return MsgPing.
+func ReceivePings(context ReceivePingsContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &receivePingsFlow{
+		ReceivePingsContext: context,
+		incomingRoute:       incomingRoute,
+		outgoingRoute:       outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *receivePingsFlow) start() error {
+	for {
+		message, err := flow.incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		pingMessage := message.(*appmessage.MsgPing)
+
+		pongMessage := appmessage.NewMsgPong(pingMessage.Nonce)
+		err = flow.outgoingRoute.Enqueue(pongMessage)
+		if err != nil {
+			return err
+		}
+	}
+}

app/protocol/flows/ping/send.go

@@ -0,0 +1,66 @@
+package ping
+
+import (
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"time"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/random"
+)
+
+// SendPingsContext is the interface for the context needed for the SendPings flow.
+type SendPingsContext interface {
+}
+
+type sendPingsFlow struct {
+	SendPingsContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// SendPings starts sending MsgPings every pingInterval seconds to the
+// given peer.
+// This function assumes that incomingRoute will only return MsgPong.
+func SendPings(context SendPingsContext, incomingRoute *router.Route, outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+	flow := &sendPingsFlow{
+		SendPingsContext: context,
+		incomingRoute:    incomingRoute,
+		outgoingRoute:    outgoingRoute,
+		peer:             peer,
+	}
+	return flow.start()
+}
+
+func (flow *sendPingsFlow) start() error {
+	const pingInterval = 2 * time.Minute
+	ticker := time.NewTicker(pingInterval)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		nonce, err := random.Uint64()
+		if err != nil {
+			return err
+		}
+		flow.peer.SetPingPending(nonce)
+
+		pingMessage := appmessage.NewMsgPing(nonce)
+		err = flow.outgoingRoute.Enqueue(pingMessage)
+		if err != nil {
+			return err
+		}
+
+		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+		if err != nil {
+			return err
+		}
+		pongMessage := message.(*appmessage.MsgPong)
+		if pongMessage.Nonce != pingMessage.Nonce {
+			return protocolerrors.New(true, "nonce mismatch between ping and pong")
+		}
+		flow.peer.SetPingIdle()
+	}
+	return nil
+}

app/protocol/flows/rejects/handle_rejects.go

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

app/protocol/flows/relaytransactions/handle_relayed_transactions.go

@@ -0,0 +1,223 @@
+package relaytransactions
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+)
+
+// TransactionsRelayContext is the interface for the context needed for the
+// HandleRelayedTransactions and HandleRequestedTransactions flows.
+type TransactionsRelayContext interface {
+	NetAdapter() *netadapter.NetAdapter
+	DAG() *blockdag.BlockDAG
+	SharedRequestedTransactions() *SharedRequestedTransactions
+	TxPool() *mempool.TxPool
+	Broadcast(message appmessage.Message) error
+}
+
+type handleRelayedTransactionsFlow struct {
+	TransactionsRelayContext
+	incomingRoute, outgoingRoute *router.Route
+	invsQueue                    []*appmessage.MsgInvTransaction
+}
+
+// HandleRelayedTransactions listens to appmessage.MsgInvTransaction messages, requests their corresponding transactions if they
+// are missing, adds them to the mempool and propagates them to the rest of the network.
+func HandleRelayedTransactions(context TransactionsRelayContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &handleRelayedTransactionsFlow{
+		TransactionsRelayContext: context,
+		incomingRoute:            incomingRoute,
+		outgoingRoute:            outgoingRoute,
+		invsQueue:                make([]*appmessage.MsgInvTransaction, 0),
+	}
+	return flow.start()
+}
+
+func (flow *handleRelayedTransactionsFlow) start() error {
+	for {
+		inv, err := flow.readInv()
+		if err != nil {
+			return err
+		}
+
+		requestedIDs, err := flow.requestInvTransactions(inv)
+		if err != nil {
+			return err
+		}
+
+		err = flow.receiveTransactions(requestedIDs)
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRelayedTransactionsFlow) requestInvTransactions(
+	inv *appmessage.MsgInvTransaction) (requestedIDs []*daghash.TxID, err error) {
+
+	idsToRequest := make([]*daghash.TxID, 0, len(inv.TxIDs))
+	for _, txID := range inv.TxIDs {
+		if flow.isKnownTransaction(txID) {
+			continue
+		}
+		exists := flow.SharedRequestedTransactions().addIfNotExists(txID)
+		if exists {
+			continue
+		}
+		idsToRequest = append(idsToRequest, txID)
+	}
+
+	if len(idsToRequest) == 0 {
+		return idsToRequest, nil
+	}
+
+	msgGetTransactions := appmessage.NewMsgRequestTransactions(idsToRequest)
+	err = flow.outgoingRoute.Enqueue(msgGetTransactions)
+	if err != nil {
+		flow.SharedRequestedTransactions().removeMany(idsToRequest)
+		return nil, err
+	}
+	return idsToRequest, nil
+}
+
+func (flow *handleRelayedTransactionsFlow) isKnownTransaction(txID *daghash.TxID) bool {
+	// Ask the transaction memory pool if the transaction is known
+	// to it in any form (main pool or orphan).
+	if flow.TxPool().HaveTransaction(txID) {
+		return true
+	}
+
+	// Check if the transaction exists from the point of view of the
+	// DAG's virtual block. Note that this is only a best effort
+	// since it is expensive to check existence of every output and
+	// the only purpose of this check is to avoid downloading
+	// already known transactions. Only the first two outputs are
+	// checked because the vast majority of transactions consist of
+	// two outputs where one is some form of "pay-to-somebody-else"
+	// and the other is a change output.
+	prevOut := appmessage.Outpoint{TxID: *txID}
+	for i := uint32(0); i < 2; i++ {
+		prevOut.Index = i
+		_, ok := flow.DAG().GetUTXOEntry(prevOut)
+		if ok {
+			return true
+		}
+	}
+	return false
+}
+
+func (flow *handleRelayedTransactionsFlow) readInv() (*appmessage.MsgInvTransaction, error) {
+	if len(flow.invsQueue) > 0 {
+		var inv *appmessage.MsgInvTransaction
+		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
+		return inv, nil
+	}
+
+	msg, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, err
+	}
+
+	inv, ok := msg.(*appmessage.MsgInvTransaction)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay flow while "+
+			"expecting an inv message", msg.Command())
+	}
+	return inv, nil
+}
+
+func (flow *handleRelayedTransactionsFlow) broadcastAcceptedTransactions(acceptedTxs []*mempool.TxDesc) error {
+	idsToBroadcast := make([]*daghash.TxID, len(acceptedTxs))
+	for i, tx := range acceptedTxs {
+		idsToBroadcast[i] = tx.Tx.ID()
+	}
+	inv := appmessage.NewMsgInvTransaction(idsToBroadcast)
+	return flow.Broadcast(inv)
+}
+
+// readMsgTxOrNotFound returns the next msgTx or msgTransactionNotFound in incomingRoute,
+// returning only one of the message types at a time.
+//
+// and populates invsQueue with any inv messages that meanwhile arrive.
+func (flow *handleRelayedTransactionsFlow) readMsgTxOrNotFound() (
+	msgTx *appmessage.MsgTx, msgNotFound *appmessage.MsgTransactionNotFound, err error) {
+
+	for {
+		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		switch message := message.(type) {
+		case *appmessage.MsgInvTransaction:
+			flow.invsQueue = append(flow.invsQueue, message)
+		case *appmessage.MsgTx:
+			return message, nil, nil
+		case *appmessage.MsgTransactionNotFound:
+			return nil, message, nil
+		default:
+			return nil, nil, errors.Errorf("unexpected message %s", message.Command())
+		}
+	}
+}
+
+func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransactions []*daghash.TxID) error {
+	// In case the function returns earlier than expected, we want to make sure sharedRequestedTransactions is
+	// clean from any pending transactions.
+	defer flow.SharedRequestedTransactions().removeMany(requestedTransactions)
+	for _, expectedID := range requestedTransactions {
+		msgTx, msgTxNotFound, err := flow.readMsgTxOrNotFound()
+		if err != nil {
+			return err
+		}
+		if msgTxNotFound != nil {
+			if !msgTxNotFound.ID.IsEqual(expectedID) {
+				return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
+					expectedID, msgTxNotFound.ID)
+			}
+
+			continue
+		}
+		tx := util.NewTx(msgTx)
+		if !tx.ID().IsEqual(expectedID) {
+			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
+				expectedID, tx.ID())
+		}
+
+		acceptedTxs, err := flow.TxPool().ProcessTransaction(tx, true)
+		if err != nil {
+			ruleErr := &mempool.RuleError{}
+			if !errors.As(err, ruleErr) {
+				return errors.Wrapf(err, "failed to process transaction %s", tx.ID())
+			}
+
+			shouldBan := false
+			if txRuleErr := (&mempool.TxRuleError{}); errors.As(ruleErr.Err, txRuleErr) {
+				if txRuleErr.RejectCode == mempool.RejectInvalid {
+					shouldBan = true
+				}
+			} else if dagRuleErr := (&blockdag.RuleError{}); errors.As(ruleErr.Err, dagRuleErr) {
+				shouldBan = true
+			}
+
+			if !shouldBan {
+				continue
+			}
+
+			return protocolerrors.Errorf(true, "rejected transaction %s", tx.ID())
+		}
+		err = flow.broadcastAcceptedTransactions(acceptedTxs)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

app/protocol/flows/relaytransactions/handle_requested_transactions.go

@@ -0,0 +1,59 @@
+package relaytransactions
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+type handleRequestedTransactionsFlow struct {
+	TransactionsRelayContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestedTransactions listens to appmessage.MsgRequestTransactions messages, responding with the requested
+// transactions if those are in the mempool.
+// Missing transactions would be ignored
+func HandleRequestedTransactions(context TransactionsRelayContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &handleRequestedTransactionsFlow{
+		TransactionsRelayContext: context,
+		incomingRoute:            incomingRoute,
+		outgoingRoute:            outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestedTransactionsFlow) start() error {
+	for {
+		msgRequestTransactions, err := flow.readRequestTransactions()
+		if err != nil {
+			return err
+		}
+
+		for _, transactionID := range msgRequestTransactions.IDs {
+			tx, ok := flow.TxPool().FetchTransaction(transactionID)
+
+			if !ok {
+				msgTransactionNotFound := appmessage.NewMsgTransactionNotFound(transactionID)
+				err := flow.outgoingRoute.Enqueue(msgTransactionNotFound)
+				if err != nil {
+					return err
+				}
+				continue
+			}
+
+			err := flow.outgoingRoute.Enqueue(tx.MsgTx())
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (flow *handleRequestedTransactionsFlow) readRequestTransactions() (*appmessage.MsgRequestTransactions, error) {
+	msg, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, err
+	}
+
+	return msg.(*appmessage.MsgRequestTransactions), nil
+}

app/protocol/flows/relaytransactions/shared_requested_transactions.go

@@ -0,0 +1,45 @@
+package relaytransactions
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+	"sync"
+)
+
+// SharedRequestedTransactions is a data structure that is shared between peers that
+// holds the IDs of all the requested transactions to prevent redundant requests.
+type SharedRequestedTransactions struct {
+	transactions map[daghash.TxID]struct{}
+	sync.Mutex
+}
+
+func (s *SharedRequestedTransactions) remove(txID *daghash.TxID) {
+	s.Lock()
+	defer s.Unlock()
+	delete(s.transactions, *txID)
+}
+
+func (s *SharedRequestedTransactions) removeMany(txIDs []*daghash.TxID) {
+	s.Lock()
+	defer s.Unlock()
+	for _, txID := range txIDs {
+		delete(s.transactions, *txID)
+	}
+}
+
+func (s *SharedRequestedTransactions) addIfNotExists(txID *daghash.TxID) (exists bool) {
+	s.Lock()
+	defer s.Unlock()
+	_, ok := s.transactions[*txID]
+	if ok {
+		return true
+	}
+	s.transactions[*txID] = struct{}{}
+	return false
+}
+
+// NewSharedRequestedTransactions returns a new instance of SharedRequestedTransactions.
+func NewSharedRequestedTransactions() *SharedRequestedTransactions {
+	return &SharedRequestedTransactions{
+		transactions: make(map[daghash.TxID]struct{}),
+	}
+}

app/protocol/log.go

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

app/protocol/manager.go

@@ -0,0 +1,74 @@
+package protocol
+
+import (
+	"fmt"
+
+	"github.com/kaspanet/kaspad/app/protocol/flowcontext"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/util"
+)
+
+// Manager manages the p2p protocol
+type Manager struct {
+	context *flowcontext.FlowContext
+}
+
+// NewManager creates a new instance of the p2p protocol manager
+func NewManager(cfg *config.Config, dag *blockdag.BlockDAG, netAdapter *netadapter.NetAdapter,
+	addressManager *addressmanager.AddressManager, txPool *mempool.TxPool,
+	connectionManager *connmanager.ConnectionManager) (*Manager, error) {
+
+	manager := Manager{
+		context: flowcontext.New(cfg, dag, addressManager, txPool, netAdapter, connectionManager),
+	}
+	netAdapter.SetRouterInitializer(manager.routerInitializer)
+	return &manager, nil
+}
+
+// Start starts the p2p protocol
+func (m *Manager) Start() error {
+	return m.context.NetAdapter().Start()
+}
+
+// Stop stops the p2p protocol
+func (m *Manager) Stop() error {
+	return m.context.NetAdapter().Stop()
+}
+
+// Peers returns the currently active peers
+func (m *Manager) Peers() []*peerpkg.Peer {
+	return m.context.Peers()
+}
+
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (m *Manager) IBDPeer() *peerpkg.Peer {
+	return m.context.IBDPeer()
+}
+
+// AddTransaction adds transaction to the mempool and propagates it.
+func (m *Manager) AddTransaction(tx *util.Tx) error {
+	return m.context.AddTransaction(tx)
+}
+
+// AddBlock adds the given block to the DAG and propagates it.
+func (m *Manager) AddBlock(block *util.Block, flags blockdag.BehaviorFlags) error {
+	return m.context.AddBlock(block, flags)
+}
+
+func (m *Manager) runFlows(flows []*flow, peer *peerpkg.Peer, errChan <-chan error) error {
+	for _, flow := range flows {
+		executeFunc := flow.executeFunc // extract to new variable so that it's not overwritten
+		spawn(fmt.Sprintf("flow-%s", flow.name), func() {
+			executeFunc(peer)
+		})
+	}
+
+	return <-errChan
+}

app/protocol/peer/log.go

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

app/protocol/peer/peer.go

@@ -0,0 +1,207 @@
+package peer
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/daghash"
+	mathUtil "github.com/kaspanet/kaspad/util/math"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// Peer holds data about a peer.
+type Peer struct {
+	connection *netadapter.NetConnection
+
+	selectedTipHashMtx sync.RWMutex
+	selectedTipHash    *daghash.Hash
+
+	userAgent                string
+	services                 appmessage.ServiceFlag
+	advertisedProtocolVerion uint32 // protocol version advertised by remote
+	protocolVersion          uint32 // negotiated protocol version
+	disableRelayTx           bool
+	subnetworkID             *subnetworkid.SubnetworkID
+
+	timeOffset        time.Duration
+	connectionStarted time.Time
+
+	pingLock         sync.RWMutex
+	lastPingNonce    uint64        // The nonce of the last ping we sent
+	lastPingTime     time.Time     // Time we sent last ping
+	lastPingDuration time.Duration // Time for last ping to return
+
+	isSelectedTipRequested uint32
+	selectedTipRequestChan chan struct{}
+	lastSelectedTipRequest mstime.Time
+
+	ibdStartChan chan struct{}
+}
+
+// New returns a new Peer
+func New(connection *netadapter.NetConnection) *Peer {
+	return &Peer{
+		connection:             connection,
+		selectedTipRequestChan: make(chan struct{}),
+		ibdStartChan:           make(chan struct{}),
+		connectionStarted:      time.Now(),
+	}
+}
+
+// Connection returns the NetConnection associated with this peer
+func (p *Peer) Connection() *netadapter.NetConnection {
+	return p.connection
+}
+
+// SelectedTipHash returns the selected tip of the peer.
+func (p *Peer) SelectedTipHash() *daghash.Hash {
+	p.selectedTipHashMtx.RLock()
+	defer p.selectedTipHashMtx.RUnlock()
+	return p.selectedTipHash
+}
+
+// SetSelectedTipHash sets the selected tip of the peer.
+func (p *Peer) SetSelectedTipHash(hash *daghash.Hash) {
+	p.selectedTipHashMtx.Lock()
+	defer p.selectedTipHashMtx.Unlock()
+	p.selectedTipHash = hash
+}
+
+// SubnetworkID returns the subnetwork the peer is associated with.
+// It is nil in full nodes.
+func (p *Peer) SubnetworkID() *subnetworkid.SubnetworkID {
+	return p.subnetworkID
+}
+
+// ID returns the peer ID.
+func (p *Peer) ID() *id.ID {
+	return p.connection.ID()
+}
+
+// TimeOffset returns the peer's time offset.
+func (p *Peer) TimeOffset() time.Duration {
+	return p.timeOffset
+}
+
+// UserAgent returns the peer's user agent.
+func (p *Peer) UserAgent() string {
+	return p.userAgent
+}
+
+// AdvertisedProtocolVersion returns the peer's advertised protocol version.
+func (p *Peer) AdvertisedProtocolVersion() uint32 {
+	return p.advertisedProtocolVerion
+}
+
+// TimeConnected returns the time since the connection to this been has been started.
+func (p *Peer) TimeConnected() time.Duration {
+	return time.Since(p.connectionStarted)
+}
+
+// IsOutbound returns whether the peer is an outbound connection.
+func (p *Peer) IsOutbound() bool {
+	return p.connection.IsOutbound()
+}
+
+// UpdateFieldsFromMsgVersion updates the peer with the data from the version message.
+func (p *Peer) UpdateFieldsFromMsgVersion(msg *appmessage.MsgVersion) {
+	// Negotiate the protocol version.
+	p.advertisedProtocolVerion = msg.ProtocolVersion
+	p.protocolVersion = mathUtil.MinUint32(p.protocolVersion, p.advertisedProtocolVerion)
+	log.Debugf("Negotiated protocol version %d for peer %s",
+		p.protocolVersion, p.ID())
+
+	// Set the supported services for the peer to what the remote peer
+	// advertised.
+	p.services = msg.Services
+
+	// Set the remote peer's user agent.
+	p.userAgent = msg.UserAgent
+
+	p.disableRelayTx = msg.DisableRelayTx
+	p.selectedTipHash = msg.SelectedTipHash
+	p.subnetworkID = msg.SubnetworkID
+
+	p.timeOffset = mstime.Since(msg.Timestamp)
+}
+
+// SetPingPending sets the ping state of the peer to 'pending'
+func (p *Peer) SetPingPending(nonce uint64) {
+	p.pingLock.Lock()
+	defer p.pingLock.Unlock()
+
+	p.lastPingNonce = nonce
+	p.lastPingTime = time.Now()
+}
+
+// SetPingIdle sets the ping state of the peer to 'idle'
+func (p *Peer) SetPingIdle() {
+	p.pingLock.Lock()
+	defer p.pingLock.Unlock()
+
+	p.lastPingNonce = 0
+	p.lastPingDuration = time.Since(p.lastPingTime)
+}
+
+func (p *Peer) String() string {
+	return p.connection.String()
+}
+
+// RequestSelectedTipIfRequired notifies the peer that requesting
+// a selected tip is required. This triggers the selected tip
+// request flow.
+func (p *Peer) RequestSelectedTipIfRequired() {
+	if atomic.SwapUint32(&p.isSelectedTipRequested, 1) != 0 {
+		return
+	}
+
+	const minGetSelectedTipInterval = time.Minute
+	if mstime.Since(p.lastSelectedTipRequest) < minGetSelectedTipInterval {
+		return
+	}
+
+	p.lastSelectedTipRequest = mstime.Now()
+	p.selectedTipRequestChan <- struct{}{}
+}
+
+// WaitForSelectedTipRequests blocks the current thread until
+// a selected tip is requested from this peer
+func (p *Peer) WaitForSelectedTipRequests() {
+	<-p.selectedTipRequestChan
+}
+
+// FinishRequestingSelectedTip finishes requesting the selected
+// tip from this peer
+func (p *Peer) FinishRequestingSelectedTip() {
+	atomic.StoreUint32(&p.isSelectedTipRequested, 0)
+}
+
+// StartIBD starts the IBD process for this peer
+func (p *Peer) StartIBD() {
+	p.ibdStartChan <- struct{}{}
+}
+
+// WaitForIBDStart blocks the current thread until
+// IBD start is requested from this peer
+func (p *Peer) WaitForIBDStart() {
+	<-p.ibdStartChan
+}
+
+// Address returns the address associated with this connection
+func (p *Peer) Address() string {
+	return p.connection.Address()
+}
+
+// LastPingDuration returns the duration of the last ping to
+// this peer
+func (p *Peer) LastPingDuration() time.Duration {
+	p.pingLock.Lock()
+	defer p.pingLock.Unlock()
+
+	return p.lastPingDuration
+}