Fixed version

* [NOD-1551] Add NewTestConsensusWithDataDir to factory

* [NOD-1551] Cache transaction ID

* [NOD-1551] Should return err if err != nil

* [NOD-1551] BuildBlockWithParents returns the blocks pastUTXOData

* [NOD-1551] Set BlockCoinbaseMaturity to 0 in TestDoubleSpends

* [NOD-1551] Fix comments

* --amend

Co-authored-by: Ori Newman <orinewman1@gmail.com>

README.md

@@ -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,

addressmanager/addressmanager_test.go

@@ -1,635 +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 addressmanager
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-
-	"github.com/pkg/errors"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// naTest is used to describe a test to be performed against the NetAddressKey
-// method.
-type naTest struct {
-	in   wire.NetAddress
-	want AddressKey
-}
-
-// 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 AddressKey) {
-	nip := net.ParseIP(ip)
-	na := *wire.NewNetAddressIPPort(nip, port, wire.SFNodeNetwork)
-	test := naTest{na, want}
-	naTests = append(naTests, test)
-}
-
-func lookupFuncForTest(host string) ([]net.IP, error) {
-	return nil, errors.New("not implemented")
-}
-
-func newAddrManagerForTest(t *testing.T, testName string,
-	localSubnetworkID *subnetworkid.SubnetworkID) (addressManager *AddressManager, teardown func()) {
-
-	cfg := config.DefaultConfig()
-	cfg.SubnetworkID = localSubnetworkID
-
-	dbPath, err := ioutil.TempDir("", testName)
-	if err != nil {
-		t.Fatalf("Error creating temporary directory: %s", err)
-	}
-
-	databaseContext, err := dbaccess.New(dbPath)
-	if err != nil {
-		t.Fatalf("error creating db: %s", err)
-	}
-
-	addressManager = New(cfg, databaseContext)
-
-	return addressManager, func() {
-		err := databaseContext.Close()
-		if err != nil {
-			t.Fatalf("error closing the database: %s", err)
-		}
-	}
-}
-
-func TestStartStop(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestStartStop", nil)
-	defer teardown()
-	err := amgr.Start()
-	if err != nil {
-		t.Fatalf("Address Manager failed to start: %v", err)
-	}
-	err = amgr.Stop()
-	if err != nil {
-		t.Fatalf("Address Manager failed to stop: %v", err)
-	}
-}
-
-func TestAddAddressByIP(t *testing.T) {
-	fmtErr := errors.Errorf("")
-	addrErr := &net.AddrError{}
-	var tests = []struct {
-		addrIP string
-		err    error
-	}{
-		{
-			someIP + ":16111",
-			nil,
-		},
-		{
-			someIP,
-			addrErr,
-		},
-		{
-			someIP[:12] + ":8333",
-			fmtErr,
-		},
-		{
-			someIP + ":abcd",
-			fmtErr,
-		},
-	}
-
-	amgr, teardown := newAddrManagerForTest(t, "TestAddAddressByIP", nil)
-	defer teardown()
-	for i, test := range tests {
-		err := amgr.AddAddressByIP(test.addrIP, nil)
-		if test.err != nil && err == nil {
-			t.Errorf("TestAddAddressByIP test %d failed expected an error and got none", i)
-			continue
-		}
-		if test.err == nil && err != nil {
-			t.Errorf("TestAddAddressByIP test %d failed expected no error and got one", i)
-			continue
-		}
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("TestAddAddressByIP test %d failed got %v, want %v", i,
-				reflect.TypeOf(err), reflect.TypeOf(test.err))
-			continue
-		}
-	}
-}
-
-func TestAddLocalAddress(t *testing.T) {
-	var tests = []struct {
-		address  wire.NetAddress
-		priority AddressPriority
-		valid    bool
-	}{
-		{
-			wire.NetAddress{IP: net.ParseIP("192.168.0.100")},
-			InterfacePrio,
-			false,
-		},
-		{
-			wire.NetAddress{IP: net.ParseIP("204.124.1.1")},
-			InterfacePrio,
-			true,
-		},
-		{
-			wire.NetAddress{IP: net.ParseIP("204.124.1.1")},
-			BoundPrio,
-			true,
-		},
-		{
-			wire.NetAddress{IP: net.ParseIP("::1")},
-			InterfacePrio,
-			false,
-		},
-		{
-			wire.NetAddress{IP: net.ParseIP("fe80::1")},
-			InterfacePrio,
-			false,
-		},
-		{
-			wire.NetAddress{IP: net.ParseIP("2620:100::1")},
-			InterfacePrio,
-			true,
-		},
-	}
-	amgr, teardown := newAddrManagerForTest(t, "TestAddLocalAddress", nil)
-	defer teardown()
-	for x, test := range tests {
-		result := amgr.AddLocalAddress(&test.address, test.priority)
-		if result == nil && !test.valid {
-			t.Errorf("TestAddLocalAddress test #%d failed: %s should have "+
-				"been accepted", x, test.address.IP)
-			continue
-		}
-		if result != nil && test.valid {
-			t.Errorf("TestAddLocalAddress test #%d failed: %s should not have "+
-				"been accepted", x, test.address.IP)
-			continue
-		}
-	}
-}
-
-func TestAttempt(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestAttempt", nil)
-	defer teardown()
-
-	// Add a new address and get it
-	err := amgr.AddAddressByIP(someIP+":8333", nil)
-	if err != nil {
-		t.Fatalf("Adding address failed: %v", err)
-	}
-	ka := amgr.GetAddress()
-
-	if !ka.LastAttempt().IsZero() {
-		t.Errorf("Address should not have attempts, but does")
-	}
-
-	na := ka.NetAddress()
-	amgr.Attempt(na)
-
-	if ka.LastAttempt().IsZero() {
-		t.Errorf("Address should have an attempt, but does not")
-	}
-}
-
-func TestConnected(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestConnected", nil)
-	defer teardown()
-
-	// Add a new address and get it
-	err := amgr.AddAddressByIP(someIP+":8333", nil)
-	if err != nil {
-		t.Fatalf("Adding address failed: %v", err)
-	}
-	ka := amgr.GetAddress()
-	na := ka.NetAddress()
-	// make it an hour ago
-	na.Timestamp = mstime.Now().Add(time.Hour * -1)
-
-	amgr.Connected(na)
-
-	if !ka.NetAddress().Timestamp.After(na.Timestamp) {
-		t.Errorf("Address should have a new timestamp, but does not")
-	}
-}
-
-func TestNeedMoreAddresses(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestNeedMoreAddresses", nil)
-	defer teardown()
-	addrsToAdd := 1500
-	b := amgr.NeedMoreAddresses()
-	if !b {
-		t.Errorf("Expected that we need more addresses")
-	}
-	addrs := make([]*wire.NetAddress, addrsToAdd)
-
-	var err error
-	for i := 0; i < addrsToAdd; i++ {
-		s := AddressKey(fmt.Sprintf("%d.%d.173.147:8333", i/128+60, i%128+60))
-		addrs[i], err = amgr.DeserializeNetAddress(s)
-		if err != nil {
-			t.Errorf("Failed to turn %s into an address: %v", s, err)
-		}
-	}
-
-	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
-
-	amgr.AddAddresses(addrs, srcAddr, nil)
-	numAddrs := amgr.TotalNumAddresses()
-	if numAddrs > addrsToAdd {
-		t.Errorf("Number of addresses is too many %d vs %d", numAddrs, addrsToAdd)
-	}
-
-	b = amgr.NeedMoreAddresses()
-	if b {
-		t.Errorf("Expected that we don't need more addresses")
-	}
-}
-
-func TestGood(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestGood", nil)
-	defer teardown()
-	addrsToAdd := 64 * 64
-	addrs := make([]*wire.NetAddress, addrsToAdd)
-	subnetworkCount := 32
-	subnetworkIDs := make([]*subnetworkid.SubnetworkID, subnetworkCount)
-
-	var err error
-	for i := 0; i < addrsToAdd; i++ {
-		s := AddressKey(fmt.Sprintf("%d.173.147.%d:8333", i/64+60, i%64+60))
-		addrs[i], err = amgr.DeserializeNetAddress(s)
-		if err != nil {
-			t.Errorf("Failed to turn %s into an address: %v", s, err)
-		}
-	}
-
-	for i := 0; i < subnetworkCount; i++ {
-		subnetworkIDs[i] = &subnetworkid.SubnetworkID{0xff - byte(i)}
-	}
-
-	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
-
-	amgr.AddAddresses(addrs, srcAddr, nil)
-	for i, addr := range addrs {
-		amgr.Good(addr, subnetworkIDs[i%subnetworkCount])
-	}
-
-	numAddrs := amgr.TotalNumAddresses()
-	if numAddrs >= addrsToAdd {
-		t.Errorf("Number of addresses is too many: %d vs %d", numAddrs, addrsToAdd)
-	}
-
-	numCache := len(amgr.AddressCache(true, nil))
-	if numCache == 0 || numCache >= numAddrs/4 {
-		t.Errorf("Number of addresses in cache: got %d, want positive and less than %d",
-			numCache, numAddrs/4)
-	}
-
-	for i := 0; i < subnetworkCount; i++ {
-		numCache = len(amgr.AddressCache(false, subnetworkIDs[i]))
-		if numCache == 0 || numCache >= numAddrs/subnetworkCount {
-			t.Errorf("Number of addresses in subnetwork cache: got %d, want positive and less than %d",
-				numCache, numAddrs/4/subnetworkCount)
-		}
-	}
-}
-
-func TestGoodChangeSubnetworkID(t *testing.T) {
-	amgr, teardown := newAddrManagerForTest(t, "TestGoodChangeSubnetworkID", nil)
-	defer teardown()
-	addr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
-	addrKey := NetAddressKey(addr)
-	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
-
-	oldSubnetwork := subnetworkid.SubnetworkIDNative
-	amgr.AddAddress(addr, srcAddr, oldSubnetwork)
-	amgr.Good(addr, oldSubnetwork)
-
-	// make sure address was saved to addressIndex under oldSubnetwork
-	ka := amgr.knownAddress(addr)
-	if ka == nil {
-		t.Fatalf("Address was not found after first time .Good called")
-	}
-	if !ka.SubnetworkID().IsEqual(oldSubnetwork) {
-		t.Fatalf("Address index did not point to oldSubnetwork")
-	}
-
-	// make sure address was added to correct bucket under oldSubnetwork
-	bucket := amgr.subnetworkTriedAddresBucketArrays[*oldSubnetwork][amgr.triedAddressBucketIndex(addr)]
-	wasFound := false
-	for _, ka := range bucket {
-		if NetAddressKey(ka.NetAddress()) == addrKey {
-			wasFound = true
-		}
-	}
-	if !wasFound {
-		t.Fatalf("Address was not found in the correct bucket in oldSubnetwork")
-	}
-
-	// now call .Good again with a different subnetwork
-	newSubnetwork := subnetworkid.SubnetworkIDRegistry
-	amgr.Good(addr, newSubnetwork)
-
-	// make sure address was updated in addressIndex under newSubnetwork
-	ka = amgr.knownAddress(addr)
-	if ka == nil {
-		t.Fatalf("Address was not found after second time .Good called")
-	}
-	if !ka.SubnetworkID().IsEqual(newSubnetwork) {
-		t.Fatalf("Address index did not point to newSubnetwork")
-	}
-
-	// make sure address was removed from bucket under oldSubnetwork
-	bucket = amgr.subnetworkTriedAddresBucketArrays[*oldSubnetwork][amgr.triedAddressBucketIndex(addr)]
-	wasFound = false
-	for _, ka := range bucket {
-		if NetAddressKey(ka.NetAddress()) == addrKey {
-			wasFound = true
-		}
-	}
-	if wasFound {
-		t.Fatalf("Address was not removed from bucket in oldSubnetwork")
-	}
-
-	// make sure address was added to correct bucket under newSubnetwork
-	bucket = amgr.subnetworkTriedAddresBucketArrays[*newSubnetwork][amgr.triedAddressBucketIndex(addr)]
-	wasFound = false
-	for _, ka := range bucket {
-		if NetAddressKey(ka.NetAddress()) == addrKey {
-			wasFound = true
-		}
-	}
-	if !wasFound {
-		t.Fatalf("Address was not found in the correct bucket in newSubnetwork")
-	}
-}
-
-func TestGetAddress(t *testing.T) {
-	localSubnetworkID := &subnetworkid.SubnetworkID{0xff}
-	amgr, teardown := newAddrManagerForTest(t, "TestGetAddress", localSubnetworkID)
-	defer teardown()
-
-	// Get an address from an empty set (should error)
-	if rv := amgr.GetAddress(); rv != nil {
-		t.Errorf("GetAddress failed: got: %v want: %v\n", rv, nil)
-	}
-
-	// Add a new address and get it
-	err := amgr.AddAddressByIP(someIP+":8332", localSubnetworkID)
-	if err != nil {
-		t.Fatalf("Adding address failed: %v", err)
-	}
-	ka := amgr.GetAddress()
-	if ka == nil {
-		t.Fatalf("Did not get an address where there is one in the pool")
-	}
-	amgr.Attempt(ka.NetAddress())
-
-	// Checks that we don't get it if we find that it has other subnetwork ID than expected.
-	actualSubnetworkID := &subnetworkid.SubnetworkID{0xfe}
-	amgr.Good(ka.NetAddress(), actualSubnetworkID)
-	ka = amgr.GetAddress()
-	if ka != nil {
-		t.Errorf("Didn't expect to get an address because there shouldn't be any address from subnetwork ID %s or nil", localSubnetworkID)
-	}
-
-	// Checks that the total number of addresses incremented although the new address is not full node or a partial node of the same subnetwork as the local node.
-	numAddrs := amgr.TotalNumAddresses()
-	if numAddrs != 1 {
-		t.Errorf("Wrong number of addresses: got %d, want %d", numAddrs, 1)
-	}
-
-	// Now we repeat the same process, but now the address has the expected subnetwork ID.
-
-	// Add a new address and get it
-	err = amgr.AddAddressByIP(someIP+":8333", localSubnetworkID)
-	if err != nil {
-		t.Fatalf("Adding address failed: %v", err)
-	}
-	ka = amgr.GetAddress()
-	if ka == nil {
-		t.Fatalf("Did not get an address where there is one in the pool")
-	}
-	if ka.NetAddress().IP.String() != someIP {
-		t.Errorf("Wrong IP: got %v, want %v", ka.NetAddress().IP.String(), someIP)
-	}
-	if !ka.SubnetworkID().IsEqual(localSubnetworkID) {
-		t.Errorf("Wrong Subnetwork ID: got %v, want %v", *ka.SubnetworkID(), localSubnetworkID)
-	}
-	amgr.Attempt(ka.NetAddress())
-
-	// Mark this as a good address and get it
-	amgr.Good(ka.NetAddress(), localSubnetworkID)
-	ka = amgr.GetAddress()
-	if ka == nil {
-		t.Fatalf("Did not get an address where there is one in the pool")
-	}
-	if ka.NetAddress().IP.String() != someIP {
-		t.Errorf("Wrong IP: got %v, want %v", ka.NetAddress().IP.String(), someIP)
-	}
-	if *ka.SubnetworkID() != *localSubnetworkID {
-		t.Errorf("Wrong Subnetwork ID: got %v, want %v", ka.SubnetworkID(), localSubnetworkID)
-	}
-
-	numAddrs = amgr.TotalNumAddresses()
-	if numAddrs != 2 {
-		t.Errorf("Wrong number of addresses: got %d, want %d", numAddrs, 1)
-	}
-}
-
-func TestGetBestLocalAddress(t *testing.T) {
-	localAddrs := []wire.NetAddress{
-		{IP: net.ParseIP("192.168.0.100")},
-		{IP: net.ParseIP("::1")},
-		{IP: net.ParseIP("fe80::1")},
-		{IP: net.ParseIP("2001:470::1")},
-	}
-
-	var tests = []struct {
-		remoteAddr wire.NetAddress
-		want0      wire.NetAddress
-		want1      wire.NetAddress
-		want2      wire.NetAddress
-		want3      wire.NetAddress
-	}{
-		{
-			// Remote connection from public IPv4
-			wire.NetAddress{IP: net.ParseIP("204.124.8.1")},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.ParseIP("204.124.8.100")},
-			wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
-		},
-		{
-			// Remote connection from private IPv4
-			wire.NetAddress{IP: net.ParseIP("172.16.0.254")},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.IPv4zero},
-		},
-		{
-			// Remote connection from public IPv6
-			wire.NetAddress{IP: net.ParseIP("2602:100:abcd::102")},
-			wire.NetAddress{IP: net.IPv6zero},
-			wire.NetAddress{IP: net.ParseIP("2001:470::1")},
-			wire.NetAddress{IP: net.ParseIP("2001:470::1")},
-			wire.NetAddress{IP: net.ParseIP("2001:470::1")},
-		},
-		/* XXX
-		{
-			// Remote connection from Tor
-			wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43::100")},
-			wire.NetAddress{IP: net.IPv4zero},
-			wire.NetAddress{IP: net.ParseIP("204.124.8.100")},
-			wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")},
-		},
-		*/
-	}
-
-	amgr, teardown := newAddrManagerForTest(t, "TestGetBestLocalAddress", nil)
-	defer teardown()
-
-	// Test against default when there's no address
-	for x, test := range tests {
-		got := amgr.GetBestLocalAddress(&test.remoteAddr)
-		if !test.want0.IP.Equal(got.IP) {
-			t.Errorf("TestGetBestLocalAddress test1 #%d failed for remote address %s: want %s got %s",
-				x, test.remoteAddr.IP, test.want1.IP, got.IP)
-			continue
-		}
-	}
-
-	for _, localAddr := range localAddrs {
-		amgr.AddLocalAddress(&localAddr, InterfacePrio)
-	}
-
-	// Test against want1
-	for x, test := range tests {
-		got := amgr.GetBestLocalAddress(&test.remoteAddr)
-		if !test.want1.IP.Equal(got.IP) {
-			t.Errorf("TestGetBestLocalAddress test1 #%d failed for remote address %s: want %s got %s",
-				x, test.remoteAddr.IP, test.want1.IP, got.IP)
-			continue
-		}
-	}
-
-	// Add a public IP to the list of local addresses.
-	localAddr := wire.NetAddress{IP: net.ParseIP("204.124.8.100")}
-	amgr.AddLocalAddress(&localAddr, InterfacePrio)
-
-	// Test against want2
-	for x, test := range tests {
-		got := amgr.GetBestLocalAddress(&test.remoteAddr)
-		if !test.want2.IP.Equal(got.IP) {
-			t.Errorf("TestGetBestLocalAddress test2 #%d failed for remote address %s: want %s got %s",
-				x, test.remoteAddr.IP, test.want2.IP, got.IP)
-			continue
-		}
-	}
-	/*
-		// Add a Tor generated IP address
-		localAddr = wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
-		amgr.AddLocalAddress(&localAddr, ManualPrio)
-		// Test against want3
-		for x, test := range tests {
-			got := amgr.GetBestLocalAddress(&test.remoteAddr)
-			if !test.want3.IP.Equal(got.IP) {
-				t.Errorf("TestGetBestLocalAddress test3 #%d failed for remote address %s: want %s got %s",
-					x, test.remoteAddr.IP, test.want3.IP, got.IP)
-				continue
-			}
-		}
-	*/
-}
-
-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
-		}
-	}
-
-}

addressmanager/internal_test.go

@@ -1,24 +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 addressmanager
-
-import (
-	"github.com/kaspanet/kaspad/util/mstime"
-	"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 mstime.Time, tried bool, refs int) *KnownAddress {
-	return &KnownAddress{netAddress: na, attempts: attempts, lastAttempt: lastattempt,
-		lastSuccess: lastsuccess, tried: tried, referenceCount: refs}
-}

addressmanager/knownaddress.go

@@ -1,108 +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 addressmanager
-
-import (
-	"github.com/kaspanet/kaspad/util/mstime"
-	"time"
-
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// KnownAddress tracks information about a known network address that is used
-// to determine how viable an address is.
-type KnownAddress struct {
-	netAddress     *wire.NetAddress
-	sourceAddress  *wire.NetAddress
-	attempts       int
-	lastAttempt    mstime.Time
-	lastSuccess    mstime.Time
-	tried          bool
-	referenceCount int // reference count of new buckets
-	subnetworkID   *subnetworkid.SubnetworkID
-	isBanned       bool
-	bannedTime     mstime.Time
-}
-
-// NetAddress returns the underlying wire.NetAddress associated with the
-// known address.
-func (ka *KnownAddress) NetAddress() *wire.NetAddress {
-	return ka.netAddress
-}
-
-// SubnetworkID returns the subnetwork ID of the known address.
-func (ka *KnownAddress) SubnetworkID() *subnetworkid.SubnetworkID {
-	return ka.subnetworkID
-}
-
-// LastAttempt returns the last time the known address was attempted.
-func (ka *KnownAddress) LastAttempt() mstime.Time {
-	return ka.lastAttempt
-}
-
-// chance returns the selection probability for a known address. The priority
-// depends upon how recently the address has been seen, how recently it was last
-// attempted and how often attempts to connect to it have failed.
-func (ka *KnownAddress) chance() float64 {
-	now := mstime.Now()
-	lastAttempt := now.Sub(ka.lastAttempt)
-
-	if lastAttempt < 0 {
-		lastAttempt = 0
-	}
-
-	c := 1.0
-
-	// Very recent attempts are less likely to be retried.
-	if lastAttempt < 10*time.Minute {
-		c *= 0.01
-	}
-
-	// Failed attempts deprioritise.
-	for i := ka.attempts; i > 0; i-- {
-		c /= 1.5
-	}
-
-	return c
-}
-
-// isBad returns true if the address in question has not been tried in the last
-// minute and meets one of the following criteria:
-// 1) It claims to be from the future
-// 2) It hasn't been seen in over a month
-// 3) It has failed at least three times and never succeeded
-// 4) It has failed ten times in the last week
-// All addresses that meet these criteria are assumed to be worthless and not
-// worth keeping hold of.
-func (ka *KnownAddress) isBad() bool {
-	if ka.lastAttempt.After(mstime.Now().Add(-1 * time.Minute)) {
-		return false
-	}
-
-	// From the future?
-	if ka.netAddress.Timestamp.After(mstime.Now().Add(10 * time.Minute)) {
-		return true
-	}
-
-	// Over a month old?
-	if ka.netAddress.Timestamp.Before(mstime.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
-		return true
-	}
-
-	// Never succeeded?
-	if ka.lastSuccess.IsZero() && ka.attempts >= numRetries {
-		return true
-	}
-
-	// Hasn't succeeded in too long?
-	if !ka.lastSuccess.After(mstime.Now().Add(-1*minBadDays*time.Hour*24)) &&
-		ka.attempts >= maxFailures {
-		return true
-	}
-
-	return false
-}

addressmanager/knownaddress_test.go

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

app/app.go

@@ -2,247 +2,184 @@ package app
 
 import (
 	"fmt"
-	"sync/atomic"
+	"os"
+	"path/filepath"
+	"runtime"
+	"time"
 
-	"github.com/kaspanet/kaspad/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/db/database"
+	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
 
-	"github.com/kaspanet/kaspad/netadapter/id"
+	"github.com/kaspanet/kaspad/infrastructure/os/signal"
+	"github.com/kaspanet/kaspad/util/profiling"
+	"github.com/kaspanet/kaspad/version"
 
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/blockdag/indexers"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/kaspanet/kaspad/connmanager"
-	"github.com/kaspanet/kaspad/dbaccess"
-	"github.com/kaspanet/kaspad/dnsseed"
-	"github.com/kaspanet/kaspad/mempool"
-	"github.com/kaspanet/kaspad/mining"
-	"github.com/kaspanet/kaspad/netadapter"
-	"github.com/kaspanet/kaspad/protocol"
-	"github.com/kaspanet/kaspad/rpc"
-	"github.com/kaspanet/kaspad/signal"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/panics"
-	"github.com/kaspanet/kaspad/wire"
+
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
+	"github.com/kaspanet/kaspad/infrastructure/os/limits"
+	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
 )
 
-// App is a wrapper for all the kaspad services
-type App struct {
-	cfg               *config.Config
-	rpcServer         *rpc.Server
-	addressManager    *addressmanager.AddressManager
-	protocolManager   *protocol.Manager
-	connectionManager *connmanager.ConnectionManager
-	netAdapter        *netadapter.NetAdapter
-
-	started, shutdown int32
+var desiredLimits = &limits.DesiredLimits{
+	FileLimitWant: 2048,
+	FileLimitMin:  1024,
 }
 
-// Start launches all the kaspad services.
-func (a *App) Start() {
-	// Already started?
-	if atomic.AddInt32(&a.started, 1) != 1 {
-		return
-	}
+var serviceDescription = &winservice.ServiceDescription{
+	Name:        "kaspadsvc",
+	DisplayName: "Kaspad Service",
+	Description: "Downloads and stays synchronized with the Kaspa blockDAG and " +
+		"provides DAG services to applications.",
+}
 
-	log.Trace("Starting kaspad")
+type kaspadApp struct {
+	cfg *config.Config
+}
 
-	err := a.protocolManager.Start()
+// StartApp starts the kaspad app, and blocks until it finishes running
+func StartApp() error {
+	execenv.Initialize(desiredLimits)
+
+	// Load configuration and parse command line. This function also
+	// initializes logging and configures it accordingly.
+	cfg, err := config.LoadConfig()
 	if err != nil {
-		panics.Exit(log, fmt.Sprintf("Error starting the p2p protocol: %+v", err))
+		fmt.Fprintln(os.Stderr, err)
+		return err
+	}
+	defer panics.HandlePanic(log, "MAIN", nil)
+
+	app := &kaspadApp{cfg: cfg}
+
+	// Call serviceMain on Windows to handle running as a service. When
+	// the return isService flag is true, exit now since we ran as a
+	// service. Otherwise, just fall through to normal operation.
+	if runtime.GOOS == "windows" {
+		isService, err := winservice.WinServiceMain(app.main, serviceDescription, cfg)
+		if err != nil {
+			return err
+		}
+		if isService {
+			return nil
+		}
 	}
 
-	a.maybeSeedFromDNS()
-
-	a.connectionManager.Start()
-
-	if !a.cfg.DisableRPC {
-		a.rpcServer.Start()
-	}
+	return app.main(nil)
 }
 
-// Stop gracefully shuts down all the kaspad services.
-func (a *App) Stop() error {
-	// Make sure this only happens once.
-	if atomic.AddInt32(&a.shutdown, 1) != 1 {
-		log.Infof("Kaspad is already in the process of shutting down")
+func (app *kaspadApp) main(startedChan chan<- struct{}) error {
+	// Get a channel that will be closed when a shutdown signal has been
+	// triggered either from an OS signal such as SIGINT (Ctrl+C) or from
+	// another subsystem such as the RPC server.
+	interrupt := signal.InterruptListener()
+	defer log.Info("Shutdown complete")
+
+	// Show version at startup.
+	log.Infof("Version %s", version.Version())
+
+	// Enable http profiling server if requested.
+	if app.cfg.Profile != "" {
+		profiling.Start(app.cfg.Profile, log)
+	}
+
+	// Perform upgrades to kaspad as new versions require it.
+	if err := doUpgrades(); err != nil {
+		log.Error(err)
+		return err
+	}
+
+	// Return now if an interrupt signal was triggered.
+	if signal.InterruptRequested(interrupt) {
 		return nil
 	}
 
-	log.Warnf("Kaspad shutting down")
-
-	a.connectionManager.Stop()
-
-	err := a.protocolManager.Stop()
-	if err != nil {
-		log.Errorf("Error stopping the p2p protocol: %+v", err)
-	}
-
-	// Shutdown the RPC server if it's not disabled.
-	if !a.cfg.DisableRPC {
-		err := a.rpcServer.Stop()
+	if app.cfg.ResetDatabase {
+		err := removeDatabase(app.cfg)
 		if err != nil {
-			log.Errorf("Error stopping rpcServer: %+v", err)
+			log.Error(err)
+			return err
 		}
 	}
 
+	// Open the database
+	databaseContext, err := openDB(app.cfg)
+	if err != nil {
+		log.Error(err)
+		return err
+	}
+
+	defer func() {
+		log.Infof("Gracefully shutting down the database...")
+		err := databaseContext.Close()
+		if err != nil {
+			log.Errorf("Failed to close the database: %s", err)
+		}
+	}()
+
+	// Return now if an interrupt signal was triggered.
+	if signal.InterruptRequested(interrupt) {
+		return nil
+	}
+
+	// Create componentManager and start it.
+	componentManager, err := NewComponentManager(app.cfg, databaseContext, interrupt)
+	if err != nil {
+		log.Errorf("Unable to start kaspad: %+v", err)
+		return err
+	}
+
+	defer func() {
+		log.Infof("Gracefully shutting down kaspad...")
+
+		shutdownDone := make(chan struct{})
+		go func() {
+			componentManager.Stop()
+			shutdownDone <- struct{}{}
+		}()
+
+		const shutdownTimeout = 2 * time.Minute
+
+		select {
+		case <-shutdownDone:
+		case <-time.After(shutdownTimeout):
+			log.Criticalf("Graceful shutdown timed out %s. Terminating...", shutdownTimeout)
+		}
+		log.Infof("Kaspad shutdown complete")
+	}()
+
+	componentManager.Start()
+
+	if startedChan != nil {
+		startedChan <- struct{}{}
+	}
+
+	// Wait until the interrupt signal is received from an OS signal or
+	// shutdown is requested through one of the subsystems such as the RPC
+	// server.
+	<-interrupt
 	return nil
 }
 
-// New returns a new App instance configured to listen on addr for the
-// kaspa network type specified by dagParams. Use start to begin accepting
-// connections from peers.
-func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{}) (*App, error) {
-	indexManager, acceptanceIndex := setupIndexes(cfg)
-
-	sigCache := txscript.NewSigCache(cfg.SigCacheMaxSize)
-
-	// Create a new block DAG instance with the appropriate configuration.
-	dag, err := setupDAG(cfg, databaseContext, interrupt, sigCache, indexManager)
-	if err != nil {
-		return nil, err
-	}
-
-	txMempool := setupMempool(cfg, dag, sigCache)
-
-	netAdapter, err := netadapter.NewNetAdapter(cfg)
-	if err != nil {
-		return nil, err
-	}
-	addressManager := addressmanager.New(cfg, databaseContext)
-
-	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
-	if err != nil {
-		return nil, err
-	}
-
-	protocolManager, err := protocol.NewManager(cfg, dag, netAdapter, addressManager, txMempool, connectionManager)
-	if err != nil {
-		return nil, err
-	}
-	rpcServer, err := setupRPC(
-		cfg, dag, txMempool, sigCache, acceptanceIndex, connectionManager, addressManager, protocolManager)
-	if err != nil {
-		return nil, err
-	}
-
-	return &App{
-		cfg:               cfg,
-		rpcServer:         rpcServer,
-		protocolManager:   protocolManager,
-		connectionManager: connectionManager,
-		netAdapter:        netAdapter,
-		addressManager:    addressManager,
-	}, nil
+// doUpgrades performs upgrades to kaspad as new versions require it.
+// currently it's a placeholder we got from kaspad upstream, that does nothing
+func doUpgrades() error {
+	return nil
 }
 
-func (a *App) maybeSeedFromDNS() {
-	if !a.cfg.DisableDNSSeed {
-		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, wire.SFNodeNetwork, false, nil,
-			a.cfg.Lookup, func(addresses []*wire.NetAddress) {
-				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
-				// IPs of nodes and not its own IP, we can not know real IP of
-				// source. So we'll take first returned address as source.
-				a.addressManager.AddAddresses(addresses, addresses[0], nil)
-			})
-	}
-}
-func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{},
-	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
-
-	dag, err := blockdag.New(&blockdag.Config{
-		Interrupt:       interrupt,
-		DatabaseContext: databaseContext,
-		DAGParams:       cfg.NetParams(),
-		TimeSource:      blockdag.NewTimeSource(),
-		SigCache:        sigCache,
-		IndexManager:    indexManager,
-		SubnetworkID:    cfg.SubnetworkID,
-	})
-	return dag, err
+// dbPath returns the path to the block database given a database type.
+func databasePath(cfg *config.Config) string {
+	return filepath.Join(cfg.DataDir, "db")
 }
 
-func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.AcceptanceIndex) {
-	// Create indexes if needed.
-	var indexes []indexers.Indexer
-	var acceptanceIndex *indexers.AcceptanceIndex
-	if cfg.AcceptanceIndex {
-		log.Info("acceptance index is enabled")
-		indexes = append(indexes, acceptanceIndex)
-	}
-
-	// Create an index manager if any of the optional indexes are enabled.
-	if len(indexes) < 0 {
-		return nil, nil
-	}
-	indexManager := indexers.NewManager(indexes)
-	return indexManager, acceptanceIndex
+func removeDatabase(cfg *config.Config) error {
+	dbPath := databasePath(cfg)
+	return os.RemoveAll(dbPath)
 }
 
-func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript.SigCache) *mempool.TxPool {
-	mempoolConfig := mempool.Config{
-		Policy: mempool.Policy{
-			AcceptNonStd:    cfg.RelayNonStd,
-			MaxOrphanTxs:    cfg.MaxOrphanTxs,
-			MaxOrphanTxSize: config.DefaultMaxOrphanTxSize,
-			MinRelayTxFee:   cfg.MinRelayTxFee,
-			MaxTxVersion:    1,
-		},
-		CalcSequenceLockNoLock: func(tx *util.Tx, utxoSet blockdag.UTXOSet) (*blockdag.SequenceLock, error) {
-			return dag.CalcSequenceLockNoLock(tx, utxoSet, true)
-		},
-		IsDeploymentActive: dag.IsDeploymentActive,
-		SigCache:           sigCache,
-		DAG:                dag,
-	}
-
-	return mempool.New(&mempoolConfig)
-}
-
-func setupRPC(cfg *config.Config,
-	dag *blockdag.BlockDAG,
-	txMempool *mempool.TxPool,
-	sigCache *txscript.SigCache,
-	acceptanceIndex *indexers.AcceptanceIndex,
-	connectionManager *connmanager.ConnectionManager,
-	addressManager *addressmanager.AddressManager,
-	protocolManager *protocol.Manager) (*rpc.Server, error) {
-
-	if !cfg.DisableRPC {
-		policy := mining.Policy{
-			BlockMaxMass: cfg.BlockMaxMass,
-		}
-		blockTemplateGenerator := mining.NewBlkTmplGenerator(&policy, txMempool, dag, sigCache)
-
-		rpcServer, err := rpc.NewRPCServer(cfg, dag, txMempool, acceptanceIndex, blockTemplateGenerator,
-			connectionManager, addressManager, protocolManager)
-		if err != nil {
-			return nil, err
-		}
-
-		// Signal process shutdown when the RPC server requests it.
-		spawn("setupRPC-handleShutdownRequest", func() {
-			<-rpcServer.RequestedProcessShutdown()
-			signal.ShutdownRequestChannel <- struct{}{}
-		})
-
-		return rpcServer, nil
-	}
-	return nil, nil
-}
-
-// P2PNodeID returns the network ID associated with this App
-func (a *App) P2PNodeID() *id.ID {
-	return a.netAdapter.ID()
-}
-
-// AddressManager returns the AddressManager associated with this App
-func (a *App) AddressManager() *addressmanager.AddressManager {
-	return a.addressManager
-}
-
-// WaitForShutdown blocks until the main listener and peer handlers are stopped.
-func (a *App) WaitForShutdown() {
-	// TODO(libp2p)
-	// a.p2pServer.WaitForShutdown()
+func openDB(cfg *config.Config) (database.Database, error) {
+	dbPath := databasePath(cfg)
+	log.Infof("Loading database from '%s'", dbPath)
+	return ldb.NewLevelDB(dbPath)
 }

app/appmessage/README.md

@@ -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/common.go

@@ -2,24 +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"
-	"github.com/kaspanet/kaspad/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"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/binaryserializer"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
 )
 
 // 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.
@@ -135,7 +138,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		}
 		return nil
 
-	case *daghash.Hash:
+	case *externalapi.DomainHash:
 		_, err := io.ReadFull(r, e[:])
 		if err != nil {
 			return err
@@ -145,7 +148,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 	case *id.ID:
 		return e.Deserialize(r)
 
-	case *subnetworkid.SubnetworkID:
+	case *externalapi.DomainSubnetworkID:
 		_, err := io.ReadFull(r, e[:])
 		if err != nil {
 			return err
@@ -160,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 {
@@ -268,7 +263,7 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
-	case *daghash.Hash:
+	case *externalapi.DomainHash:
 		_, err := w.Write(e[:])
 		if err != nil {
 			return err
@@ -278,7 +273,7 @@ func WriteElement(w io.Writer, element interface{}) error {
 	case *id.ID:
 		return e.Serialize(w)
 
-	case *subnetworkid.SubnetworkID:
+	case *externalapi.DomainSubnetworkID:
 		_, err := w.Write(e[:])
 		if err != nil {
 			return err
@@ -292,13 +287,6 @@ 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 {
@@ -387,30 +375,31 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 // on its value.
 func WriteVarInt(w io.Writer, val uint64) error {
 	if val < 0xfd {
-		return binaryserializer.PutUint8(w, uint8(val))
+		_, err := w.Write([]byte{uint8(val)})
+		return errors.WithStack(err)
 	}
 
 	if val <= math.MaxUint16 {
-		err := binaryserializer.PutUint8(w, 0xfd)
-		if err != nil {
-			return err
-		}
-		return binaryserializer.PutUint16(w, littleEndian, uint16(val))
+		var buf [3]byte
+		buf[0] = 0xfd
+		littleEndian.PutUint16(buf[1:], uint16(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
 	}
 
 	if val <= math.MaxUint32 {
-		err := binaryserializer.PutUint8(w, 0xfe)
-		if err != nil {
-			return err
-		}
-		return binaryserializer.PutUint32(w, littleEndian, uint32(val))
+		var buf [5]byte
+		buf[0] = 0xfe
+		littleEndian.PutUint32(buf[1:], uint32(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
 	}
 
-	err := binaryserializer.PutUint8(w, 0xff)
-	if err != nil {
-		return err
-	}
-	return binaryserializer.PutUint64(w, littleEndian, val)
+	var buf [9]byte
+	buf[0] = 0xff
+	littleEndian.PutUint64(buf[1:], val)
+	_, err := w.Write(buf[:])
+	return errors.WithStack(err)
 }
 
 // VarIntSerializeSize returns the number of bytes it would take to serialize

app/appmessage/common_test.go

@@ -2,23 +2,24 @@
 // 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"
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/pkg/errors"
+
 	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainnetGenesisHash = &daghash.Hash{
+var mainnetGenesisHash = &externalapi.DomainHash{
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
 	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
@@ -27,43 +28,43 @@ var mainnetGenesisHash = &daghash.Hash{
 
 // simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simnetGenesisHash = &daghash.Hash{
-	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a,
-	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
-	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
-	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
+var simnetGenesisHash = &externalapi.DomainHash{
+	0x9d, 0x89, 0xb0, 0x6e, 0xb3, 0x47, 0xb5, 0x6e,
+	0xcd, 0x6c, 0x63, 0x99, 0x45, 0x91, 0xd5, 0xce,
+	0x9b, 0x43, 0x05, 0xc1, 0xa5, 0x5e, 0x2a, 0xda,
+	0x90, 0x4c, 0xf0, 0x6c, 0x4d, 0x5f, 0xd3, 0x62,
 }
 
 // mainnetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
-var mainnetGenesisMerkleRoot = &daghash.Hash{
+var mainnetGenesisMerkleRoot = &externalapi.DomainHash{
 	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 }
 
-var exampleAcceptedIDMerkleRoot = &daghash.Hash{
+var exampleAcceptedIDMerkleRoot = &externalapi.DomainHash{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 }
 
-var exampleUTXOCommitment = &daghash.Hash{
+var exampleUTXOCommitment = &externalapi.DomainHash{
 	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	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) {
+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}},
@@ -104,7 +105,7 @@ func TestElementWire(t *testing.T) {
 			},
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
@@ -121,10 +122,6 @@ 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},
@@ -133,7 +130,7 @@ func TestElementWire(t *testing.T) {
 
 	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 {
@@ -146,7 +143,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 {
@@ -169,9 +166,9 @@ 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 {
@@ -197,7 +194,7 @@ func TestElementWireErrors(t *testing.T) {
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
@@ -206,7 +203,6 @@ 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},
@@ -214,7 +210,7 @@ func TestElementWireErrors(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 := WriteElement(w, test.in)
 		if !errors.Is(err, test.writeErr) {
@@ -223,7 +219,7 @@ func TestElementWireErrors(t *testing.T) {
 			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 {
@@ -238,11 +234,11 @@ 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 {
 		value uint64 // Value to encode
-		buf   []byte // Wire encoding
+		buf   []byte // Encoded value
 	}{
 		// Latest protocol version.
 		// Single byte
@@ -271,7 +267,7 @@ func TestVarIntWire(t *testing.T) {
 
 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		buf := &bytes.Buffer{}
 		err := WriteVarInt(buf, test.value)
 		if err != nil {
@@ -284,7 +280,7 @@ 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 {
@@ -299,12 +295,12 @@ func TestVarIntWire(t *testing.T) {
 	}
 }
 
-// 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
@@ -324,7 +320,7 @@ 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 !errors.Is(err, test.writeErr) {
@@ -333,7 +329,7 @@ func TestVarIntWireErrors(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarInt(r)
 		if !errors.Is(err, test.readErr) {
@@ -352,7 +348,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},
@@ -384,7 +380,7 @@ 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 msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
@@ -400,7 +396,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
@@ -435,8 +431,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.
@@ -445,8 +441,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
@@ -459,7 +455,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 {
@@ -472,7 +468,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 {
@@ -487,9 +483,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.
@@ -497,8 +493,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
@@ -514,7 +510,7 @@ 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 !errors.Is(err, test.writeErr) {
@@ -523,7 +519,7 @@ func TestVarStringWireErrors(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarString(r, test.pver)
 		if !errors.Is(err, test.readErr) {
@@ -542,8 +538,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},
@@ -554,7 +550,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) {
@@ -566,8 +562,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.
@@ -575,8 +571,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
@@ -589,7 +585,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 {
@@ -602,7 +598,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")
@@ -618,9 +614,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.
@@ -628,8 +624,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
@@ -645,7 +641,7 @@ 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 !errors.Is(err, test.writeErr) {
@@ -654,7 +650,7 @@ func TestVarBytesWireErrors(t *testing.T) {
 			continue
 		}
 
-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
 			"test payload")
@@ -674,8 +670,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},
@@ -686,7 +682,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
@@ -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.NewMsgRequestAddresses()
+	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/domainconverters.go

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

app/appmessage/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"
@@ -32,3 +32,16 @@ func (e *MessageError) Error() string {
 func messageError(f string, desc string) *MessageError {
 	return &MessageError{Func: f, Description: desc}
 }
+
+// RPCError represents an error arriving from the RPC
+type RPCError struct {
+	Message string
+}
+
+// RPCErrorf formats according to a format specifier and returns the string
+// as an RPCError.
+func RPCErrorf(format string, args ...interface{}) *RPCError {
+	return &RPCError{
+		Message: fmt.Sprintf(format, args...),
+	}
+}

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

app/appmessage/p2p_ibdrootnotfound.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgIBDRootNotFound implements the Message interface and represents a kaspa
+// IBDRootNotFound message. It is used to notify the IBD root that was requested
+// by other peer was not found.
+//
+// This message has no payload.
+type MsgIBDRootNotFound struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDRootNotFound) Command() MessageCommand {
+	return CmdIBDRootNotFound
+}
+
+// NewMsgIBDRootNotFound returns a new kaspa IBDRootNotFound message that conforms to the
+// Message interface.
+func NewMsgIBDRootNotFound() *MsgDoneHeaders {
+	return &MsgDoneHeaders{}
+}

app/appmessage/p2p_msgaddresses.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
+
+// 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.
+type MsgAddresses struct {
+	baseMessage
+	AddressList []*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(addressList []*NetAddress) *MsgAddresses {
+	return &MsgAddresses{
+		AddressList: addressList,
+	}
+}

app/appmessage/p2p_msgblock.go

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

app/appmessage/p2p_msgblock_test.go

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

app/appmessage/p2p_msgblockheader.go

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

app/appmessage/p2p_msgblockheader_test.go

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

app/appmessage/p2p_msgblocklocator.go

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

app/appmessage/p2p_msgblocklocator_test.go

@@ -1,21 +1,24 @@
-package wire
+package appmessage
 
 import (
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"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)
+	locatorHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	msg := NewMsgBlockLocator([]*daghash.Hash{locatorHash})
+	msg := NewMsgBlockLocator([]*externalapi.DomainHash{locatorHash})
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(10)

app/appmessage/p2p_msgdoneheaders.go

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

app/appmessage/p2p_msgibdblock.go

@@ -2,12 +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
 
 // 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
 }
 
@@ -26,5 +27,5 @@ func (msg *MsgIBDBlock) MaxPayloadLength(pver uint32) uint32 {
 // 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}
+	return &MsgIBDBlock{MsgBlock: msgBlock}
 }

app/appmessage/p2p_msgibdblock_test.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"
 	"reflect"
 	"testing"
 
@@ -64,55 +63,3 @@ func TestIBDBlock(t *testing.T) {
 			len(msg.Transactions), 0)
 	}
 }
-
-// TestIBDBlockWire tests the MsgIBDBlock wire encode and decode for various numbers
-// of transaction inputs and outputs and protocol versions.
-func TestIBDBlockWire(t *testing.T) {
-	tests := []struct {
-		in     *MsgIBDBlock // Message to encode
-		out    *MsgIBDBlock // Expected decoded message
-		buf    []byte       // Wire encoding
-		txLocs []TxLoc      // Expected transaction locations
-		pver   uint32       // Protocol version for wire encoding
-	}{
-		// Latest protocol version.
-		{
-			&MsgIBDBlock{&blockOne},
-			&MsgIBDBlock{&blockOne},
-			blockOneBytes,
-			blockOneTxLocs,
-			ProtocolVersion,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode the message to wire 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 wire 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/p2p_msgibdrootutxosetandblock.go

@@ -0,0 +1,23 @@
+package appmessage
+
+// MsgIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
+// IBDRootUTXOSetAndBlock message. It is used to answer RequestIBDRootUTXOSetAndBlock messages.
+type MsgIBDRootUTXOSetAndBlock struct {
+	baseMessage
+	UTXOSet []byte
+	Block   *MsgBlock
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDRootUTXOSetAndBlock) Command() MessageCommand {
+	return CmdIBDRootUTXOSetAndBlock
+}
+
+// NewMsgIBDRootUTXOSetAndBlock returns a new MsgIBDRootUTXOSetAndBlock.
+func NewMsgIBDRootUTXOSetAndBlock(utxoSet []byte, block *MsgBlock) *MsgIBDRootUTXOSetAndBlock {
+	return &MsgIBDRootUTXOSetAndBlock{
+		UTXOSet: utxoSet,
+		Block:   block,
+	}
+}

app/appmessage/p2p_msginvrelayblock.go

@@ -1,14 +1,15 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // 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 {
-	Hash *daghash.Hash
+	baseMessage
+	Hash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -19,7 +20,7 @@ func (msg *MsgInvRelayBlock) Command() MessageCommand {
 
 // NewMsgInvBlock returns a new kaspa invrelblk message that conforms to
 // the Message interface. See MsgInvRelayBlock for details.
-func NewMsgInvBlock(hash *daghash.Hash) *MsgInvRelayBlock {
+func NewMsgInvBlock(hash *externalapi.DomainHash) *MsgInvRelayBlock {
 	return &MsgInvRelayBlock{
 		Hash: hash,
 	}

app/appmessage/p2p_msginvtransaction.go

@@ -1,7 +1,7 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MaxInvPerTxInvMsg is the maximum number of hashes that can
@@ -12,7 +12,8 @@ const MaxInvPerTxInvMsg = MaxInvPerMsg
 // 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 {
-	TxIDs []*daghash.TxID
+	baseMessage
+	TxIDs []*externalapi.DomainTransactionID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,7 +24,7 @@ func (msg *MsgInvTransaction) Command() MessageCommand {
 
 // NewMsgInvTransaction returns a new kaspa TxInv message that conforms to
 // the Message interface. See MsgInvTransaction for details.
-func NewMsgInvTransaction(ids []*daghash.TxID) *MsgInvTransaction {
+func NewMsgInvTransaction(ids []*externalapi.DomainTransactionID) *MsgInvTransaction {
 	return &MsgInvTransaction{
 		TxIDs: ids,
 	}

app/appmessage/p2p_msgping.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
 
 // MsgPing implements the Message interface and represents a kaspa ping
 // message.
@@ -16,6 +16,7 @@ package wire
 // 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

app/appmessage/p2p_msgping_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"

app/appmessage/p2p_msgpong.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
 
 // MsgPong implements the Message interface and represents a kaspa pong
 // message which is used primarily to confirm that a connection is still valid
@@ -10,6 +10,7 @@ package wire
 //
 // 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

app/appmessage/p2p_msgpong_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"

app/appmessage/p2p_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/p2p_msgrequestaddresses.go

@@ -2,10 +2,10 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgRequestAddresses implements the Message interface and represents a kaspa
@@ -15,8 +15,9 @@ import (
 //
 // This message has no payload.
 type MsgRequestAddresses struct {
+	baseMessage
 	IncludeAllSubnetworks bool
-	SubnetworkID          *subnetworkid.SubnetworkID
+	SubnetworkID          *externalapi.DomainSubnetworkID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -27,7 +28,7 @@ func (msg *MsgRequestAddresses) Command() MessageCommand {
 
 // 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 {
+func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) *MsgRequestAddresses {
 	return &MsgRequestAddresses{
 		IncludeAllSubnetworks: includeAllSubnetworks,
 		SubnetworkID:          subnetworkID,

app/appmessage/p2p_msgrequestaddresses_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"

app/appmessage/p2p_msgrequestblocklocator.go

@@ -1,7 +1,7 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgRequestBlockLocator implements the Message interface and represents a kaspa
@@ -9,8 +9,9 @@ import (
 // and low hash.
 // The locator is returned via a locator message (MsgBlockLocator).
 type MsgRequestBlockLocator struct {
-	HighHash *daghash.Hash
-	LowHash  *daghash.Hash
+	baseMessage
+	HighHash *externalapi.DomainHash
+	LowHash  *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -22,7 +23,7 @@ func (msg *MsgRequestBlockLocator) Command() MessageCommand {
 // 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 {
+func NewMsgRequestBlockLocator(highHash, lowHash *externalapi.DomainHash) *MsgRequestBlockLocator {
 	return &MsgRequestBlockLocator{
 		HighHash: highHash,
 		LowHash:  lowHash,

app/appmessage/p2p_msgrequestblocklocator_test.go

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

app/appmessage/p2p_msgrequestheaders.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/domain/consensus/model/externalapi"
+)
+
+// MsgRequestHeaders implements the Message interface and represents a kaspa
+// RequestHeaders message. It is used to request a list of blocks starting after the
+// low hash and until the high hash.
+type MsgRequestHeaders struct {
+	baseMessage
+	LowHash  *externalapi.DomainHash
+	HighHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestHeaders) Command() MessageCommand {
+	return CmdRequestHeaders
+}
+
+// NewMsgRequstHeaders returns a new kaspa RequestHeaders message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequstHeaders(lowHash, highHash *externalapi.DomainHash) *MsgRequestHeaders {
+	return &MsgRequestHeaders{
+		LowHash:  lowHash,
+		HighHash: highHash,
+	}
+}

app/appmessage/p2p_msgrequestheaders_test.go

@@ -2,39 +2,39 @@
 // 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"
 
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
-// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
+// TestRequstIBDBlocks tests the MsgRequestHeaders API.
 func TestRequstIBDBlocks(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	lowHash, err := daghash.NewHashFromStr(hashStr)
+	lowHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	hashStr = "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	highHash, err := daghash.NewHashFromStr(hashStr)
+	hashStr = "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	highHash, err := hashes.FromString(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 := NewMsgRequstHeaders(lowHash, highHash)
+	if *msg.HighHash != *highHash {
+		t.Errorf("NewMsgRequstHeaders: 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",
+		t.Errorf("NewMsgRequstHeaders: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}
 }

app/appmessage/p2p_msgrequestibdblocks.go

@@ -0,0 +1,30 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MaxRequestIBDBlocksHashes is the maximum number of hashes that can
+// be in a single RequestIBDBlocks message.
+const MaxRequestIBDBlocksHashes = MaxInvPerMsg
+
+// MsgRequestIBDBlocks implements the Message interface and represents a kaspa
+// RequestIBDBlocks message. It is used to request blocks as part of the IBD
+// protocol.
+type MsgRequestIBDBlocks struct {
+	baseMessage
+	Hashes []*externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDBlocks) Command() MessageCommand {
+	return CmdRequestIBDBlocks
+}
+
+// NewMsgRequestIBDBlocks returns a new MsgRequestIBDBlocks.
+func NewMsgRequestIBDBlocks(hashes []*externalapi.DomainHash) *MsgRequestIBDBlocks {
+	return &MsgRequestIBDBlocks{
+		Hashes: hashes,
+	}
+}

app/appmessage/p2p_msgrequestibdrootutxosetandblock.go

@@ -0,0 +1,26 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgRequestIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
+// RequestIBDRootUTXOSetAndBlock message. It is used to request the UTXO set and block body
+// of the IBD root block.
+type MsgRequestIBDRootUTXOSetAndBlock struct {
+	baseMessage
+	IBDRoot *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDRootUTXOSetAndBlock) Command() MessageCommand {
+	return CmdRequestIBDRootUTXOSetAndBlock
+}
+
+// NewMsgRequestIBDRootUTXOSetAndBlock returns a new MsgRequestIBDRootUTXOSetAndBlock.
+func NewMsgRequestIBDRootUTXOSetAndBlock(ibdRoot *externalapi.DomainHash) *MsgRequestIBDRootUTXOSetAndBlock {
+	return &MsgRequestIBDRootUTXOSetAndBlock{
+		IBDRoot: ibdRoot,
+	}
+}

app/appmessage/p2p_msgrequestnextheaders.go

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

app/appmessage/p2p_msgrequestrelayblocks.go

@@ -1,18 +1,19 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
-// MsgRequestRelayBlocksHashes is the maximum number of hashes that can
+// MaxRequestRelayBlocksHashes is the maximum number of hashes that can
 // be in a single RequestRelayBlocks message.
-const MsgRequestRelayBlocksHashes = MaxInvPerMsg
+const MaxRequestRelayBlocksHashes = 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 {
-	Hashes []*daghash.Hash
+	baseMessage
+	Hashes []*externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,7 +24,7 @@ func (msg *MsgRequestRelayBlocks) Command() MessageCommand {
 
 // NewMsgRequestRelayBlocks returns a new kaspa RequestRelayBlocks message that conforms to
 // the Message interface. See MsgRequestRelayBlocks for details.
-func NewMsgRequestRelayBlocks(hashes []*daghash.Hash) *MsgRequestRelayBlocks {
+func NewMsgRequestRelayBlocks(hashes []*externalapi.DomainHash) *MsgRequestRelayBlocks {
 	return &MsgRequestRelayBlocks{
 		Hashes: hashes,
 	}

app/appmessage/p2p_msgrequestselectedtip.go

@@ -1,10 +1,12 @@
-package wire
+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{}
+type MsgRequestSelectedTip struct {
+	baseMessage
+}
 
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.

app/appmessage/p2p_msgrequestselectedtip_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"

app/appmessage/p2p_msgrequesttransactions.go

@@ -1,7 +1,7 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MaxInvPerRequestTransactionsMsg is the maximum number of hashes that can
@@ -12,7 +12,8 @@ const MaxInvPerRequestTransactionsMsg = MaxInvPerMsg
 // RequestTransactions message. It is used to request transactions as part of the
 // transactions relay protocol.
 type MsgRequestTransactions struct {
-	IDs []*daghash.TxID
+	baseMessage
+	IDs []*externalapi.DomainTransactionID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,7 +24,7 @@ func (msg *MsgRequestTransactions) Command() MessageCommand {
 
 // NewMsgRequestTransactions returns a new kaspa RequestTransactions message that conforms to
 // the Message interface. See MsgRequestTransactions for details.
-func NewMsgRequestTransactions(ids []*daghash.TxID) *MsgRequestTransactions {
+func NewMsgRequestTransactions(ids []*externalapi.DomainTransactionID) *MsgRequestTransactions {
 	return &MsgRequestTransactions{
 		IDs: ids,
 	}

app/appmessage/p2p_msgselectedtip.go

@@ -1,15 +1,16 @@
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // 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
+	SelectedTipHash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -20,7 +21,7 @@ func (msg *MsgSelectedTip) Command() MessageCommand {
 
 // NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
 // Message interface.
-func NewMsgSelectedTip(selectedTipHash *daghash.Hash) *MsgSelectedTip {
+func NewMsgSelectedTip(selectedTipHash *externalapi.DomainHash) *MsgSelectedTip {
 	return &MsgSelectedTip{
 		SelectedTipHash: selectedTipHash,
 	}

app/appmessage/p2p_msgselectedtip_test.go

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

app/appmessage/p2p_msgtransactionnotfound.go

@@ -2,16 +2,17 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
+package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // 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 {
-	ID *daghash.TxID
+	baseMessage
+	ID *externalapi.DomainTransactionID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -22,7 +23,7 @@ func (msg *MsgTransactionNotFound) Command() MessageCommand {
 
 // NewMsgTransactionNotFound returns a new kaspa transactionsnotfound message that conforms to the
 // Message interface. See MsgTransactionNotFound for details.
-func NewMsgTransactionNotFound(id *daghash.TxID) *MsgTransactionNotFound {
+func NewMsgTransactionNotFound(id *externalapi.DomainTransactionID) *MsgTransactionNotFound {
 	return &MsgTransactionNotFound{
 		ID: id,
 	}

app/appmessage/p2p_msgtx.go

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

app/appmessage/p2p_msgtx_test.go

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

app/appmessage/p2p_msgverack.go

@@ -2,14 +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
 
 // 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{}
+type MsgVerAck struct {
+	baseMessage
+}
 
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.

app/appmessage/p2p_msgverack_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"

app/appmessage/p2p_msgversion.go

@@ -2,25 +2,24 @@
 // 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"
 	"strings"
 
-	"github.com/kaspanet/kaspad/netadapter/id"
-	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/version"
 
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 // MaxUserAgentLen is the maximum allowed length for the user agent field in a
 // version message (MsgVersion).
 const MaxUserAgentLen = 256
 
-// DefaultUserAgent for wire in the stack
+// DefaultUserAgent for appmessage in the stack
 var DefaultUserAgent = fmt.Sprintf("/kaspad:%s/", version.Version())
 
 // MsgVersion implements the Message interface and represents a kaspa version
@@ -31,13 +30,17 @@ var DefaultUserAgent = fmt.Sprintf("/kaspad:%s/", version.Version())
 // 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 wire.
+	// Time the message was generated. This is encoded as an int64 on the appmessage.
 	Timestamp mstime.Time
 
 	// Address of the local peer.
@@ -47,17 +50,17 @@ type MsgVersion struct {
 	ID *id.ID
 
 	// The user agent that generated messsage. This is a encoded as a varString
-	// on the wire. This has a max length of MaxUserAgentLen.
+	// 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
+	SelectedTipHash *externalapi.DomainHash
 
 	// 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
+	SubnetworkID *externalapi.DomainSubnetworkID
 }
 
 // HasService returns whether the specified service is supported by the peer
@@ -81,13 +84,14 @@ func (msg *MsgVersion) Command() MessageCommand {
 // 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,
-	selectedTipHash *daghash.Hash, subnetworkID *subnetworkid.SubnetworkID) *MsgVersion {
+func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
+	selectedTipHash *externalapi.DomainHash, subnetworkID *externalapi.DomainSubnetworkID) *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,

app/appmessage/p2p_msgversion_test.go

@@ -2,15 +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 (
-	"github.com/davecgh/go-spew/spew"
-	id "github.com/kaspanet/kaspad/netadapter/id"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"net"
 	"reflect"
 	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
 // TestVersion tests the MsgVersion API.
@@ -18,7 +19,7 @@ func TestVersion(t *testing.T) {
 	pver := ProtocolVersion
 
 	// Create version message data.
-	selectedTipHash := &daghash.Hash{12, 34}
+	selectedTipHash := &externalapi.DomainHash{12, 34}
 	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
 	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
 	generatedID, err := id.GenerateID()
@@ -27,7 +28,7 @@ func TestVersion(t *testing.T) {
 	}
 
 	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, selectedTipHash, nil)
+	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
 	if msg.ProtocolVersion != pver {
 		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
 			msg.ProtocolVersion, pver)
@@ -44,7 +45,7 @@ func TestVersion(t *testing.T) {
 		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
 			msg.UserAgent, DefaultUserAgent)
 	}
-	if !msg.SelectedTipHash.IsEqual(selectedTipHash) {
+	if *msg.SelectedTipHash != *selectedTipHash {
 		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
 			msg.SelectedTipHash, selectedTipHash)
 	}

app/appmessage/p2p_netaddress.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 (
 	"github.com/kaspanet/kaspad/util/mstime"
@@ -21,7 +21,7 @@ type NetAddress struct {
 	// IP address of the peer.
 	IP net.IP
 
-	// Port the peer is using. This is encoded in big endian on the wire
+	// Port the peer is using. This is encoded in big endian on the appmessage
 	// which differs from most everything else.
 	Port uint16
 }

app/appmessage/p2p_netaddress_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 (
 	"net"

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/appmessage/rpc_add_peer.go

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

app/appmessage/rpc_get_block.go

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

app/appmessage/rpc_get_block_count.go

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

app/appmessage/rpc_get_block_dag_info.go

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

app/appmessage/rpc_get_block_template.go

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

app/appmessage/rpc_get_blocks.go

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

app/appmessage/rpc_get_chain_from_block.go

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

app/appmessage/rpc_get_connected_peer_info.go

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

app/appmessage/rpc_get_current_network.go

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

app/appmessage/rpc_get_headers.go

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

app/appmessage/rpc_get_mempool_entries.go

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

app/appmessage/rpc_get_mempool_entry.go

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

app/appmessage/rpc_get_peer_addresses.go

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

app/appmessage/rpc_get_selected_tip_hash.go

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

app/appmessage/rpc_get_subnetwork.go

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

app/appmessage/rpc_notify_block_added.go

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

app/appmessage/rpc_notify_chain_changed.go

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

app/appmessage/rpc_notify_finality_conflicts.go

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

app/appmessage/rpc_resolve_finality_conflict.go

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

app/appmessage/rpc_shut_down.go

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

app/appmessage/rpc_submit_block.go

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

app/appmessage/rpc_submit_transaction.go

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

app/component_manager.go

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

app/log.go

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

app/protocol/blocklogger/blocklogger.go

@@ -5,11 +5,11 @@
 package blocklogger
 
 import (
-	"github.com/kaspanet/kaspad/util/mstime"
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 var (
@@ -22,17 +22,17 @@ var (
 // 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 {
+func LogBlock(block *externalapi.DomainBlock) {
 	mtx.Lock()
 	defer mtx.Unlock()
 
 	receivedLogBlocks++
-	receivedLogTx += int64(len(block.MsgBlock().Transactions))
+	receivedLogTx += int64(len(block.Transactions))
 
 	now := mstime.Now()
 	duration := now.Sub(lastBlockLogTime)
 	if duration < time.Second*10 {
-		return nil
+		return
 	}
 
 	// Truncate the duration to 10s of milliseconds.
@@ -48,17 +48,11 @@ func LogBlock(block *util.Block) error {
 		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)",
+	log.Infof("Processed %d %s in the last %s (%d %s, %s)",
 		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
-		txStr, blueScore, block.MsgBlock().Header.Timestamp)
+		txStr, mstime.UnixMilliseconds(block.Header.TimeInMilliseconds))
 
 	receivedLogBlocks = 0
 	receivedLogTx = 0
 	lastBlockLogTime = now
-	return nil
 }

app/protocol/blocklogger/log.go

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

app/protocol/flowcontext/addresses.go

@@ -1,7 +1,7 @@
 package flowcontext
 
 import (
-	"github.com/kaspanet/kaspad/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 )
 
 // AddressManager returns the address manager associated to the flow context.

app/protocol/flowcontext/blocks.go

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

app/protocol/flowcontext/config.go

@@ -1,6 +1,6 @@
 package flowcontext
 
-import "github.com/kaspanet/kaspad/config"
+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 {

app/protocol/flowcontext/domain.go

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

app/protocol/flowcontext/errors.go

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

app/protocol/flowcontext/ibd.go

@@ -0,0 +1,130 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"sync/atomic"
+	"time"
+
+	"github.com/kaspanet/kaspad/util/mstime"
+
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+)
+
+// StartIBDIfRequired selects a peer and starts IBD against it
+// if required
+func (f *FlowContext) StartIBDIfRequired() error {
+	f.startIBDMutex.Lock()
+	defer f.startIBDMutex.Unlock()
+
+	if f.IsInIBD() {
+		return nil
+	}
+
+	syncInfo, err := f.domain.Consensus().GetSyncInfo()
+	if err != nil {
+		return err
+	}
+
+	if syncInfo.State == externalapi.SyncStateRelay {
+		return nil
+	}
+
+	peer, err := f.selectPeerForIBD(syncInfo)
+	if err != nil {
+		return err
+	}
+	if peer == nil {
+		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
+		return nil
+	}
+
+	atomic.StoreUint32(&f.isInIBD, 1)
+	f.ibdPeer = peer
+	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+
+	return nil
+}
+
+// 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(syncInfo *externalapi.SyncInfo) (*peerpkg.Peer, error) {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peerSelectedTipHash := peer.SelectedTipHash()
+
+		if f.IsOrphan(peerSelectedTipHash) {
+			continue
+		}
+
+		blockInfo, err := f.domain.Consensus().GetBlockInfo(peerSelectedTipHash)
+		if err != nil {
+			return nil, err
+		}
+		if syncInfo.State == externalapi.SyncStateHeadersFirst {
+			if !blockInfo.Exists {
+				return peer, nil
+			}
+		} else {
+			if blockInfo.Exists && blockInfo.BlockStatus == externalapi.StatusHeaderOnly &&
+				blockInfo.IsBlockInHeaderPruningPointFuture {
+				return peer, nil
+			}
+		}
+	}
+	return nil, nil
+}
+
+func (f *FlowContext) requestSelectedTipsIfRequired() {
+	dagTimeCurrent, err := f.shouldRequestSelectedTips()
+	if err != nil {
+		panic(err)
+	}
+	if dagTimeCurrent {
+		return
+	}
+	f.requestSelectedTips()
+}
+
+func (f *FlowContext) shouldRequestSelectedTips() (bool, error) {
+	const minDurationToRequestSelectedTips = time.Minute
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+	virtualSelectedParentTime := mstime.UnixMilliseconds(virtualSelectedParent.Header.TimeInMilliseconds)
+	return mstime.Now().Sub(virtualSelectedParentTime) > minDurationToRequestSelectedTips, nil
+}
+
+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() error {
+	f.ibdPeer = nil
+
+	atomic.StoreUint32(&f.isInIBD, 0)
+
+	return 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

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

app/protocol/flowcontext/network.go

@@ -1,11 +1,11 @@
 package flowcontext
 
 import (
-	"github.com/kaspanet/kaspad/connmanager"
-	"github.com/kaspanet/kaspad/netadapter"
-	"github.com/kaspanet/kaspad/protocol/common"
-	peerpkg "github.com/kaspanet/kaspad/protocol/peer"
-	"github.com/kaspanet/kaspad/wire"
+	"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"
 )
 
@@ -24,15 +24,23 @@ func (f *FlowContext) AddToPeers(peer *peerpkg.Peer) error {
 	f.peersMutex.Lock()
 	defer f.peersMutex.Unlock()
 
-	if _, ok := f.peers[peer.ID()]; ok {
+	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
+	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()
@@ -47,8 +55,8 @@ func (f *FlowContext) readyPeerConnections() []*netadapter.NetConnection {
 }
 
 // Broadcast broadcast the given message to all the ready peers.
-func (f *FlowContext) Broadcast(message wire.Message) error {
-	return f.netAdapter.Broadcast(f.readyPeerConnections(), message)
+func (f *FlowContext) Broadcast(message appmessage.Message) error {
+	return f.netAdapter.P2PBroadcast(f.readyPeerConnections(), message)
 }
 
 // Peers returns the currently active peers

app/protocol/flowcontext/orphans.go

@@ -0,0 +1,130 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/pkg/errors"
+)
+
+// AddOrphan adds the block to the orphan set
+func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
+	f.orphansMutex.Lock()
+	defer f.orphansMutex.Unlock()
+
+	orphanHash := consensusserialization.BlockHash(orphanBlock)
+	f.orphans[*orphanHash] = orphanBlock
+
+	log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
+}
+
+// IsOrphan returns whether the given blockHash belongs to an orphan block
+func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
+	f.orphansMutex.RLock()
+	defer f.orphansMutex.RUnlock()
+
+	_, ok := f.orphans[*blockHash]
+	return ok
+}
+
+// UnorphanBlocks removes the block from the orphan set, and remove all of the blocks that are not orphans anymore.
+func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
+	f.orphansMutex.Lock()
+	defer f.orphansMutex.Unlock()
+
+	// Find all the children of rootBlock among the orphans
+	// and add them to the process queue
+	rootBlockHash := consensusserialization.BlockHash(rootBlock)
+	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
+
+	var unorphanedBlocks []*externalapi.DomainBlock
+	for len(processQueue) > 0 {
+		var orphanHash externalapi.DomainHash
+		orphanHash, processQueue = processQueue[0], processQueue[1:]
+		orphanBlock := f.orphans[orphanHash]
+
+		log.Tracef("Considering to unorphan block %s with parents %s",
+			orphanHash, orphanBlock.Header.ParentHashes)
+
+		canBeUnorphaned := true
+		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
+			orphanBlockParentInfo, err := f.domain.Consensus().GetBlockInfo(orphanBlockParentHash)
+			if err != nil {
+				return nil, err
+			}
+			if !orphanBlockParentInfo.Exists {
+				log.Tracef("Cannot unorphan block %s. It's missing at "+
+					"least the following parent: %s", orphanHash, orphanBlockParentHash)
+
+				canBeUnorphaned = false
+				break
+			}
+		}
+		if canBeUnorphaned {
+			err := f.unorphanBlock(orphanHash)
+			if err != nil {
+				return nil, err
+			}
+			unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
+			processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
+		}
+	}
+
+	return unorphanedBlocks, nil
+}
+
+// addChildOrphansToProcessQueue finds all child orphans of `blockHash`
+// and adds them to the given `processQueue` if they don't already exist
+// inside of it
+// Note that this method does not modify the given `processQueue`
+func (f *FlowContext) addChildOrphansToProcessQueue(blockHash *externalapi.DomainHash,
+	processQueue []externalapi.DomainHash) []externalapi.DomainHash {
+
+	blockChildren := f.findChildOrphansOfBlock(blockHash)
+	for _, blockChild := range blockChildren {
+		exists := false
+		for _, queueOrphan := range processQueue {
+			if queueOrphan == blockChild {
+				exists = true
+				break
+			}
+		}
+		if !exists {
+			processQueue = append(processQueue, blockChild)
+		}
+	}
+	return processQueue
+}
+
+func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash) []externalapi.DomainHash {
+	var childOrphans []externalapi.DomainHash
+	for orphanHash, orphanBlock := range f.orphans {
+		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
+			if *orphanBlockParentHash == *blockHash {
+				childOrphans = append(childOrphans, orphanHash)
+				break
+			}
+		}
+	}
+	return childOrphans
+}
+
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) error {
+	orphanBlock, ok := f.orphans[orphanHash]
+	if !ok {
+		return errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+	}
+	delete(f.orphans, orphanHash)
+
+	err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
+	if err != nil {
+		if errors.As(err, &ruleerrors.RuleError{}) {
+			log.Infof("Validation failed for orphan block %s: %s", orphanHash, err)
+			return nil
+		}
+		return err
+	}
+
+	log.Infof("Unorphaned block %s", orphanHash)
+	return nil
+}

app/protocol/flowcontext/transactions.go

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