[NOD-1064] Don't send GetBlockInvsMsg with lowHash = nil (#769)

README.md

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

addrmgr/addrmanager_test.go

@@ -0,0 +1,674 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package addrmgr
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"net"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+
+	"github.com/kaspanet/kaspad/wire"
+)
+
+// naTest is used to describe a test to be performed against the NetAddressKey
+// method.
+type naTest struct {
+	in   wire.NetAddress
+	want string
+}
+
+// naTests houses all of the tests to be performed against the NetAddressKey
+// method.
+var naTests = make([]naTest, 0)
+
+// Put some IP in here for convenience. Points to google.
+var someIP = "173.194.115.66"
+
+// addNaTests
+func addNaTests() {
+	// IPv4
+	// Localhost
+	addNaTest("127.0.0.1", 16111, "127.0.0.1:16111")
+	addNaTest("127.0.0.1", 16110, "127.0.0.1:16110")
+
+	// Class A
+	addNaTest("1.0.0.1", 16111, "1.0.0.1:16111")
+	addNaTest("2.2.2.2", 16110, "2.2.2.2:16110")
+	addNaTest("27.253.252.251", 8335, "27.253.252.251:8335")
+	addNaTest("123.3.2.1", 8336, "123.3.2.1:8336")
+
+	// Private Class A
+	addNaTest("10.0.0.1", 16111, "10.0.0.1:16111")
+	addNaTest("10.1.1.1", 16110, "10.1.1.1:16110")
+	addNaTest("10.2.2.2", 8335, "10.2.2.2:8335")
+	addNaTest("10.10.10.10", 8336, "10.10.10.10:8336")
+
+	// Class B
+	addNaTest("128.0.0.1", 16111, "128.0.0.1:16111")
+	addNaTest("129.1.1.1", 16110, "129.1.1.1:16110")
+	addNaTest("180.2.2.2", 8335, "180.2.2.2:8335")
+	addNaTest("191.10.10.10", 8336, "191.10.10.10:8336")
+
+	// Private Class B
+	addNaTest("172.16.0.1", 16111, "172.16.0.1:16111")
+	addNaTest("172.16.1.1", 16110, "172.16.1.1:16110")
+	addNaTest("172.16.2.2", 8335, "172.16.2.2:8335")
+	addNaTest("172.16.172.172", 8336, "172.16.172.172:8336")
+
+	// Class C
+	addNaTest("193.0.0.1", 16111, "193.0.0.1:16111")
+	addNaTest("200.1.1.1", 16110, "200.1.1.1:16110")
+	addNaTest("205.2.2.2", 8335, "205.2.2.2:8335")
+	addNaTest("223.10.10.10", 8336, "223.10.10.10:8336")
+
+	// Private Class C
+	addNaTest("192.168.0.1", 16111, "192.168.0.1:16111")
+	addNaTest("192.168.1.1", 16110, "192.168.1.1:16110")
+	addNaTest("192.168.2.2", 8335, "192.168.2.2:8335")
+	addNaTest("192.168.192.192", 8336, "192.168.192.192:8336")
+
+	// IPv6
+	// Localhost
+	addNaTest("::1", 16111, "[::1]:16111")
+	addNaTest("fe80::1", 16110, "[fe80::1]:16110")
+
+	// Link-local
+	addNaTest("fe80::1:1", 16111, "[fe80::1:1]:16111")
+	addNaTest("fe91::2:2", 16110, "[fe91::2:2]:16110")
+	addNaTest("fea2::3:3", 8335, "[fea2::3:3]:8335")
+	addNaTest("feb3::4:4", 8336, "[feb3::4:4]:8336")
+
+	// Site-local
+	addNaTest("fec0::1:1", 16111, "[fec0::1:1]:16111")
+	addNaTest("fed1::2:2", 16110, "[fed1::2:2]:16110")
+	addNaTest("fee2::3:3", 8335, "[fee2::3:3]:8335")
+	addNaTest("fef3::4:4", 8336, "[fef3::4:4]:8336")
+}
+
+func addNaTest(ip string, port uint16, want string) {
+	nip := net.ParseIP(ip)
+	na := *wire.NewNetAddressIPPort(nip, port, wire.SFNodeNetwork)
+	test := naTest{na, want}
+	naTests = append(naTests, test)
+}
+
+func lookupFunc(host string) ([]net.IP, error) {
+	return nil, errors.New("not implemented")
+}
+
+func TestStartStop(t *testing.T) {
+	n := New("teststartstop", lookupFunc, nil)
+	n.Start()
+	err := n.Stop()
+	if err != nil {
+		t.Fatalf("Address Manager failed to stop: %v", err)
+	}
+}
+
+func TestAddAddressByIP(t *testing.T) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	fmtErr := errors.Errorf("")
+	addrErr := &net.AddrError{}
+	var tests = []struct {
+		addrIP string
+		err    error
+	}{
+		{
+			someIP + ":16111",
+			nil,
+		},
+		{
+			someIP,
+			addrErr,
+		},
+		{
+			someIP[:12] + ":8333",
+			fmtErr,
+		},
+		{
+			someIP + ":abcd",
+			fmtErr,
+		},
+	}
+
+	amgr := New("testaddressbyip", nil, nil)
+	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) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	var tests = []struct {
+		address  wire.NetAddress
+		priority AddressPriority
+		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 := New("testaddlocaladdress", nil, nil)
+	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) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	n := New("testattempt", lookupFunc, nil)
+
+	// Add a new address and get it
+	err := n.AddAddressByIP(someIP+":8333", nil)
+	if err != nil {
+		t.Fatalf("Adding address failed: %v", err)
+	}
+	ka := n.GetAddress()
+
+	if !ka.LastAttempt().IsZero() {
+		t.Errorf("Address should not have attempts, but does")
+	}
+
+	na := ka.NetAddress()
+	n.Attempt(na)
+
+	if ka.LastAttempt().IsZero() {
+		t.Errorf("Address should have an attempt, but does not")
+	}
+}
+
+func TestConnected(t *testing.T) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	n := New("testconnected", lookupFunc, nil)
+
+	// Add a new address and get it
+	err := n.AddAddressByIP(someIP+":8333", nil)
+	if err != nil {
+		t.Fatalf("Adding address failed: %v", err)
+	}
+	ka := n.GetAddress()
+	na := ka.NetAddress()
+	// make it an hour ago
+	na.Timestamp = time.Unix(time.Now().Add(time.Hour*-1).Unix(), 0)
+
+	n.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) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	n := New("testneedmoreaddresses", lookupFunc, nil)
+	addrsToAdd := 1500
+	b := n.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 := fmt.Sprintf("%d.%d.173.147:8333", i/128+60, i%128+60)
+		addrs[i], err = n.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)
+
+	n.AddAddresses(addrs, srcAddr, nil)
+	numAddrs := n.TotalNumAddresses()
+	if numAddrs > addrsToAdd {
+		t.Errorf("Number of addresses is too many %d vs %d", numAddrs, addrsToAdd)
+	}
+
+	b = n.NeedMoreAddresses()
+	if b {
+		t.Errorf("Expected that we don't need more addresses")
+	}
+}
+
+func TestGood(t *testing.T) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	n := New("testgood", lookupFunc, nil)
+	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 := fmt.Sprintf("%d.173.147.%d:8333", i/64+60, i%64+60)
+		addrs[i], err = n.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)
+
+	n.AddAddresses(addrs, srcAddr, nil)
+	for i, addr := range addrs {
+		n.Good(addr, subnetworkIDs[i%subnetworkCount])
+	}
+
+	numAddrs := n.TotalNumAddresses()
+	if numAddrs >= addrsToAdd {
+		t.Errorf("Number of addresses is too many: %d vs %d", numAddrs, addrsToAdd)
+	}
+
+	numCache := len(n.AddressCache(true, nil))
+	if numCache == 0 || numCache >= numAddrs/4 {
+		t.Errorf("Number of addresses in cache: got %d, want positive and less than %d",
+			numCache, numAddrs/4)
+	}
+
+	for i := 0; i < subnetworkCount; i++ {
+		numCache = len(n.AddressCache(false, subnetworkIDs[i]))
+		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) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	n := New("test_good_change_subnetwork_id", lookupFunc, nil)
+	addr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+	addrKey := NetAddressKey(addr)
+	srcAddr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
+
+	oldSubnetwork := subnetworkid.SubnetworkIDNative
+	n.AddAddress(addr, srcAddr, oldSubnetwork)
+	n.Good(addr, oldSubnetwork)
+
+	// make sure address was saved to addrIndex under oldSubnetwork
+	ka := n.find(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 := n.addrTried[*oldSubnetwork][n.getTriedBucket(addr)]
+	wasFound := false
+	for e := bucket.Front(); e != nil; e = e.Next() {
+		if NetAddressKey(e.Value.(*KnownAddress).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
+	n.Good(addr, newSubnetwork)
+
+	// make sure address was updated in addrIndex under newSubnetwork
+	ka = n.find(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 = n.addrTried[*oldSubnetwork][n.getTriedBucket(addr)]
+	wasFound = false
+	for e := bucket.Front(); e != nil; e = e.Next() {
+		if NetAddressKey(e.Value.(*KnownAddress).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 = n.addrTried[*newSubnetwork][n.getTriedBucket(addr)]
+	wasFound = false
+	for e := bucket.Front(); e != nil; e = e.Next() {
+		if NetAddressKey(e.Value.(*KnownAddress).NetAddress()) == addrKey {
+			wasFound = true
+		}
+	}
+	if !wasFound {
+		t.Fatalf("Address was not found in the correct bucket in newSubnetwork")
+	}
+}
+
+func TestGetAddress(t *testing.T) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	localSubnetworkID := &subnetworkid.SubnetworkID{0xff}
+	n := New("testgetaddress", lookupFunc, localSubnetworkID)
+
+	// Get an address from an empty set (should error)
+	if rv := n.GetAddress(); rv != nil {
+		t.Errorf("GetAddress failed: got: %v want: %v\n", rv, nil)
+	}
+
+	// Add a new address and get it
+	err := n.AddAddressByIP(someIP+":8332", localSubnetworkID)
+	if err != nil {
+		t.Fatalf("Adding address failed: %v", err)
+	}
+	ka := n.GetAddress()
+	if ka == nil {
+		t.Fatalf("Did not get an address where there is one in the pool")
+	}
+	n.Attempt(ka.NetAddress())
+
+	// Checks that we don't get it if we find that it has other subnetwork ID than expected.
+	actualSubnetworkID := &subnetworkid.SubnetworkID{0xfe}
+	n.Good(ka.NetAddress(), actualSubnetworkID)
+	ka = n.GetAddress()
+	if ka != nil {
+		t.Errorf("Didn't expect to get an address because there shouldn't be any address from subnetwork ID %s or nil", localSubnetworkID)
+	}
+
+	// Checks that the total number of addresses incremented although the new address is not full node or a partial node of the same subnetwork as the local node.
+	numAddrs := n.TotalNumAddresses()
+	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 = n.AddAddressByIP(someIP+":8333", localSubnetworkID)
+	if err != nil {
+		t.Fatalf("Adding address failed: %v", err)
+	}
+	ka = n.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)
+	}
+	n.Attempt(ka.NetAddress())
+
+	// Mark this as a good address and get it
+	n.Good(ka.NetAddress(), localSubnetworkID)
+	ka = n.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 = n.TotalNumAddresses()
+	if numAddrs != 2 {
+		t.Errorf("Wrong number of addresses: got %d, want %d", numAddrs, 1)
+	}
+}
+
+func TestGetBestLocalAddress(t *testing.T) {
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
+	})
+	defer config.SetActiveConfig(originalActiveCfg)
+
+	localAddrs := []wire.NetAddress{
+		{IP: net.ParseIP("192.168.0.100")},
+		{IP: net.ParseIP("::1")},
+		{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 := New("testgetbestlocaladdress", nil, nil)
+
+	// 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
+		}
+	}
+
+}

addrmgr/doc.go

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

addrmgr/internal_test.go

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

addrmgr/knownaddress.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package addrmgr
+
+import (
+	"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 {
+	na           *wire.NetAddress
+	srcAddr      *wire.NetAddress
+	attempts     int
+	lastattempt  time.Time
+	lastsuccess  time.Time
+	tried        bool
+	refs         int // reference count of new buckets
+	subnetworkID *subnetworkid.SubnetworkID
+}
+
+// NetAddress returns the underlying wire.NetAddress associated with the
+// known address.
+func (ka *KnownAddress) NetAddress() *wire.NetAddress {
+	return ka.na
+}
+
+// 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() time.Time {
+	return ka.lastattempt
+}
+
+// chance returns the selection probability for a known address. The priority
+// depends upon how recently the address has been seen, how recently it was last
+// attempted and how often attempts to connect to it have failed.
+func (ka *KnownAddress) chance() float64 {
+	now := time.Now()
+	lastAttempt := now.Sub(ka.lastattempt)
+
+	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(time.Now().Add(-1 * time.Minute)) {
+		return false
+	}
+
+	// From the future?
+	if ka.na.Timestamp.After(time.Now().Add(10 * time.Minute)) {
+		return true
+	}
+
+	// Over a month old?
+	if ka.na.Timestamp.Before(time.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(time.Now().Add(-1*minBadDays*time.Hour*24)) &&
+		ka.attempts >= maxFailures {
+		return true
+	}
+
+	return false
+}

addrmgr/knownaddress_test.go

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

addrmgr/log.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 addressmanager
+package addrmgr
 
 import (
-	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/logger"
 	"github.com/kaspanet/kaspad/util/panics"
 )
 

addrmgr/network.go

@@ -2,12 +2,14 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package addressmanager
+package addrmgr
 
 import (
 	"net"
 
-	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/config"
+
+	"github.com/kaspanet/kaspad/wire"
 )
 
 var (
@@ -78,13 +80,6 @@ var (
 	heNet = ipNet("2001:470::", 32, 128)
 )
 
-const (
-	// GetAddressesMax is the most addresses that we will send in response
-	// to a getAddress (in practise the most addresses we will return from a
-	// call to AddressCache()).
-	GetAddressesMax = 2500
-)
-
 // ipNet returns a net.IPNet struct given the passed IP address string, number
 // of one bits to include at the start of the mask, and the total number of bits
 // for the mask.
@@ -93,19 +88,19 @@ func ipNet(ip string, ones, bits int) net.IPNet {
 }
 
 // IsIPv4 returns whether or not the given address is an IPv4 address.
-func IsIPv4(na *appmessage.NetAddress) bool {
+func IsIPv4(na *wire.NetAddress) bool {
 	return na.IP.To4() != nil
 }
 
 // IsLocal returns whether or not the given address is a local address.
-func IsLocal(na *appmessage.NetAddress) bool {
+func IsLocal(na *wire.NetAddress) bool {
 	return na.IP.IsLoopback() || zero4Net.Contains(na.IP)
 }
 
 // IsRFC1918 returns whether or not the passed address is part of the IPv4
 // private network address space as defined by RFC1918 (10.0.0.0/8,
 // 172.16.0.0/12, or 192.168.0.0/16).
-func IsRFC1918(na *appmessage.NetAddress) bool {
+func IsRFC1918(na *wire.NetAddress) bool {
 	for _, rfc := range rfc1918Nets {
 		if rfc.Contains(na.IP) {
 			return true
@@ -116,56 +111,56 @@ func IsRFC1918(na *appmessage.NetAddress) bool {
 
 // IsRFC2544 returns whether or not the passed address is part of the IPv4
 // address space as defined by RFC2544 (198.18.0.0/15)
-func IsRFC2544(na *appmessage.NetAddress) bool {
+func IsRFC2544(na *wire.NetAddress) bool {
 	return rfc2544Net.Contains(na.IP)
 }
 
 // IsRFC3849 returns whether or not the passed address is part of the IPv6
 // documentation range as defined by RFC3849 (2001:DB8::/32).
-func IsRFC3849(na *appmessage.NetAddress) bool {
+func IsRFC3849(na *wire.NetAddress) bool {
 	return rfc3849Net.Contains(na.IP)
 }
 
 // IsRFC3927 returns whether or not the passed address is part of the IPv4
 // autoconfiguration range as defined by RFC3927 (169.254.0.0/16).
-func IsRFC3927(na *appmessage.NetAddress) bool {
+func IsRFC3927(na *wire.NetAddress) bool {
 	return rfc3927Net.Contains(na.IP)
 }
 
 // IsRFC3964 returns whether or not the passed address is part of the IPv6 to
 // IPv4 encapsulation range as defined by RFC3964 (2002::/16).
-func IsRFC3964(na *appmessage.NetAddress) bool {
+func IsRFC3964(na *wire.NetAddress) bool {
 	return rfc3964Net.Contains(na.IP)
 }
 
 // IsRFC4193 returns whether or not the passed address is part of the IPv6
 // unique local range as defined by RFC4193 (FC00::/7).
-func IsRFC4193(na *appmessage.NetAddress) bool {
+func IsRFC4193(na *wire.NetAddress) bool {
 	return rfc4193Net.Contains(na.IP)
 }
 
 // IsRFC4380 returns whether or not the passed address is part of the IPv6
 // teredo tunneling over UDP range as defined by RFC4380 (2001::/32).
-func IsRFC4380(na *appmessage.NetAddress) bool {
+func IsRFC4380(na *wire.NetAddress) bool {
 	return rfc4380Net.Contains(na.IP)
 }
 
 // IsRFC4843 returns whether or not the passed address is part of the IPv6
 // ORCHID range as defined by RFC4843 (2001:10::/28).
-func IsRFC4843(na *appmessage.NetAddress) bool {
+func IsRFC4843(na *wire.NetAddress) bool {
 	return rfc4843Net.Contains(na.IP)
 }
 
 // IsRFC4862 returns whether or not the passed address is part of the IPv6
 // stateless address autoconfiguration range as defined by RFC4862 (FE80::/64).
-func IsRFC4862(na *appmessage.NetAddress) bool {
+func IsRFC4862(na *wire.NetAddress) bool {
 	return rfc4862Net.Contains(na.IP)
 }
 
 // IsRFC5737 returns whether or not the passed address is part of the IPv4
 // documentation address space as defined by RFC5737 (192.0.2.0/24,
 // 198.51.100.0/24, 203.0.113.0/24)
-func IsRFC5737(na *appmessage.NetAddress) bool {
+func IsRFC5737(na *wire.NetAddress) bool {
 	for _, rfc := range rfc5737Net {
 		if rfc.Contains(na.IP) {
 			return true
@@ -177,19 +172,19 @@ func IsRFC5737(na *appmessage.NetAddress) bool {
 
 // IsRFC6052 returns whether or not the passed address is part of the IPv6
 // well-known prefix range as defined by RFC6052 (64:FF9B::/96).
-func IsRFC6052(na *appmessage.NetAddress) bool {
+func IsRFC6052(na *wire.NetAddress) bool {
 	return rfc6052Net.Contains(na.IP)
 }
 
 // IsRFC6145 returns whether or not the passed address is part of the IPv6 to
 // IPv4 translated address range as defined by RFC6145 (::FFFF:0:0:0/96).
-func IsRFC6145(na *appmessage.NetAddress) bool {
+func IsRFC6145(na *wire.NetAddress) bool {
 	return rfc6145Net.Contains(na.IP)
 }
 
 // IsRFC6598 returns whether or not the passed address is part of the IPv4
 // shared address space specified by RFC6598 (100.64.0.0/10)
-func IsRFC6598(na *appmessage.NetAddress) bool {
+func IsRFC6598(na *wire.NetAddress) bool {
 	return rfc6598Net.Contains(na.IP)
 }
 
@@ -197,7 +192,7 @@ func IsRFC6598(na *appmessage.NetAddress) bool {
 // considered invalid under the following circumstances:
 // IPv4: It is either a zero or all bits set address.
 // IPv6: It is either a zero or RFC3849 documentation address.
-func IsValid(na *appmessage.NetAddress) bool {
+func IsValid(na *wire.NetAddress) bool {
 	// IsUnspecified returns if address is 0, so only all bits set, and
 	// RFC3849 need to be explicitly checked.
 	return na.IP != nil && !(na.IP.IsUnspecified() ||
@@ -207,8 +202,8 @@ func IsValid(na *appmessage.NetAddress) bool {
 // IsRoutable returns whether or not the passed address is routable over
 // the public internet. This is true as long as the address is valid and is not
 // in any reserved ranges.
-func IsRoutable(na *appmessage.NetAddress, acceptUnroutable bool) bool {
-	if acceptUnroutable {
+func IsRoutable(na *wire.NetAddress) bool {
+	if config.ActiveConfig().NetParams().AcceptUnroutable {
 		return !IsLocal(na)
 	}
 
@@ -222,11 +217,11 @@ func IsRoutable(na *appmessage.NetAddress, acceptUnroutable bool) bool {
 // of. This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
 // "local" for a local address, and the string "unroutable" for an unroutable
 // address.
-func (am *AddressManager) GroupKey(na *appmessage.NetAddress) string {
+func GroupKey(na *wire.NetAddress) string {
 	if IsLocal(na) {
 		return "local"
 	}
-	if !IsRoutable(na, am.cfg.AcceptUnroutable) {
+	if !IsRoutable(na) {
 		return "unroutable"
 	}
 	if IsIPv4(na) {

addrmgr/network_test.go

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

app/app.go

@@ -1,185 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
-
-	"github.com/kaspanet/kaspad/infrastructure/db/database"
-	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
-
-	"github.com/kaspanet/kaspad/infrastructure/os/signal"
-	"github.com/kaspanet/kaspad/util/profiling"
-	"github.com/kaspanet/kaspad/version"
-
-	"github.com/kaspanet/kaspad/util/panics"
-
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/os/execenv"
-	"github.com/kaspanet/kaspad/infrastructure/os/limits"
-	"github.com/kaspanet/kaspad/infrastructure/os/winservice"
-)
-
-var desiredLimits = &limits.DesiredLimits{
-	FileLimitWant: 2048,
-	FileLimitMin:  1024,
-}
-
-var serviceDescription = &winservice.ServiceDescription{
-	Name:        "kaspadsvc",
-	DisplayName: "Kaspad Service",
-	Description: "Downloads and stays synchronized with the Kaspa blockDAG and " +
-		"provides DAG services to applications.",
-}
-
-type kaspadApp struct {
-	cfg *config.Config
-}
-
-// 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 {
-		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
-		}
-	}
-
-	return app.main(nil)
-}
-
-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
-	}
-
-	if app.cfg.ResetDatabase {
-		err := removeDatabase(app.cfg)
-		if err != nil {
-			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
-}
-
-// 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
-}
-
-// 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 removeDatabase(cfg *config.Config) error {
-	dbPath := databasePath(cfg)
-	return os.RemoveAll(dbPath)
-}
-
-func openDB(cfg *config.Config) (database.Database, error) {
-	dbPath := databasePath(cfg)
-	log.Infof("Loading database from '%s'", dbPath)
-	return ldb.NewLevelDB(dbPath)
-}

app/appmessage/base_message.go

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

app/appmessage/domainconverters.go

@@ -1,155 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-// DomainBlockToMsgBlock converts an externalapi.DomainBlock to MsgBlock
-func DomainBlockToMsgBlock(domainBlock *externalapi.DomainBlock) *MsgBlock {
-	msgTxs := make([]*MsgTx, 0, len(domainBlock.Transactions))
-	for _, domainTransaction := range domainBlock.Transactions {
-		msgTxs = append(msgTxs, DomainTransactionToMsgTx(domainTransaction))
-	}
-	return &MsgBlock{
-		Header:       *DomainBlockHeaderToBlockHeader(domainBlock.Header),
-		Transactions: msgTxs,
-	}
-}
-
-// DomainBlockHeaderToBlockHeader converts an externalapi.DomainBlockHeader to 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/message.go

@@ -1,205 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"fmt"
-	"time"
-)
-
-// MaxMessagePayload is the maximum bytes a message can be regardless of other
-// individual limits imposed by messages themselves.
-const MaxMessagePayload = 1024 * 1024 * 32 // 32MB
-
-// MessageCommand is a number in the header of a message that represents its type.
-type MessageCommand uint32
-
-func (cmd MessageCommand) String() string {
-	cmdString, ok := ProtocolMessageCommandToString[cmd]
-	if !ok {
-		cmdString, ok = RPCMessageCommandToString[cmd]
-	}
-	if !ok {
-		cmdString = "unknown command"
-	}
-	return fmt.Sprintf("%s [code %d]", cmdString, uint8(cmd))
-}
-
-// Commands used in kaspa message headers which describe the type of message.
-const (
-	// protocol
-	CmdVersion MessageCommand = iota
-	CmdVerAck
-	CmdRequestAddresses
-	CmdAddresses
-	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

@@ -1,22 +0,0 @@
-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

@@ -1,30 +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 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

@@ -1,87 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// defaultTransactionAlloc is the default size used for the backing array
-// for transactions. The transaction array will dynamically grow as needed, but
-// this figure is intended to provide enough space for the number of
-// transactions in the vast majority of blocks without needing to grow the
-// backing array multiple times.
-const defaultTransactionAlloc = 2048
-
-// MaxMassAcceptedByBlock is the maximum total transaction mass a block may accept.
-const MaxMassAcceptedByBlock = 10000000
-
-// MaxMassPerTx is the maximum total mass a transaction may have.
-const MaxMassPerTx = MaxMassAcceptedByBlock / 2
-
-// MaxTxPerBlock is the maximum number of transactions that could
-// possibly fit into a block.
-const MaxTxPerBlock = (MaxMassAcceptedByBlock / minTxPayload) + 1
-
-// MaxBlockParents is the maximum allowed number of parents for block.
-const MaxBlockParents = 10
-
-// TxLoc holds locator data for the offset and length of where a transaction is
-// located within a MsgBlock data buffer.
-type TxLoc struct {
-	TxStart int
-	TxLen   int
-}
-
-// MsgBlock implements the Message interface and represents a kaspa
-// block message. It is used to deliver block and transaction information in
-// response to a getdata message (MsgGetData) for a given block hash.
-type MsgBlock struct {
-	baseMessage
-	Header       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

@@ -1,238 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"math"
-	"reflect"
-	"testing"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-// TestBlock tests the MsgBlock API.
-func TestBlock(t *testing.T) {
-	pver := ProtocolVersion
-
-	// Block 1 header.
-	parentHashes := blockOne.Header.ParentHashes
-	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
-	utxoCommitment := blockOne.Header.UTXOCommitment
-	bits := blockOne.Header.Bits
-	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(5)
-	msg := NewMsgBlock(bh)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgBlock: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure max payload is expected value for latest protocol version.
-	wantPayload := uint32(1024 * 1024 * 32)
-	maxPayload := msg.MaxPayloadLength(pver)
-	if maxPayload != wantPayload {
-		t.Errorf("MaxPayloadLength: wrong max payload length for "+
-			"protocol version %d - got %v, want %v", pver,
-			maxPayload, wantPayload)
-	}
-
-	// Ensure we get the same block header data back out.
-	if !reflect.DeepEqual(&msg.Header, bh) {
-		t.Errorf("NewMsgBlock: wrong block header - got %v, want %v",
-			spew.Sdump(&msg.Header), spew.Sdump(bh))
-	}
-
-	// Ensure transactions are added properly.
-	tx := blockOne.Transactions[0].Copy()
-	msg.AddTransaction(tx)
-	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
-		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
-			spew.Sdump(msg.Transactions),
-			spew.Sdump(blockOne.Transactions))
-	}
-
-	// Ensure transactions are properly cleared.
-	msg.ClearTransactions()
-	if len(msg.Transactions) != 0 {
-		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
-			len(msg.Transactions), 0)
-	}
-}
-
-func TestConvertToPartial(t *testing.T) {
-	localSubnetworkID := &externalapi.DomainSubnetworkID{0x12}
-
-	transactions := []struct {
-		subnetworkID          *externalapi.DomainSubnetworkID
-		payload               []byte
-		expectedPayloadLength int
-	}{
-		{
-			subnetworkID:          &subnetworks.SubnetworkIDNative,
-			payload:               []byte{},
-			expectedPayloadLength: 0,
-		},
-		{
-			subnetworkID:          &subnetworks.SubnetworkIDRegistry,
-			payload:               []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
-			expectedPayloadLength: 0,
-		},
-		{
-			subnetworkID:          localSubnetworkID,
-			payload:               []byte{0x01},
-			expectedPayloadLength: 1,
-		},
-		{
-			subnetworkID:          &externalapi.DomainSubnetworkID{0x34},
-			payload:               []byte{0x02},
-			expectedPayloadLength: 0,
-		},
-	}
-
-	block := MsgBlock{}
-	payload := []byte{1}
-	for _, transaction := range transactions {
-		block.Transactions = append(block.Transactions, NewSubnetworkMsgTx(1, nil, nil, transaction.subnetworkID, 0, payload))
-	}
-
-	block.ConvertToPartial(localSubnetworkID)
-
-	for _, testTransaction := range transactions {
-		var subnetworkTx *MsgTx
-		for _, blockTransaction := range block.Transactions {
-			if blockTransaction.SubnetworkID == *testTransaction.subnetworkID {
-				subnetworkTx = blockTransaction
-			}
-		}
-		if subnetworkTx == nil {
-			t.Errorf("ConvertToPartial: subnetworkID '%s' not found in block!", testTransaction.subnetworkID)
-			continue
-		}
-
-		payloadLength := len(subnetworkTx.Payload)
-		if payloadLength != testTransaction.expectedPayloadLength {
-			t.Errorf("ConvertToPartial: unexpected payload length for subnetwork '%s': expected: %d, got: %d",
-				testTransaction.subnetworkID, testTransaction.expectedPayloadLength, payloadLength)
-		}
-	}
-}
-
-// blockOne is the first block in the mainnet block DAG.
-var blockOne = MsgBlock{
-	Header: 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

@@ -1,108 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"math"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/pkg/errors"
-)
-
-// BaseBlockHeaderPayload is the base number of bytes a block header can be,
-// not including the list of parent block headers.
-// Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes +
-// + NumParentBlocks 1 byte + HashMerkleRoot hash +
-// + AcceptedIDMerkleRoot hash + UTXOCommitment hash.
-// To get total size of block header len(ParentHashes) * externalapi.DomainHashSize should be
-// added to this value
-const BaseBlockHeaderPayload = 25 + 3*(externalapi.DomainHashSize)
-
-// MaxNumParentBlocks is the maximum number of parent blocks a block can reference.
-// Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte
-const MaxNumParentBlocks = 255
-
-// MaxBlockHeaderPayload is the maximum number of bytes a block header can be.
-// BaseBlockHeaderPayload + up to MaxNumParentBlocks hashes of parent blocks
-const MaxBlockHeaderPayload = BaseBlockHeaderPayload + (MaxNumParentBlocks * externalapi.DomainHashSize)
-
-// 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

@@ -1,88 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/random"
-)
-
-// TestBlockHeader tests the 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,31 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MaxBlockLocatorsPerMsg is the maximum number of block locator hashes allowed
-// per message.
-const MaxBlockLocatorsPerMsg = 500
-
-// MsgBlockLocator implements the Message interface and represents a kaspa
-// locator message. It is used to find the blockLocator of a peer that is
-// syncing with you.
-type MsgBlockLocator struct {
-	baseMessage
-	BlockLocatorHashes []*externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgBlockLocator) Command() MessageCommand {
-	return CmdBlockLocator
-}
-
-// NewMsgBlockLocator returns a new kaspa locator message that conforms to
-// the Message interface. See MsgBlockLocator for details.
-func NewMsgBlockLocator(locatorHashes []*externalapi.DomainHash) *MsgBlockLocator {
-	return &MsgBlockLocator{
-		BlockLocatorHashes: locatorHashes,
-	}
-}

app/appmessage/p2p_msgblocklocator_test.go

@@ -1,37 +0,0 @@
-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"
-)
-
-// TestBlockLocator tests the MsgBlockLocator API.
-func TestBlockLocator(t *testing.T) {
-	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	locatorHash, err := hashes.FromString(hashStr)
-	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
-	}
-
-	msg := NewMsgBlockLocator([]*externalapi.DomainHash{locatorHash})
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(10)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgBlockLocator: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure block locator hashes are added properly.
-	if msg.BlockLocatorHashes[0] != locatorHash {
-		t.Errorf("AddBlockLocatorHash: wrong block locator added - "+
-			"got %v, want %v",
-			spew.Sprint(msg.BlockLocatorHashes[0]),
-			spew.Sprint(locatorHash))
-	}
-}

app/appmessage/p2p_msgdoneheaders.go

@@ -1,22 +0,0 @@
-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

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

app/appmessage/p2p_msgibdblock_test.go

@@ -1,65 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// TestIBDBlock tests the MsgIBDBlock API.
-func TestIBDBlock(t *testing.T) {
-	pver := ProtocolVersion
-
-	// Block 1 header.
-	parentHashes := blockOne.Header.ParentHashes
-	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
-	utxoCommitment := blockOne.Header.UTXOCommitment
-	bits := blockOne.Header.Bits
-	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(17)
-	msg := NewMsgIBDBlock(NewMsgBlock(bh))
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure max payload is expected value for latest protocol version.
-	wantPayload := uint32(1024 * 1024 * 32)
-	maxPayload := msg.MaxPayloadLength(pver)
-	if maxPayload != wantPayload {
-		t.Errorf("MaxPayloadLength: wrong max payload length for "+
-			"protocol version %d - got %v, want %v", pver,
-			maxPayload, wantPayload)
-	}
-
-	// Ensure we get the same block header data back out.
-	if !reflect.DeepEqual(&msg.Header, bh) {
-		t.Errorf("NewMsgIBDBlock: wrong block header - got %v, want %v",
-			spew.Sdump(&msg.Header), spew.Sdump(bh))
-	}
-
-	// Ensure transactions are added properly.
-	tx := blockOne.Transactions[0].Copy()
-	msg.AddTransaction(tx)
-	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
-		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
-			spew.Sdump(msg.Transactions),
-			spew.Sdump(blockOne.Transactions))
-	}
-
-	// Ensure transactions are properly cleared.
-	msg.ClearTransactions()
-	if len(msg.Transactions) != 0 {
-		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
-			len(msg.Transactions), 0)
-	}
-}

app/appmessage/p2p_msgibdrootutxosetandblock.go

@@ -1,23 +0,0 @@
-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,27 +0,0 @@
-package appmessage
-
-import (
-	"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 {
-	baseMessage
-	Hash *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgInvRelayBlock) Command() MessageCommand {
-	return CmdInvRelayBlock
-}
-
-// NewMsgInvBlock returns a new kaspa invrelblk message that conforms to
-// the Message interface. See MsgInvRelayBlock for details.
-func NewMsgInvBlock(hash *externalapi.DomainHash) *MsgInvRelayBlock {
-	return &MsgInvRelayBlock{
-		Hash: hash,
-	}
-}

app/appmessage/p2p_msginvtransaction.go

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

app/appmessage/p2p_msgping_test.go

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

app/appmessage/p2p_msgpong_test.go

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

app/appmessage/p2p_msgreject.go

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

app/appmessage/p2p_msgrequestaddresses.go

@@ -1,36 +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 appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgRequestAddresses implements the Message interface and represents a kaspa
-// RequestAddresses message. It is used to request a list of known active peers on the
-// network from a peer to help identify potential nodes. The list is returned
-// via one or more addr messages (MsgAddresses).
-//
-// This message has no payload.
-type MsgRequestAddresses struct {
-	baseMessage
-	IncludeAllSubnetworks bool
-	SubnetworkID          *externalapi.DomainSubnetworkID
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestAddresses) Command() MessageCommand {
-	return CmdRequestAddresses
-}
-
-// NewMsgRequestAddresses returns a new kaspa RequestAddresses message that conforms to the
-// Message interface. See MsgRequestAddresses for details.
-func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) *MsgRequestAddresses {
-	return &MsgRequestAddresses{
-		IncludeAllSubnetworks: includeAllSubnetworks,
-		SubnetworkID:          subnetworkID,
-	}
-}

app/appmessage/p2p_msgrequestaddresses_test.go

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

app/appmessage/p2p_msgrequestblocklocator.go

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

app/appmessage/p2p_msgrequestblocklocator_test.go

@@ -1,26 +0,0 @@
-package appmessage
-
-import (
-	"testing"
-
-	"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 := hashes.FromString(hashStr)
-	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
-	}
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(9)
-	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

@@ -1,34 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// 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

@@ -1,40 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"testing"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
-)
-
-// TestRequstIBDBlocks tests the MsgRequestHeaders API.
-func TestRequstIBDBlocks(t *testing.T) {
-	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	lowHash, err := hashes.FromString(hashStr)
-	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
-	}
-
-	hashStr = "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	highHash, err := hashes.FromString(hashStr)
-	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
-	}
-
-	// Ensure we get the same data back out.
-	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("NewMsgRequstHeaders: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-}

app/appmessage/p2p_msgrequestibdblocks.go

@@ -1,30 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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

app/appmessage/p2p_msgrequestselectedtip.go

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

app/appmessage/p2p_msgrequestselectedtip_test.go

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

app/appmessage/p2p_msgrequesttransactions.go

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

app/appmessage/p2p_msgselectedtip.go

@@ -1,28 +0,0 @@
-package appmessage
-
-import (
-	"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 *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgSelectedTip) Command() MessageCommand {
-	return CmdSelectedTip
-}
-
-// NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
-// Message interface.
-func NewMsgSelectedTip(selectedTipHash *externalapi.DomainHash) *MsgSelectedTip {
-	return &MsgSelectedTip{
-		SelectedTipHash: selectedTipHash,
-	}
-}

app/appmessage/p2p_msgselectedtip_test.go

@@ -1,18 +0,0 @@
-package appmessage
-
-import (
-	"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(&externalapi.DomainHash{})
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgSelectedTip: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-}

app/appmessage/p2p_msgtransactionnotfound.go

@@ -1,30 +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 appmessage
-
-import (
-	"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 {
-	baseMessage
-	ID *externalapi.DomainTransactionID
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgTransactionNotFound) Command() MessageCommand {
-	return CmdTransactionNotFound
-}
-
-// NewMsgTransactionNotFound returns a new kaspa transactionsnotfound message that conforms to the
-// Message interface. See MsgTransactionNotFound for details.
-func NewMsgTransactionNotFound(id *externalapi.DomainTransactionID) *MsgTransactionNotFound {
-	return &MsgTransactionNotFound{
-		ID: id,
-	}
-}

app/appmessage/p2p_msgtx.go

@@ -1,328 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"encoding/binary"
-	"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

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

app/appmessage/p2p_msgverack.go

@@ -1,26 +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 appmessage
-
-// MsgVerAck defines a kaspa verack message which is used for a peer to
-// acknowledge a version message (MsgVersion) after it has used the information
-// to negotiate parameters. It implements the Message interface.
-//
-// This message has no payload.
-type MsgVerAck struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgVerAck) Command() MessageCommand {
-	return CmdVerAck
-}
-
-// NewMsgVerAck returns a new kaspa verack message that conforms to the
-// Message interface.
-func NewMsgVerAck() *MsgVerAck {
-	return &MsgVerAck{}
-}

app/appmessage/p2p_msgverack_test.go

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

app/appmessage/p2p_msgversion.go

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

app/appmessage/p2p_msgversion_test.go

@@ -1,97 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"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.
-func TestVersion(t *testing.T) {
-	pver := ProtocolVersion
-
-	// Create version message data.
-	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()
-	if err != nil {
-		t.Fatalf("id.GenerateID: %s", err)
-	}
-
-	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
-	if msg.ProtocolVersion != pver {
-		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
-			msg.ProtocolVersion, pver)
-	}
-	if !reflect.DeepEqual(msg.Address, me) {
-		t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
-			spew.Sdump(&msg.Address), spew.Sdump(me))
-	}
-	if msg.ID.String() != generatedID.String() {
-		t.Errorf("NewMsgVersion: wrong nonce - got %s, want %s",
-			msg.ID, generatedID)
-	}
-	if msg.UserAgent != DefaultUserAgent {
-		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
-			msg.UserAgent, DefaultUserAgent)
-	}
-	if *msg.SelectedTipHash != *selectedTipHash {
-		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
-			msg.SelectedTipHash, selectedTipHash)
-	}
-	if msg.DisableRelayTx {
-		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
-			"default - got %v, want %v", msg.DisableRelayTx, false)
-	}
-
-	msg.AddUserAgent("myclient", "1.2.3", "optional", "comments")
-	customUserAgent := DefaultUserAgent + "myclient:1.2.3(optional; comments)/"
-	if msg.UserAgent != customUserAgent {
-		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
-			msg.UserAgent, customUserAgent)
-	}
-
-	msg.AddUserAgent("mygui", "3.4.5")
-	customUserAgent += "mygui:3.4.5/"
-	if msg.UserAgent != customUserAgent {
-		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
-			msg.UserAgent, customUserAgent)
-	}
-
-	// Version message should not have any services set by default.
-	if msg.Services != 0 {
-		t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
-			msg.Services, 0)
-
-	}
-	if msg.HasService(SFNodeNetwork) {
-		t.Errorf("HasService: SFNodeNetwork service is set")
-	}
-
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(0)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgVersion: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure adding the full service node flag works.
-	msg.AddService(SFNodeNetwork)
-	if msg.Services != SFNodeNetwork {
-		t.Errorf("AddService: wrong services - got %v, want %v",
-			msg.Services, SFNodeNetwork)
-	}
-	if !msg.HasService(SFNodeNetwork) {
-		t.Errorf("HasService: SFNodeNetwork service not set")
-	}
-}

app/appmessage/p2p_netaddress.go

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

app/appmessage/p2p_netaddress_test.go

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

app/appmessage/rpc_add_peer.go

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

app/appmessage/rpc_get_block.go

@@ -1,109 +0,0 @@
-package appmessage
-
-// GetBlockRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockRequestMessage struct {
-	baseMessage
-	Hash                          string
-	SubnetworkID                  string
-	IncludeTransactionVerboseData bool
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockRequestMessage) Command() MessageCommand {
-	return CmdGetBlockRequestMessage
-}
-
-// NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
-	return &GetBlockRequestMessage{
-		Hash:                          hash,
-		SubnetworkID:                  subnetworkID,
-		IncludeTransactionVerboseData: includeTransactionVerboseData,
-	}
-}
-
-// GetBlockResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockResponseMessage struct {
-	baseMessage
-	BlockVerboseData *BlockVerboseData
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockResponseMessage) Command() MessageCommand {
-	return CmdGetBlockResponseMessage
-}
-
-// NewGetBlockResponseMessage returns a instance of the message
-func NewGetBlockResponseMessage() *GetBlockResponseMessage {
-	return &GetBlockResponseMessage{}
-}
-
-// BlockVerboseData holds verbose data about a block
-type BlockVerboseData struct {
-	Hash                   string
-	Version                int32
-	VersionHex             string
-	HashMerkleRoot         string
-	AcceptedIDMerkleRoot   string
-	UTXOCommitment         string
-	TxIDs                  []string
-	TransactionVerboseData []*TransactionVerboseData
-	Time                   int64
-	Nonce                  uint64
-	Bits                   string
-	Difficulty             float64
-	ParentHashes           []string
-	SelectedParentHash     string
-	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

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

app/appmessage/rpc_get_block_dag_info.go

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

app/appmessage/rpc_get_block_template.go

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

app/appmessage/rpc_get_blocks.go

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

app/appmessage/rpc_get_chain_from_block.go

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

app/appmessage/rpc_get_connected_peer_info.go

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

app/appmessage/rpc_get_current_network.go

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

app/appmessage/rpc_get_headers.go

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

app/appmessage/rpc_get_mempool_entries.go

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

app/appmessage/rpc_get_mempool_entry.go

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

app/appmessage/rpc_get_peer_addresses.go

@@ -1,46 +0,0 @@
-package appmessage
-
-// GetPeerAddressesRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetPeerAddressesRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetPeerAddressesRequestMessage) Command() MessageCommand {
-	return CmdGetPeerAddressesRequestMessage
-}
-
-// NewGetPeerAddressesRequestMessage returns a instance of the message
-func NewGetPeerAddressesRequestMessage() *GetPeerAddressesRequestMessage {
-	return &GetPeerAddressesRequestMessage{}
-}
-
-// GetPeerAddressesResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetPeerAddressesResponseMessage struct {
-	baseMessage
-	Addresses       []*GetPeerAddressesKnownAddressMessage
-	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

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

app/appmessage/rpc_get_subnetwork.go

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

app/appmessage/rpc_notify_block_added.go

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

app/appmessage/rpc_notify_chain_changed.go

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

app/appmessage/rpc_notify_finality_conflicts.go

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

app/appmessage/rpc_resolve_finality_conflict.go

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

app/appmessage/rpc_shut_down.go

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

app/appmessage/rpc_submit_block.go

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

app/appmessage/rpc_submit_transaction.go

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

app/component_manager.go

@@ -1,161 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"sync/atomic"
-
-	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
-
-	"github.com/kaspanet/kaspad/domain"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol"
-	"github.com/kaspanet/kaspad/app/rpc"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/util/panics"
-)
-
-// ComponentManager is a wrapper for all the kaspad services
-type ComponentManager struct {
-	cfg               *config.Config
-	addressManager    *addressmanager.AddressManager
-	protocolManager   *protocol.Manager
-	rpcManager        *rpc.Manager
-	connectionManager *connmanager.ConnectionManager
-	netAdapter        *netadapter.NetAdapter
-
-	started, shutdown int32
-}
-
-// Start launches all the kaspad services.
-func (a *ComponentManager) Start() {
-	// Already started?
-	if atomic.AddInt32(&a.started, 1) != 1 {
-		return
-	}
-
-	log.Trace("Starting kaspad")
-
-	err := a.netAdapter.Start()
-	if err != nil {
-		panics.Exit(log, fmt.Sprintf("Error starting the net adapter: %+v", err))
-	}
-
-	a.maybeSeedFromDNS()
-
-	a.connectionManager.Start()
-}
-
-// Stop gracefully shuts down all the kaspad services.
-func (a *ComponentManager) Stop() {
-	// Make sure this only happens once.
-	if atomic.AddInt32(&a.shutdown, 1) != 1 {
-		log.Infof("Kaspad is already in the process of shutting down")
-		return
-	}
-
-	log.Warnf("Kaspad shutting down")
-
-	a.connectionManager.Stop()
-
-	err := a.netAdapter.Stop()
-	if err != nil {
-		log.Errorf("Error stopping the net adapter: %+v", err)
-	}
-
-	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

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

app/protocol/blocklogger/blocklogger.go

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

app/protocol/blocklogger/log.go

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

app/protocol/common/common.go

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

app/protocol/flowcontext/addresses.go

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

app/protocol/flowcontext/blocks.go

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

app/protocol/flowcontext/domain.go

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

app/protocol/flowcontext/errors.go

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

app/protocol/flowcontext/flow_context.go

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

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

app/protocol/flowcontext/network.go

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

app/protocol/flowcontext/orphans.go

@@ -1,130 +0,0 @@
-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

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

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -1,42 +0,0 @@
-package addressexchange
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// ReceiveAddressesContext is the interface for the context needed for the ReceiveAddresses flow.
-type ReceiveAddressesContext interface {
-	Config() *config.Config
-	AddressManager() *addressmanager.AddressManager
-}
-
-// ReceiveAddresses asks a peer for more addresses if needed.
-func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
-	peer *peerpkg.Peer) error {
-
-	subnetworkID := peer.SubnetworkID()
-	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
-	err := outgoingRoute.Enqueue(msgGetAddresses)
-	if err != nil {
-		return err
-	}
-
-	message, err := incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
-	if err != nil {
-		return err
-	}
-
-	msgAddresses := message.(*appmessage.MsgAddresses)
-	if len(msgAddresses.AddressList) > addressmanager.GetAddressesMax {
-		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
-	}
-
-	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
-	return nil
-}

app/protocol/flows/addressexchange/sendaddresses.go

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

app/protocol/flows/blockrelay/handle_relay_block_requests.go

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

app/protocol/flows/blockrelay/handle_relay_invs.go

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

app/protocol/flows/blockrelay/hashes_queue_set.go

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

app/protocol/flows/blockrelay/log.go

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

app/protocol/flows/blockrelay/shared_requested_blocks.go

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