fdlkjsjkldsfhjkds

* Add TestValidateAndInsertPruningPoint

* Check fake UTXO set and validate that the pruning point changed

.codecov.yml

@@ -0,0 +1,7 @@
+coverage:
+  status:
+    patch: off
+
+    project:
+      default:
+        informational: true

.github/workflows/SetPageFileSize.ps1

@@ -0,0 +1,196 @@
+<#
+# MIT License (MIT) Copyright (c) 2020 Maxim Lobanov and contributors
+# Source: https://github.com/al-cheb/configure-pagefile-action/blob/master/scripts/SetPageFileSize.ps1
+.SYNOPSIS
+  Configure Pagefile on Windows machine
+.NOTES
+  Author:         Aleksandr Chebotov
+
+.EXAMPLE
+  SetPageFileSize.ps1 -MinimumSize 4GB -MaximumSize 8GB -DiskRoot "D:"
+#>
+
+param(
+    [System.UInt64] $MinimumSize = 8gb ,
+    [System.UInt64] $MaximumSize = 8gb ,
+    [System.String] $DiskRoot = "D:"
+)
+
+# https://referencesource.microsoft.com/#System.IdentityModel/System/IdentityModel/NativeMethods.cs,619688d876febbe1
+# https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/mm/modwrite/create.htm
+# https://referencesource.microsoft.com/#mscorlib/microsoft/win32/safehandles/safefilehandle.cs,9b08210f3be75520
+# https://referencesource.microsoft.com/#mscorlib/system/security/principal/tokenaccesslevels.cs,6eda91f498a38586
+# https://www.autoitscript.com/forum/topic/117993-api-ntcreatepagingfile/
+
+$source = @'
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Principal;
+using System.Text;
+using Microsoft.Win32;
+using Microsoft.Win32.SafeHandles;
+
+namespace Util
+{
+    class NativeMethods
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct LUID
+        {
+            internal uint LowPart;
+            internal uint HighPart;
+        }
+    
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct LUID_AND_ATTRIBUTES
+        {
+            internal LUID Luid;
+            internal uint Attributes;
+        }
+    
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct TOKEN_PRIVILEGE
+        {
+            internal uint PrivilegeCount;
+            internal LUID_AND_ATTRIBUTES Privilege;
+    
+            internal static readonly uint Size = (uint)Marshal.SizeOf(typeof(TOKEN_PRIVILEGE));
+        }
+
+        [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        internal struct UNICODE_STRING
+        {
+            internal UInt16 length;
+            internal UInt16 maximumLength;
+            internal string buffer;
+        }
+
+        [DllImport("kernel32.dll", SetLastError=true)]
+        internal static extern IntPtr LocalFree(IntPtr handle);
+
+        [DllImport("advapi32.dll", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true, PreserveSig = false)]
+        internal static extern bool LookupPrivilegeValueW(
+            [In] string lpSystemName,
+            [In] string lpName,
+            [Out] out LUID luid
+        );
+
+        [DllImport("advapi32.dll", SetLastError = true, PreserveSig = false)]
+        internal static extern bool AdjustTokenPrivileges(
+            [In] SafeCloseHandle tokenHandle,
+            [In] bool disableAllPrivileges,
+            [In] ref TOKEN_PRIVILEGE newState,
+            [In] uint bufferLength,
+            [Out] out TOKEN_PRIVILEGE previousState,
+            [Out] out uint returnLength
+        );
+
+        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true, PreserveSig = false)]
+        internal static extern bool OpenProcessToken(
+            [In] IntPtr processToken,
+            [In] int desiredAccess,
+            [Out] out SafeCloseHandle tokenHandle
+        );
+
+        [DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true, CallingConvention = CallingConvention.StdCall)]
+        internal static extern Int32 NtCreatePagingFile(
+            [In] ref UNICODE_STRING pageFileName, 
+            [In] ref Int64 minimumSize, 
+            [In] ref Int64 maximumSize, 
+            [In] UInt32 flags
+        );
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        internal static extern uint QueryDosDeviceW(
+            string lpDeviceName,
+            StringBuilder lpTargetPath,
+            int ucchMax
+        );
+    }
+
+    public sealed class SafeCloseHandle: SafeHandleZeroOrMinusOneIsInvalid 
+    {
+        [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
+        internal extern static bool CloseHandle(IntPtr handle);
+
+        private SafeCloseHandle() : base(true)
+        {
+        }
+ 
+        public SafeCloseHandle(IntPtr preexistingHandle, bool ownsHandle) : base(ownsHandle) 
+        {
+            SetHandle(preexistingHandle);
+        }
+
+        override protected bool ReleaseHandle()
+        {
+            return CloseHandle(handle);
+        }
+    }
+
+    public class PageFile
+    {
+        public static void SetPageFileSize(long minimumValue, long maximumValue, string lpDeviceName)
+        {
+            SetPageFilePrivilege();
+            StringBuilder lpTargetPath = new StringBuilder(260);
+
+            UInt32 resultQueryDosDevice = NativeMethods.QueryDosDeviceW(lpDeviceName, lpTargetPath, lpTargetPath.Capacity);
+            if (resultQueryDosDevice == 0)
+            {
+                throw new Win32Exception(Marshal.GetLastWin32Error());
+            }
+
+            string pageFilePath = lpTargetPath.ToString() + "\\pagefile.sys";
+
+            NativeMethods.UNICODE_STRING pageFileName = new NativeMethods.UNICODE_STRING
+            {
+                length = (ushort)(pageFilePath.Length * 2),
+                maximumLength = (ushort)(2 * (pageFilePath.Length + 1)),
+                buffer = pageFilePath
+            };
+
+            Int32 resultNtCreatePagingFile = NativeMethods.NtCreatePagingFile(ref pageFileName, ref minimumValue, ref maximumValue, 0);
+            if (resultNtCreatePagingFile != 0)
+            {
+                throw new Win32Exception(Marshal.GetLastWin32Error());
+            }
+
+            Console.WriteLine("PageFile: {0} / {1} bytes for {2}", minimumValue, maximumValue, pageFilePath);
+        }
+
+        static void SetPageFilePrivilege()
+        {
+            const int SE_PRIVILEGE_ENABLED = 0x00000002;
+            const int AdjustPrivileges = 0x00000020;
+            const int Query = 0x00000008;
+
+            NativeMethods.LUID luid;
+            NativeMethods.LookupPrivilegeValueW(null, "SeCreatePagefilePrivilege", out luid);
+
+            SafeCloseHandle hToken;
+            NativeMethods.OpenProcessToken(
+                Process.GetCurrentProcess().Handle,
+                AdjustPrivileges | Query,
+                out hToken
+            );
+
+            NativeMethods.TOKEN_PRIVILEGE previousState;
+            NativeMethods.TOKEN_PRIVILEGE newState;
+            uint previousSize = 0;
+            newState.PrivilegeCount = 1;
+            newState.Privilege.Luid = luid;
+            newState.Privilege.Attributes = SE_PRIVILEGE_ENABLED;
+
+            NativeMethods.AdjustTokenPrivileges(hToken, false, ref newState, NativeMethods.TOKEN_PRIVILEGE.Size, out previousState, out previousSize);
+        }
+    }
+}
+'@
+
+Add-Type -TypeDefinition $source
+
+# Set SetPageFileSize
+[Util.PageFile]::SetPageFileSize($minimumSize, $maximumSize, $diskRoot)

.github/workflows/go.yml

@@ -0,0 +1,70 @@
+name: Go
+
+on:
+  push:
+  pull_request:
+    # edtited - "title, body, or the base branch of the PR is modified"
+    # synchronize - "commit(s) pushed to the pull request"
+    types: [opened, synchronize, edited, reopened]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-16.04, macos-10.15 ]
+    name: Testing on on ${{ matrix.os }}
+    steps:
+
+      - name: Fix windows CRLF
+        run: git config --global core.autocrlf false
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      # We need to increase the page size because the tests run out of memory on github CI windows.
+      # Use the powershell script from this github action: https://github.com/al-cheb/configure-pagefile-action/blob/master/scripts/SetPageFileSize.ps1
+      # MIT License (MIT) Copyright (c) 2020 Maxim Lobanov and contributors
+      - name: Increase page size on windows
+        if: runner.os == 'Windows'
+        shell: powershell
+        run: powershell -command .\.github\workflows\SetPageFileSize.ps1
+
+
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.14
+
+
+      # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
+      - name: Go Cache
+        uses: actions/cache@v2
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Test
+        shell: bash
+        run: ./build_and_test.sh
+
+  coverage:
+    runs-on: ubuntu-20.04
+    name: Produce code coverage
+    steps:
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - name: Set up Go 1.x
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.14
+
+      - name: Create coverage file
+        # Because of https://github.com/golang/go/issues/27333 this seem to "fail" even though nothing is wrong, so ignore the failure
+        run: go test -json -covermode=atomic -coverpkg=./... -coverprofile coverage.txt ./... || true
+
+      - name: Upload coverage file
+        run: bash <(curl -s https://codecov.io/bash)

.gitignore

@@ -13,6 +13,21 @@ kaspad.db
 *.o
 *.a
 *.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Real binaries, build with `go build .`
+kaspad
+cmd/gencerts/gencerts
+cmd/kaspactl/kaspactl
+cmd/kasminer/kaspaminer
+*.exe
+*.exe~
+
+# Output of the go coverage tool
+*.out
 
 # Folders
 _obj
@@ -31,8 +46,7 @@ _cgo_export.*
 
 _testmain.go
 
-*.exe
- 
+
 # IDE
 .idea
 .vscode

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing to Kaspad
+
+Any contribution to Kaspad is very welcome.
+
+## Getting started
+
+If you want to start contributing to Kaspad and don't know where to start, you can pick an issue from
+the [list](https://github.com/kaspanet/kaspad/issues).
+
+If you want to make a big change it's better to discuss it first by opening an issue or talk about it in
+[Discord](https://discord.gg/WmGhhzk) to avoid duplicate work.
+
+## Pull Request process
+
+Any pull request should be opened against the development branch of the target version. The development branch format is
+as follows: `vx.y.z-dev`, for example: `v0.8.5-dev`.
+
+All pull requests should pass the checks written in `build_and_test.sh`, so it's recommended to run this script before
+submitting your PR.

README.md

@@ -9,12 +9,16 @@ Warning: This is pre-alpha software. There's no guarantee anything works.
 
 Kaspad is the reference full node Kaspa implementation written in Go (golang).
 
-This project is currently under active development and is in a pre-Alpha state. 
+This project is currently under active development and is in a pre-Alpha state.
 Some things still don't work and APIs are far from finalized. The code is provided for reference only.
 
+## What is kaspa
+
+Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations and sub-second block times. It is based on [the PHANTOM protocol](https://eprint.iacr.org/2018/104.pdf), a generalization of Nakamoto consensus.
+
 ## Requirements
 
-Latest version of [Go](http://golang.org) (currently 1.13).
+Go 1.14 or later.
 
 ## Installation
 
@@ -27,23 +31,17 @@ Latest version of [Go](http://golang.org) (currently 1.13).
 
 ```bash
 $ go version
-$ go env GOROOT GOPATH
 ```
 
-NOTE: The `GOROOT` and `GOPATH` above must not be the same path. It is
-recommended that `GOPATH` is set to a directory in your home directory such as
-`~/dev/go` to avoid write permission issues. It is also recommended to add
-`$GOPATH/bin` to your `PATH` at this point.
-
 - Run the following commands to obtain and install kaspad including all dependencies:
 
 ```bash
-$ git clone https://github.com/kaspanet/kaspad $GOPATH/src/github.com/kaspanet/kaspad
-$ cd $GOPATH/src/github.com/kaspanet/kaspad
+$ git clone https://github.com/kaspanet/kaspad
+$ cd kaspad
 $ go install . ./cmd/...
 ```
 
-- Kaspad (and utilities) should now be installed in `$GOPATH/bin`. If you did
+- Kaspad (and utilities) should now be installed in `$(go env GOPATH)/bin`. If you did
   not already add the bin directory to your system path during Go installation,
   you are encouraged to do so now.
 
@@ -53,10 +51,8 @@ $ go install . ./cmd/...
 Kaspad has several configuration options available to tweak how it runs, but all
 of the basic operations work with zero configuration.
 
-#### Linux/BSD/POSIX/Source
-
 ```bash
-$ ./kaspad
+$ kaspad
 ```
 
 ## Discord
@@ -69,9 +65,8 @@ is used for this project.
 
 ## Documentation
 
-The documentation is a work-in-progress. It is located in the [docs](https://github.com/kaspanet/kaspad/tree/master/docs) folder.
+The documentation is a work-in-progress.
 
 ## License
 
 Kaspad is licensed under the copyfree [ISC License](https://choosealicense.com/licenses/isc/).
-

app/app.go

@@ -7,9 +7,9 @@ import (
 	"runtime"
 	"time"
 
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/infrastructure/db/database"
+	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
 
-	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
 	"github.com/kaspanet/kaspad/infrastructure/os/signal"
 	"github.com/kaspanet/kaspad/util/profiling"
 	"github.com/kaspanet/kaspad/version"
@@ -46,7 +46,7 @@ func StartApp() error {
 	// initializes logging and configures it accordingly.
 	cfg, err := config.LoadConfig()
 	if err != nil {
-		fmt.Fprint(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, err)
 		return err
 	}
 	defer panics.HandlePanic(log, "MAIN", nil)
@@ -123,16 +123,6 @@ func (app *kaspadApp) main(startedChan chan<- struct{}) error {
 		return nil
 	}
 
-	// Drop indexes and exit if requested.
-	if app.cfg.DropAcceptanceIndex {
-		if err := indexers.DropAcceptanceIndex(databaseContext); err != nil {
-			log.Errorf("%s", err)
-			return err
-		}
-
-		return nil
-	}
-
 	// Create componentManager and start it.
 	componentManager, err := NewComponentManager(app.cfg, databaseContext, interrupt)
 	if err != nil {
@@ -188,8 +178,8 @@ func removeDatabase(cfg *config.Config) error {
 	return os.RemoveAll(dbPath)
 }
 
-func openDB(cfg *config.Config) (*dbaccess.DatabaseContext, error) {
+func openDB(cfg *config.Config) (database.Database, error) {
 	dbPath := databasePath(cfg)
 	log.Infof("Loading database from '%s'", dbPath)
-	return dbaccess.New(dbPath)
+	return ldb.NewLevelDB(dbPath)
 }

app/appmessage/bench_test.go

@@ -1,431 +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"
-	"compress/bzip2"
-	"io/ioutil"
-	"math"
-	"os"
-	"testing"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
-// the main network and test network.
-var genesisCoinbaseTxIns = []*TxIn{
-	{
-		PreviousOutpoint: Outpoint{
-			TxID:  daghash.TxID{},
-			Index: 0xffffffff,
-		},
-		SignatureScript: []byte{
-			0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, 0x45, /* |.......E| */
-			0x54, 0x68, 0x65, 0x20, 0x54, 0x69, 0x6d, 0x65, /* |The Time| */
-			0x73, 0x20, 0x30, 0x33, 0x2f, 0x4a, 0x61, 0x6e, /* |s 03/Jan| */
-			0x2f, 0x32, 0x30, 0x30, 0x39, 0x20, 0x43, 0x68, /* |/2009 Ch| */
-			0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x6f, 0x72, /* |ancellor| */
-			0x20, 0x6f, 0x6e, 0x20, 0x62, 0x72, 0x69, 0x6e, /* | on brin| */
-			0x6b, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x65, 0x63, /* |k of sec|*/
-			0x6f, 0x6e, 0x64, 0x20, 0x62, 0x61, 0x69, 0x6c, /* |ond bail| */
-			0x6f, 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, /* |out for |*/
-			0x62, 0x61, 0x6e, 0x6b, 0x73, /* |banks| */
-		},
-		Sequence: math.MaxUint64,
-	},
-}
-var genesisCoinbaseTxOuts = []*TxOut{
-	{
-		Value: 0x12a05f200,
-		ScriptPubKey: []byte{
-			0x41, 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, /* |A.g....U| */
-			0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, /* |H'.g..q0| */
-			0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, /* |..\..(.9| */
-			0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, /* |..yb...a| */
-			0xde, 0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, /* |..I..?L.| */
-			0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, /* |8..U....| */
-			0x12, 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, /* |..\8M...| */
-			0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, /* |.W.Lp+k.| */
-			0x1d, 0x5f, 0xac, /* |._.| */
-		},
-	},
-}
-var genesisCoinbaseTx = NewNativeMsgTx(1, genesisCoinbaseTxIns, genesisCoinbaseTxOuts)
-
-// BenchmarkWriteVarInt1 performs a benchmark on how long it takes to write
-// a single byte variable length integer.
-func BenchmarkWriteVarInt1(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarInt(ioutil.Discard, 1)
-	}
-}
-
-// BenchmarkWriteVarInt3 performs a benchmark on how long it takes to write
-// a three byte variable length integer.
-func BenchmarkWriteVarInt3(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarInt(ioutil.Discard, 65535)
-	}
-}
-
-// BenchmarkWriteVarInt5 performs a benchmark on how long it takes to write
-// a five byte variable length integer.
-func BenchmarkWriteVarInt5(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarInt(ioutil.Discard, 4294967295)
-	}
-}
-
-// BenchmarkWriteVarInt9 performs a benchmark on how long it takes to write
-// a nine byte variable length integer.
-func BenchmarkWriteVarInt9(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarInt(ioutil.Discard, 18446744073709551615)
-	}
-}
-
-// BenchmarkReadVarInt1 performs a benchmark on how long it takes to read
-// a single byte variable length integer.
-func BenchmarkReadVarInt1(b *testing.B) {
-	buf := []byte{0x01}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarInt(r)
-	}
-}
-
-// BenchmarkReadVarInt3 performs a benchmark on how long it takes to read
-// a three byte variable length integer.
-func BenchmarkReadVarInt3(b *testing.B) {
-	buf := []byte{0x0fd, 0xff, 0xff}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarInt(r)
-	}
-}
-
-// BenchmarkReadVarInt5 performs a benchmark on how long it takes to read
-// a five byte variable length integer.
-func BenchmarkReadVarInt5(b *testing.B) {
-	buf := []byte{0xfe, 0xff, 0xff, 0xff, 0xff}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarInt(r)
-	}
-}
-
-// BenchmarkReadVarInt9 performs a benchmark on how long it takes to read
-// a nine byte variable length integer.
-func BenchmarkReadVarInt9(b *testing.B) {
-	buf := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarInt(r)
-	}
-}
-
-// BenchmarkReadVarStr4 performs a benchmark on how long it takes to read a
-// four byte variable length string.
-func BenchmarkReadVarStr4(b *testing.B) {
-	buf := []byte{0x04, 't', 'e', 's', 't'}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarString(r, 0)
-	}
-}
-
-// BenchmarkReadVarStr10 performs a benchmark on how long it takes to read a
-// ten byte variable length string.
-func BenchmarkReadVarStr10(b *testing.B) {
-	buf := []byte{0x0a, 't', 'e', 's', 't', '0', '1', '2', '3', '4', '5'}
-	r := bytes.NewReader(buf)
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		ReadVarString(r, 0)
-	}
-}
-
-// BenchmarkWriteVarStr4 performs a benchmark on how long it takes to write a
-// four byte variable length string.
-func BenchmarkWriteVarStr4(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarString(ioutil.Discard, "test")
-	}
-}
-
-// BenchmarkWriteVarStr10 performs a benchmark on how long it takes to write a
-// ten byte variable length string.
-func BenchmarkWriteVarStr10(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		WriteVarString(ioutil.Discard, "test012345")
-	}
-}
-
-// BenchmarkReadOutpoint performs a benchmark on how long it takes to read a
-// transaction outpoint.
-func BenchmarkReadOutpoint(b *testing.B) {
-	buf := []byte{
-		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, // Previous output index
-	}
-	r := bytes.NewReader(buf)
-	var op Outpoint
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		readOutpoint(r, 0, 0, &op)
-	}
-}
-
-// BenchmarkWriteOutpoint performs a benchmark on how long it takes to write a
-// transaction outpoint.
-func BenchmarkWriteOutpoint(b *testing.B) {
-	op := &Outpoint{
-		TxID:  daghash.TxID{},
-		Index: 0,
-	}
-	for i := 0; i < b.N; i++ {
-		writeOutpoint(ioutil.Discard, 0, 0, op)
-	}
-}
-
-// BenchmarkReadTxOut performs a benchmark on how long it takes to read a
-// transaction output.
-func BenchmarkReadTxOut(b *testing.B) {
-	buf := []byte{
-		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 signature
-		0xac, // OP_CHECKSIG
-	}
-	r := bytes.NewReader(buf)
-	var txOut TxOut
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		readTxOut(r, 0, 0, &txOut)
-		scriptPool.Return(txOut.ScriptPubKey)
-	}
-}
-
-// BenchmarkWriteTxOut performs a benchmark on how long it takes to write
-// a transaction output.
-func BenchmarkWriteTxOut(b *testing.B) {
-	txOut := blockOne.Transactions[0].TxOut[0]
-	for i := 0; i < b.N; i++ {
-		WriteTxOut(ioutil.Discard, 0, 0, txOut)
-	}
-}
-
-// BenchmarkReadTxIn performs a benchmark on how long it takes to read a
-// transaction input.
-func BenchmarkReadTxIn(b *testing.B) {
-	buf := []byte{
-		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, // Previous output index
-		0x07,                                     // Varint for length of signature script
-		0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, // Signature script
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
-	}
-	r := bytes.NewReader(buf)
-	var txIn TxIn
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		readTxIn(r, 0, 0, &txIn)
-		scriptPool.Return(txIn.SignatureScript)
-	}
-}
-
-// BenchmarkWriteTxIn performs a benchmark on how long it takes to write
-// a transaction input.
-func BenchmarkWriteTxIn(b *testing.B) {
-	txIn := blockOne.Transactions[0].TxIn[0]
-	for i := 0; i < b.N; i++ {
-		writeTxIn(ioutil.Discard, 0, 0, txIn, txEncodingFull)
-	}
-}
-
-// BenchmarkDeserializeTx performs a benchmark on how long it takes to
-// deserialize a small transaction.
-func BenchmarkDeserializeTxSmall(b *testing.B) {
-	buf := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version
-		0x01, // Varint for number of input transactions
-		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
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
-		0x01,                                           // Varint for number of output transactions
-		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 signature
-		0xac,                                           // OP_CHECKSIG
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
-	}
-
-	r := bytes.NewReader(buf)
-	var tx MsgTx
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		tx.Deserialize(r)
-	}
-}
-
-// BenchmarkDeserializeTxLarge performs a benchmark on how long it takes to
-// deserialize a very large transaction.
-func BenchmarkDeserializeTxLarge(b *testing.B) {
-	fi, err := os.Open("testdata/megatx.bin.bz2")
-	if err != nil {
-		b.Fatalf("Failed to read transaction data: %v", err)
-	}
-	defer fi.Close()
-	buf, err := ioutil.ReadAll(bzip2.NewReader(fi))
-	if err != nil {
-		b.Fatalf("Failed to read transaction data: %v", err)
-	}
-
-	r := bytes.NewReader(buf)
-	var tx MsgTx
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		tx.Deserialize(r)
-	}
-}
-
-// BenchmarkSerializeTx performs a benchmark on how long it takes to serialize
-// a transaction.
-func BenchmarkSerializeTx(b *testing.B) {
-	tx := blockOne.Transactions[0]
-	for i := 0; i < b.N; i++ {
-		tx.Serialize(ioutil.Discard)
-
-	}
-}
-
-// BenchmarkReadBlockHeader performs a benchmark on how long it takes to
-// deserialize a block header.
-func BenchmarkReadBlockHeader(b *testing.B) {
-	buf := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version 1
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // PrevBlock
-		0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2,
-		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, // MerkleRoot
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
-		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
-		0x00, // TxnCount Varint
-	}
-	r := bytes.NewReader(buf)
-	var header BlockHeader
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		readBlockHeader(r, 0, &header)
-	}
-}
-
-// BenchmarkWriteBlockHeader performs a benchmark on how long it takes to
-// serialize a block header.
-func BenchmarkWriteBlockHeader(b *testing.B) {
-	header := blockOne.Header
-	for i := 0; i < b.N; i++ {
-		writeBlockHeader(ioutil.Discard, 0, &header)
-	}
-}
-
-// BenchmarkTxHash performs a benchmark on how long it takes to hash a
-// transaction.
-func BenchmarkTxHash(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		genesisCoinbaseTx.TxHash()
-	}
-}
-
-// BenchmarkDoubleHashB performs a benchmark on how long it takes to perform a
-// double hash returning a byte slice.
-func BenchmarkDoubleHashB(b *testing.B) {
-	var buf bytes.Buffer
-	if err := genesisCoinbaseTx.Serialize(&buf); err != nil {
-		b.Errorf("Serialize: unexpected error: %v", err)
-		return
-	}
-	txBytes := buf.Bytes()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = daghash.DoubleHashB(txBytes)
-	}
-}
-
-// BenchmarkDoubleHashH performs a benchmark on how long it takes to perform
-// a double hash returning a daghash.Hash.
-func BenchmarkDoubleHashH(b *testing.B) {
-	var buf bytes.Buffer
-	if err := genesisCoinbaseTx.Serialize(&buf); err != nil {
-		b.Errorf("Serialize: unexpected error: %v", err)
-		return
-	}
-	txBytes := buf.Bytes()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = daghash.DoubleHashH(txBytes)
-	}
-}
-
-// BenchmarkDoubleHashWriter performs a benchmark on how long it takes to perform
-// a double hash via the writer returning a daghash.Hash.
-func BenchmarkDoubleHashWriter(b *testing.B) {
-	var buf bytes.Buffer
-	err := genesisCoinbaseTx.Serialize(&buf)
-	if err != nil {
-		b.Fatalf("Serialize: unexpected error: %+v", err)
-	}
-	txBytes := buf.Bytes()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		writer := daghash.NewDoubleHashWriter()
-		_, _ = writer.Write(txBytes)
-		writer.Finalize()
-	}
-}

app/appmessage/common.go

@@ -5,34 +5,12 @@
 package appmessage
 
 import (
-	"encoding/binary"
-	"fmt"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-	"github.com/kaspanet/kaspad/util/binaryserializer"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
 	"github.com/pkg/errors"
-	"io"
-	"math"
 )
 
-// MaxVarIntPayload is the maximum payload size for a variable length integer.
-const MaxVarIntPayload = 9
-
 // MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
 const MaxInvPerMsg = 1 << 17
 
-var (
-	// littleEndian is a convenience variable since binary.LittleEndian is
-	// quite long.
-	littleEndian = binary.LittleEndian
-
-	// bigEndian is a convenience variable since binary.BigEndian is quite
-	// long.
-	bigEndian = binary.BigEndian
-)
-
 // errNonCanonicalVarInt is the common format string used for non-canonically
 // encoded variable length integer errors.
 var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
@@ -40,473 +18,3 @@ var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
 
 // errNoEncodingForType signifies that there's no encoding for the given type.
 var errNoEncodingForType = errors.New("there's no encoding for this type")
-
-// int64Time represents a unix timestamp with milliseconds precision encoded with
-// an int64. It is used as a way to signal the readElement function how to decode
-// a timestamp into a Go mstime.Time since it is otherwise ambiguous.
-type int64Time mstime.Time
-
-// ReadElement reads the next sequence of bytes from r using little endian
-// depending on the concrete type of element pointed to.
-func ReadElement(r io.Reader, element interface{}) error {
-	// Attempt to read the element based on the concrete type via fast
-	// type assertions first.
-	switch e := element.(type) {
-	case *int32:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = int32(rv)
-		return nil
-
-	case *uint32:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = rv
-		return nil
-
-	case *int64:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = int64(rv)
-		return nil
-
-	case *uint64:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = rv
-		return nil
-
-	case *uint8:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		*e = rv
-		return nil
-
-	case *bool:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		if rv == 0x00 {
-			*e = false
-		} else {
-			*e = true
-		}
-		return nil
-
-	// Unix timestamp encoded as an int64.
-	case *int64Time:
-		rv, err := binaryserializer.Uint64(r, binary.LittleEndian)
-		if err != nil {
-			return err
-		}
-		*e = int64Time(mstime.UnixMilliseconds(int64(rv)))
-		return nil
-
-	// Message header checksum.
-	case *[4]byte:
-		_, err := io.ReadFull(r, e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	// Message header command.
-	case *MessageCommand:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = MessageCommand(rv)
-		return nil
-
-	// IP address.
-	case *[16]byte:
-		_, err := io.ReadFull(r, e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case *daghash.Hash:
-		_, err := io.ReadFull(r, e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case *id.ID:
-		return e.Deserialize(r)
-
-	case *subnetworkid.SubnetworkID:
-		_, err := io.ReadFull(r, e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case *ServiceFlag:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = ServiceFlag(rv)
-		return nil
-
-	case *KaspaNet:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = KaspaNet(rv)
-		return nil
-	}
-
-	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to read type %T", element)
-}
-
-// readElements reads multiple items from r. It is equivalent to multiple
-// calls to readElement.
-func readElements(r io.Reader, elements ...interface{}) error {
-	for _, element := range elements {
-		err := ReadElement(r, element)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// WriteElement writes the little endian representation of element to w.
-func WriteElement(w io.Writer, element interface{}) error {
-	// Attempt to write the element based on the concrete type via fast
-	// type assertions first.
-	switch e := element.(type) {
-	case int32:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case uint32:
-		err := binaryserializer.PutUint32(w, littleEndian, e)
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case int64:
-		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case uint64:
-		err := binaryserializer.PutUint64(w, littleEndian, e)
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case uint8:
-		err := binaryserializer.PutUint8(w, e)
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case bool:
-		var err error
-		if e {
-			err = binaryserializer.PutUint8(w, 0x01)
-		} else {
-			err = binaryserializer.PutUint8(w, 0x00)
-		}
-		if err != nil {
-			return err
-		}
-		return nil
-
-	// Message header checksum.
-	case [4]byte:
-		_, err := w.Write(e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	// Message header command.
-	case MessageCommand:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	// IP address.
-	case [16]byte:
-		_, err := w.Write(e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case *daghash.Hash:
-		_, err := w.Write(e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case *id.ID:
-		return e.Serialize(w)
-
-	case *subnetworkid.SubnetworkID:
-		_, err := w.Write(e[:])
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case ServiceFlag:
-		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case KaspaNet:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-	}
-
-	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to write type %T", element)
-}
-
-// writeElements writes multiple items to w. It is equivalent to multiple
-// calls to writeElement.
-func writeElements(w io.Writer, elements ...interface{}) error {
-	for _, element := range elements {
-		err := WriteElement(w, element)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// ReadVarInt reads a variable length integer from r and returns it as a uint64.
-func ReadVarInt(r io.Reader) (uint64, error) {
-	discriminant, err := binaryserializer.Uint8(r)
-	if err != nil {
-		return 0, err
-	}
-
-	var rv uint64
-	switch discriminant {
-	case 0xff:
-		sv, err := binaryserializer.Uint64(r, littleEndian)
-		if err != nil {
-			return 0, err
-		}
-		rv = sv
-
-		// The encoding is not canonical if the value could have been
-		// encoded using fewer bytes.
-		min := uint64(0x100000000)
-		if rv < min {
-			return 0, messageError("readVarInt", fmt.Sprintf(
-				errNonCanonicalVarInt, rv, discriminant, min))
-		}
-
-	case 0xfe:
-		sv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return 0, err
-		}
-		rv = uint64(sv)
-
-		// The encoding is not canonical if the value could have been
-		// encoded using fewer bytes.
-		min := uint64(0x10000)
-		if rv < min {
-			return 0, messageError("readVarInt", fmt.Sprintf(
-				errNonCanonicalVarInt, rv, discriminant, min))
-		}
-
-	case 0xfd:
-		sv, err := binaryserializer.Uint16(r, littleEndian)
-		if err != nil {
-			return 0, err
-		}
-		rv = uint64(sv)
-
-		// The encoding is not canonical if the value could have been
-		// encoded using fewer bytes.
-		min := uint64(0xfd)
-		if rv < min {
-			return 0, messageError("readVarInt", fmt.Sprintf(
-				errNonCanonicalVarInt, rv, discriminant, min))
-		}
-
-	default:
-		rv = uint64(discriminant)
-	}
-
-	return rv, nil
-}
-
-// WriteVarInt serializes val to w using a variable number of bytes depending
-// on its value.
-func WriteVarInt(w io.Writer, val uint64) error {
-	if val < 0xfd {
-		_, err := w.Write([]byte{uint8(val)})
-		return errors.WithStack(err)
-	}
-
-	if val <= math.MaxUint16 {
-		var buf [3]byte
-		buf[0] = 0xfd
-		littleEndian.PutUint16(buf[1:], uint16(val))
-		_, err := w.Write(buf[:])
-		return errors.WithStack(err)
-	}
-
-	if val <= math.MaxUint32 {
-		var buf [5]byte
-		buf[0] = 0xfe
-		littleEndian.PutUint32(buf[1:], uint32(val))
-		_, err := w.Write(buf[:])
-		return errors.WithStack(err)
-	}
-
-	var buf [9]byte
-	buf[0] = 0xff
-	littleEndian.PutUint64(buf[1:], val)
-	_, err := w.Write(buf[:])
-	return errors.WithStack(err)
-}
-
-// VarIntSerializeSize returns the number of bytes it would take to serialize
-// val as a variable length integer.
-func VarIntSerializeSize(val uint64) int {
-	// The value is small enough to be represented by itself, so it's
-	// just 1 byte.
-	if val < 0xfd {
-		return 1
-	}
-
-	// Discriminant 1 byte plus 2 bytes for the uint16.
-	if val <= math.MaxUint16 {
-		return 3
-	}
-
-	// Discriminant 1 byte plus 4 bytes for the uint32.
-	if val <= math.MaxUint32 {
-		return 5
-	}
-
-	// Discriminant 1 byte plus 8 bytes for the uint64.
-	return 9
-}
-
-// ReadVarString reads a variable length string from r and returns it as a Go
-// string. A variable length string is encoded as a variable length integer
-// containing the length of the string followed by the bytes that represent the
-// string itself. An error is returned if the length is greater than the
-// maximum block payload size since it helps protect against memory exhaustion
-// attacks and forced panics through malformed messages.
-func ReadVarString(r io.Reader, pver uint32) (string, error) {
-	count, err := ReadVarInt(r)
-	if err != nil {
-		return "", err
-	}
-
-	// Prevent variable length strings that are larger than the maximum
-	// message size. It would be possible to cause memory exhaustion and
-	// panics without a sane upper bound on this count.
-	if count > MaxMessagePayload {
-		str := fmt.Sprintf("variable length string is too long "+
-			"[count %d, max %d]", count, MaxMessagePayload)
-		return "", messageError("ReadVarString", str)
-	}
-
-	buf := make([]byte, count)
-	_, err = io.ReadFull(r, buf)
-	if err != nil {
-		return "", err
-	}
-	return string(buf), nil
-}
-
-// WriteVarString serializes str to w as a variable length integer containing
-// the length of the string followed by the bytes that represent the string
-// itself.
-func WriteVarString(w io.Writer, str string) error {
-	err := WriteVarInt(w, uint64(len(str)))
-	if err != nil {
-		return err
-	}
-	_, err = w.Write([]byte(str))
-	return err
-}
-
-// ReadVarBytes reads a variable length byte array. A byte array is encoded
-// as a varInt containing the length of the array followed by the bytes
-// themselves. An error is returned if the length is greater than the
-// passed maxAllowed parameter which helps protect against memory exhaustion
-// attacks and forced panics through malformed messages. The fieldName
-// parameter is only used for the error message so it provides more context in
-// the error.
-func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
-	fieldName string) ([]byte, error) {
-
-	count, err := ReadVarInt(r)
-	if err != nil {
-		return nil, err
-	}
-
-	// Prevent byte array larger than the max message size. It would
-	// be possible to cause memory exhaustion and panics without a sane
-	// upper bound on this count.
-	if count > uint64(maxAllowed) {
-		str := fmt.Sprintf("%s is larger than the max allowed size "+
-			"[count %d, max %d]", fieldName, count, maxAllowed)
-		return nil, messageError("ReadVarBytes", str)
-	}
-
-	b := make([]byte, count)
-	_, err = io.ReadFull(r, b)
-	if err != nil {
-		return nil, err
-	}
-	return b, nil
-}
-
-// WriteVarBytes serializes a variable length byte array to w as a varInt
-// containing the number of bytes, followed by the bytes themselves.
-func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
-	slen := uint64(len(bytes))
-	err := WriteVarInt(w, slen)
-	if err != nil {
-		return err
-	}
-
-	_, err = w.Write(bytes)
-	return err
-}

app/appmessage/common_test.go

@@ -1,695 +1,44 @@
-// 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"
-	"github.com/pkg/errors"
-	"io"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
-)
+import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 // mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainnetGenesisHash = &daghash.Hash{
+var mainnetGenesisHash = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
 	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
 	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
-}
+})
 
 // simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simnetGenesisHash = &daghash.Hash{
-	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a,
-	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
-	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
-	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-}
+var simnetGenesisHash = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
+	0x9d, 0x89, 0xb0, 0x6e, 0xb3, 0x47, 0xb5, 0x6e,
+	0xcd, 0x6c, 0x63, 0x99, 0x45, 0x91, 0xd5, 0xce,
+	0x9b, 0x43, 0x05, 0xc1, 0xa5, 0x5e, 0x2a, 0xda,
+	0x90, 0x4c, 0xf0, 0x6c, 0x4d, 0x5f, 0xd3, 0x62,
+})
 
 // mainnetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
-var mainnetGenesisMerkleRoot = &daghash.Hash{
+var mainnetGenesisMerkleRoot = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-}
+})
 
-var exampleAcceptedIDMerkleRoot = &daghash.Hash{
+var exampleAcceptedIDMerkleRoot = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-}
+})
 
-var exampleUTXOCommitment = &daghash.Hash{
+var exampleUTXOCommitment = externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-}
-
-// TestElementEncoding tests appmessage encode and decode for various element types. This
-// is mainly to test the "fast" paths in readElement and writeElement which use
-// type assertions to avoid reflection when possible.
-func TestElementEncoding(t *testing.T) {
-	tests := []struct {
-		in  interface{} // Value to encode
-		buf []byte      // Encoded value
-	}{
-		{int32(1), []byte{0x01, 0x00, 0x00, 0x00}},
-		{uint32(256), []byte{0x00, 0x01, 0x00, 0x00}},
-		{
-			int64(65536),
-			[]byte{0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
-		},
-		{
-			uint64(4294967296),
-			[]byte{0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
-		},
-		{
-			true,
-			[]byte{0x01},
-		},
-		{
-			false,
-			[]byte{0x00},
-		},
-		{
-			[4]byte{0x01, 0x02, 0x03, 0x04},
-			[]byte{0x01, 0x02, 0x03, 0x04},
-		},
-		{
-			MessageCommand(0x10),
-			[]byte{
-				0x10, 0x00, 0x00, 0x00,
-			},
-		},
-		{
-			[16]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-			},
-			[]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-			},
-		},
-		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-			}),
-			[]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-			},
-		},
-		{
-			ServiceFlag(SFNodeNetwork),
-			[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-		},
-		{
-			KaspaNet(Mainnet),
-			[]byte{0x1d, 0xf7, 0xdc, 0x3d},
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Write to appmessage format.
-		var buf bytes.Buffer
-		err := WriteElement(&buf, test.in)
-		if err != nil {
-			t.Errorf("writeElement #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("writeElement #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Read from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		val := test.in
-		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
-			val = reflect.New(reflect.TypeOf(test.in)).Interface()
-		}
-		err = ReadElement(rbuf, val)
-		if err != nil {
-			t.Errorf("readElement #%d error %v", i, err)
-			continue
-		}
-		ival := val
-		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
-			ival = reflect.Indirect(reflect.ValueOf(val)).Interface()
-		}
-		if !reflect.DeepEqual(ival, test.in) {
-			t.Errorf("readElement #%d\n got: %s want: %s", i,
-				spew.Sdump(ival), spew.Sdump(test.in))
-			continue
-		}
-	}
-}
-
-// TestElementEncodingErrors performs negative tests against appmessage encode and decode
-// of various element types to confirm error paths work correctly.
-func TestElementEncodingErrors(t *testing.T) {
-	type writeElementReflect int32
-
-	tests := []struct {
-		in       interface{} // Value to encode
-		max      int         // Max size of fixed buffer to induce errors
-		writeErr error       // Expected write error
-		readErr  error       // Expected read error
-	}{
-		{int32(1), 0, io.ErrShortWrite, io.EOF},
-		{uint32(256), 0, io.ErrShortWrite, io.EOF},
-		{int64(65536), 0, io.ErrShortWrite, io.EOF},
-		{true, 0, io.ErrShortWrite, io.EOF},
-		{[4]byte{0x01, 0x02, 0x03, 0x04}, 0, io.ErrShortWrite, io.EOF},
-		{
-			MessageCommand(10),
-			0, io.ErrShortWrite, io.EOF,
-		},
-		{
-			[16]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-			},
-			0, io.ErrShortWrite, io.EOF,
-		},
-		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-				0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-			}),
-			0, io.ErrShortWrite, io.EOF,
-		},
-		{ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF},
-		{KaspaNet(Mainnet), 0, io.ErrShortWrite, io.EOF},
-		// Type with no supported encoding.
-		{writeElementReflect(0), 0, errNoEncodingForType, errNoEncodingForType},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := WriteElement(w, test.in)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("writeElement #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		r := newFixedReader(test.max, nil)
-		val := test.in
-		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
-			val = reflect.New(reflect.TypeOf(test.in)).Interface()
-		}
-		err = ReadElement(r, val)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("readElement #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestVarIntEncoding tests appmessage encode and decode for variable length integers.
-func TestVarIntEncoding(t *testing.T) {
-	tests := []struct {
-		value uint64 // Value to encode
-		buf   []byte // Encoded value
-	}{
-		// Latest protocol version.
-		// Single byte
-		{0, []byte{0x00}},
-		// Max single byte
-		{0xfc, []byte{0xfc}},
-		// Min 2-byte
-		{0xfd, []byte{0xfd, 0x0fd, 0x00}},
-		// Max 2-byte
-		{0xffff, []byte{0xfd, 0xff, 0xff}},
-		// Min 4-byte
-		{0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
-		// Max 4-byte
-		{0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
-		// Min 8-byte
-		{
-			0x100000000,
-			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
-		},
-		// Max 8-byte
-		{
-			0xffffffffffffffff,
-			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		buf := &bytes.Buffer{}
-		err := WriteVarInt(buf, test.value)
-		if err != nil {
-			t.Errorf("WriteVarInt #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("WriteVarInt #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		val, err := ReadVarInt(rbuf)
-		if err != nil {
-			t.Errorf("ReadVarInt #%d error %v", i, err)
-			continue
-		}
-		if val != test.value {
-			t.Errorf("ReadVarInt #%d\n got: %x want: %x", i,
-				val, test.value)
-			continue
-		}
-	}
-}
-
-// TestVarIntEncodingErrors performs negative tests against appmessage encode and decode
-// of variable length integers to confirm error paths work correctly.
-func TestVarIntEncodingErrors(t *testing.T) {
-	tests := []struct {
-		in       uint64 // Value to encode
-		buf      []byte // Encoded value
-		max      int    // Max size of fixed buffer to induce errors
-		writeErr error  // Expected write error
-		readErr  error  // Expected read error
-	}{
-		// Force errors on discriminant.
-		{0, []byte{0x00}, 0, io.ErrShortWrite, io.EOF},
-		// Force errors on 2-byte read/write.
-		{0xfd, []byte{0xfd}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
-		{0xfd, []byte{0xfd}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
-		// Force errors on 4-byte read/write.
-		{0x10000, []byte{0xfe}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
-		{0x10000, []byte{0xfe}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
-		// Force errors on 8-byte read/write.
-		{0x100000000, []byte{0xff}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
-		{0x100000000, []byte{0xff}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := WriteVarInt(w, test.in)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		r := newFixedReader(test.max, test.buf)
-		_, err = ReadVarInt(r)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestVarIntNonCanonical ensures variable length integers that are not encoded
-// canonically return the expected error.
-func TestVarIntNonCanonical(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		name string // Test name for easier identification
-		in   []byte // Value to decode
-		pver uint32 // Protocol version for appmessage encoding
-	}{
-		{
-			"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
-			pver,
-		},
-		{
-			"max single-byte value encoded with 3 bytes",
-			[]byte{0xfd, 0xfc, 0x00}, pver,
-		},
-		{
-			"0 encoded with 5 bytes",
-			[]byte{0xfe, 0x00, 0x00, 0x00, 0x00}, pver,
-		},
-		{
-			"max three-byte value encoded with 5 bytes",
-			[]byte{0xfe, 0xff, 0xff, 0x00, 0x00}, pver,
-		},
-		{
-			"0 encoded with 9 bytes",
-			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-			pver,
-		},
-		{
-			"max five-byte value encoded with 9 bytes",
-			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
-			pver,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.in)
-		val, err := ReadVarInt(rbuf)
-		if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
-			t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i,
-				test.name, err)
-			continue
-		}
-		if val != 0 {
-			t.Errorf("ReadVarInt #%d (%s)\n got: %d want: 0", i,
-				test.name, val)
-			continue
-		}
-	}
-}
-
-// TestVarIntEncoding tests the serialize size for variable length integers.
-func TestVarIntSerializeSize(t *testing.T) {
-	tests := []struct {
-		val  uint64 // Value to get the serialized size for
-		size int    // Expected serialized size
-	}{
-		// Single byte
-		{0, 1},
-		// Max single byte
-		{0xfc, 1},
-		// Min 2-byte
-		{0xfd, 3},
-		// Max 2-byte
-		{0xffff, 3},
-		// Min 4-byte
-		{0x10000, 5},
-		// Max 4-byte
-		{0xffffffff, 5},
-		// Min 8-byte
-		{0x100000000, 9},
-		// Max 8-byte
-		{0xffffffffffffffff, 9},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		serializedSize := VarIntSerializeSize(test.val)
-		if serializedSize != test.size {
-			t.Errorf("VarIntSerializeSize #%d got: %d, want: %d", i,
-				serializedSize, test.size)
-			continue
-		}
-	}
-}
-
-// TestVarStringEncoding tests appmessage encode and decode for variable length strings.
-func TestVarStringEncoding(t *testing.T) {
-	pver := ProtocolVersion
-
-	// str256 is a string that takes a 2-byte varint to encode.
-	str256 := strings.Repeat("test", 64)
-
-	tests := []struct {
-		in   string // String to encode
-		out  string // String to decoded value
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version.
-		// Empty string
-		{"", "", []byte{0x00}, pver},
-		// Single byte varint + string
-		{"Test", "Test", append([]byte{0x04}, []byte("Test")...), pver},
-		// 2-byte varint + string
-		{str256, str256, append([]byte{0xfd, 0x00, 0x01}, []byte(str256)...), pver},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		var buf bytes.Buffer
-		err := WriteVarString(&buf, test.in)
-		if err != nil {
-			t.Errorf("WriteVarString #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("WriteVarString #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		val, err := ReadVarString(rbuf, test.pver)
-		if err != nil {
-			t.Errorf("ReadVarString #%d error %v", i, err)
-			continue
-		}
-		if val != test.out {
-			t.Errorf("ReadVarString #%d\n got: %s want: %s", i,
-				val, test.out)
-			continue
-		}
-	}
-}
-
-// TestVarStringEncodingErrors performs negative tests against appmessage encode and
-// decode of variable length strings to confirm error paths work correctly.
-func TestVarStringEncodingErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	// str256 is a string that takes a 2-byte varint to encode.
-	str256 := strings.Repeat("test", 64)
-
-	tests := []struct {
-		in       string // Value to encode
-		buf      []byte // Encoded value
-		pver     uint32 // Protocol version for appmessage encoding
-		max      int    // Max size of fixed buffer to induce errors
-		writeErr error  // Expected write error
-		readErr  error  // Expected read error
-	}{
-		// Latest protocol version with intentional read/write errors.
-		// Force errors on empty string.
-		{"", []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
-		// Force error on single byte varint + string.
-		{"Test", []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
-		// Force errors on 2-byte varint + string.
-		{str256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := WriteVarString(w, test.in)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("WriteVarString #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		r := newFixedReader(test.max, test.buf)
-		_, err = ReadVarString(r, test.pver)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("ReadVarString #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestVarStringOverflowErrors performs tests to ensure deserializing variable
-// length strings intentionally crafted to use large values for the string
-// length are handled properly. This could otherwise potentially be used as an
-// attack vector.
-func TestVarStringOverflowErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-		err  error  // Expected error
-	}{
-		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
-			pver, &MessageError{}},
-		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
-			pver, &MessageError{}},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		_, err := ReadVarString(rbuf, test.pver)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("ReadVarString #%d wrong error got: %v, "+
-				"want: %v", i, err, reflect.TypeOf(test.err))
-			continue
-		}
-	}
-
-}
-
-// TestVarBytesEncoding tests appmessage encode and decode for variable length byte array.
-func TestVarBytesEncoding(t *testing.T) {
-	pver := ProtocolVersion
-
-	// bytes256 is a byte array that takes a 2-byte varint to encode.
-	bytes256 := bytes.Repeat([]byte{0x01}, 256)
-
-	tests := []struct {
-		in   []byte // Byte Array to write
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version.
-		// Empty byte array
-		{[]byte{}, []byte{0x00}, pver},
-		// Single byte varint + byte array
-		{[]byte{0x01}, []byte{0x01, 0x01}, pver},
-		// 2-byte varint + byte array
-		{bytes256, append([]byte{0xfd, 0x00, 0x01}, bytes256...), pver},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		var buf bytes.Buffer
-		err := WriteVarBytes(&buf, test.pver, test.in)
-		if err != nil {
-			t.Errorf("WriteVarBytes #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("WriteVarBytes #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
-			"test payload")
-		if err != nil {
-			t.Errorf("ReadVarBytes #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("ReadVarBytes #%d\n got: %s want: %s", i,
-				val, test.buf)
-			continue
-		}
-	}
-}
-
-// TestVarBytesEncodingErrors performs negative tests against appmessage encode and
-// decode of variable length byte arrays to confirm error paths work correctly.
-func TestVarBytesEncodingErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	// bytes256 is a byte array that takes a 2-byte varint to encode.
-	bytes256 := bytes.Repeat([]byte{0x01}, 256)
-
-	tests := []struct {
-		in       []byte // Byte Array to write
-		buf      []byte // Encoded value
-		pver     uint32 // Protocol version for appmessage encoding
-		max      int    // Max size of fixed buffer to induce errors
-		writeErr error  // Expected write error
-		readErr  error  // Expected read error
-	}{
-		// Latest protocol version with intentional read/write errors.
-		// Force errors on empty byte array.
-		{[]byte{}, []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
-		// Force error on single byte varint + byte array.
-		{[]byte{0x01, 0x02, 0x03}, []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
-		// Force errors on 2-byte varint + byte array.
-		{bytes256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := WriteVarBytes(w, test.pver, test.in)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		r := newFixedReader(test.max, test.buf)
-		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
-			"test payload")
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestVarBytesOverflowErrors performs tests to ensure deserializing variable
-// length byte arrays intentionally crafted to use large values for the array
-// length are handled properly. This could otherwise potentially be used as an
-// attack vector.
-func TestVarBytesOverflowErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-		err  error  // Expected error
-	}{
-		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
-			pver, &MessageError{}},
-		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
-			pver, &MessageError{}},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Decode from appmessage format.
-		rbuf := bytes.NewReader(test.buf)
-		_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
-			"test payload")
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("ReadVarBytes #%d wrong error got: %v, "+
-				"want: %v", i, err, reflect.TypeOf(test.err))
-			continue
-		}
-	}
-
-}
+})

app/appmessage/domainconverters.go

@@ -0,0 +1,270 @@
+package appmessage
+
+import (
+	"encoding/hex"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
+	"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.BlockHeader to MsgBlockHeader
+func DomainBlockHeaderToBlockHeader(domainBlockHeader externalapi.BlockHeader) *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.BlockHeader
+func BlockHeaderToDomainBlockHeader(blockHeader *MsgBlockHeader) externalapi.BlockHeader {
+	return blockheader.NewImmutableBlockHeader(
+		blockHeader.Version,
+		blockHeader.ParentHashes,
+		blockHeader.HashMerkleRoot,
+		blockHeader.AcceptedIDMerkleRoot,
+		blockHeader.UTXOCommitment,
+		blockHeader.Timestamp.UnixMilliseconds(),
+		blockHeader.Bits,
+		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,
+	}
+}
+
+// RPCTransactionToDomainTransaction converts RPCTransactions to DomainTransactions
+func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externalapi.DomainTransaction, error) {
+	inputs := make([]*externalapi.DomainTransactionInput, len(rpcTransaction.Inputs))
+	for i, input := range rpcTransaction.Inputs {
+		transactionIDBytes, err := hex.DecodeString(input.PreviousOutpoint.TransactionID)
+		if err != nil {
+			return nil, err
+		}
+		transactionID, err := transactionid.FromBytes(transactionIDBytes)
+		if err != nil {
+			return nil, err
+		}
+		previousOutpoint := &externalapi.DomainOutpoint{
+			TransactionID: *transactionID,
+			Index:         input.PreviousOutpoint.Index,
+		}
+		signatureScript, err := hex.DecodeString(input.SignatureScript)
+		if err != nil {
+			return nil, err
+		}
+		inputs[i] = &externalapi.DomainTransactionInput{
+			PreviousOutpoint: *previousOutpoint,
+			SignatureScript:  signatureScript,
+			Sequence:         input.Sequence,
+		}
+	}
+	outputs := make([]*externalapi.DomainTransactionOutput, len(rpcTransaction.Outputs))
+	for i, output := range rpcTransaction.Outputs {
+		scriptPublicKey, err := hex.DecodeString(output.ScriptPublicKey.Script)
+		if err != nil {
+			return nil, err
+		}
+		outputs[i] = &externalapi.DomainTransactionOutput{
+			Value:           output.Amount,
+			ScriptPublicKey: &externalapi.ScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
+		}
+	}
+
+	subnetworkIDBytes, err := hex.DecodeString(rpcTransaction.SubnetworkID)
+	if err != nil {
+		return nil, err
+	}
+	subnetworkID, err := subnetworks.FromBytes(subnetworkIDBytes)
+	if err != nil {
+		return nil, err
+	}
+	payloadHashBytes, err := hex.DecodeString(rpcTransaction.PayloadHash)
+	if err != nil {
+		return nil, err
+	}
+	payloadHash, err := externalapi.NewDomainHashFromByteSlice(payloadHashBytes)
+	if err != nil {
+		return nil, err
+	}
+	payload, err := hex.DecodeString(rpcTransaction.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	return &externalapi.DomainTransaction{
+		Version:      rpcTransaction.Version,
+		Inputs:       inputs,
+		Outputs:      outputs,
+		LockTime:     rpcTransaction.LockTime,
+		SubnetworkID: *subnetworkID,
+		Gas:          rpcTransaction.LockTime,
+		PayloadHash:  *payloadHash,
+		Payload:      payload,
+	}, nil
+}
+
+// DomainTransactionToRPCTransaction converts DomainTransactions to RPCTransactions
+func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransaction) *RPCTransaction {
+	inputs := make([]*RPCTransactionInput, len(transaction.Inputs))
+	for i, input := range transaction.Inputs {
+		transactionID := input.PreviousOutpoint.TransactionID.String()
+		previousOutpoint := &RPCOutpoint{
+			TransactionID: transactionID,
+			Index:         input.PreviousOutpoint.Index,
+		}
+		signatureScript := hex.EncodeToString(input.SignatureScript)
+		inputs[i] = &RPCTransactionInput{
+			PreviousOutpoint: previousOutpoint,
+			SignatureScript:  signatureScript,
+			Sequence:         input.Sequence,
+		}
+	}
+	outputs := make([]*RPCTransactionOutput, len(transaction.Outputs))
+	for i, output := range transaction.Outputs {
+		scriptPublicKey := hex.EncodeToString(output.ScriptPublicKey.Script)
+		outputs[i] = &RPCTransactionOutput{
+			Amount:          output.Value,
+			ScriptPublicKey: &RPCScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
+		}
+	}
+	subnetworkID := hex.EncodeToString(transaction.SubnetworkID[:])
+	payloadHash := transaction.PayloadHash.String()
+	payload := hex.EncodeToString(transaction.Payload)
+	return &RPCTransaction{
+		Version:      transaction.Version,
+		Inputs:       inputs,
+		Outputs:      outputs,
+		LockTime:     transaction.LockTime,
+		SubnetworkID: subnetworkID,
+		Gas:          transaction.LockTime,
+		PayloadHash:  payloadHash,
+		Payload:      payload,
+	}
+}

app/appmessage/message.go

@@ -34,24 +34,34 @@ const (
 	CmdVerAck
 	CmdRequestAddresses
 	CmdAddresses
-	CmdRequestIBDBlocks
+	CmdRequestHeaders
 	CmdBlock
 	CmdTx
 	CmdPing
 	CmdPong
 	CmdRequestBlockLocator
 	CmdBlockLocator
-	CmdSelectedTip
-	CmdRequestSelectedTip
 	CmdInvRelayBlock
 	CmdRequestRelayBlocks
 	CmdInvTransaction
 	CmdRequestTransactions
 	CmdIBDBlock
-	CmdRequestNextIBDBlocks
-	CmdDoneIBDBlocks
+	CmdDoneHeaders
 	CmdTransactionNotFound
 	CmdReject
+	CmdHeader
+	CmdRequestNextHeaders
+	CmdRequestIBDRootUTXOSetAndBlock
+	CmdIBDRootUTXOSetChunk
+	CmdRequestIBDBlocks
+	CmdIBDRootNotFound
+	CmdRequestIBDRootHash
+	CmdIBDRootHash
+	CmdIBDBlockLocator
+	CmdIBDBlockLocatorHighestHash
+	CmdBlockHeaders
+	CmdRequestNextIBDRootUTXOSetChunk
+	CmdDoneIBDRootUTXOSetChunks
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -76,15 +86,15 @@ const (
 	CmdAddPeerResponseMessage
 	CmdSubmitTransactionRequestMessage
 	CmdSubmitTransactionResponseMessage
-	CmdNotifyChainChangedRequestMessage
-	CmdNotifyChainChangedResponseMessage
-	CmdChainChangedNotificationMessage
+	CmdNotifyVirtualSelectedParentChainChangedRequestMessage
+	CmdNotifyVirtualSelectedParentChainChangedResponseMessage
+	CmdVirtualSelectedParentChainChangedNotificationMessage
 	CmdGetBlockRequestMessage
 	CmdGetBlockResponseMessage
 	CmdGetSubnetworkRequestMessage
 	CmdGetSubnetworkResponseMessage
-	CmdGetChainFromBlockRequestMessage
-	CmdGetChainFromBlockResponseMessage
+	CmdGetVirtualSelectedParentChainFromBlockRequestMessage
+	CmdGetVirtualSelectedParentChainFromBlockResponseMessage
 	CmdGetBlocksRequestMessage
 	CmdGetBlocksResponseMessage
 	CmdGetBlockCountRequestMessage
@@ -101,81 +111,115 @@ const (
 	CmdGetMempoolEntriesResponseMessage
 	CmdShutDownRequestMessage
 	CmdShutDownResponseMessage
+	CmdGetHeadersRequestMessage
+	CmdGetHeadersResponseMessage
+	CmdNotifyUTXOsChangedRequestMessage
+	CmdNotifyUTXOsChangedResponseMessage
+	CmdUTXOsChangedNotificationMessage
+	CmdGetUTXOsByAddressesRequestMessage
+	CmdGetUTXOsByAddressesResponseMessage
+	CmdGetVirtualSelectedParentBlueScoreRequestMessage
+	CmdGetVirtualSelectedParentBlueScoreResponseMessage
+	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
+	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
+	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
 var ProtocolMessageCommandToString = map[MessageCommand]string{
-	CmdVersion:              "Version",
-	CmdVerAck:               "VerAck",
-	CmdRequestAddresses:     "RequestAddresses",
-	CmdAddresses:            "Addresses",
-	CmdRequestIBDBlocks:     "RequestBlocks",
-	CmdBlock:                "Block",
-	CmdTx:                   "Tx",
-	CmdPing:                 "Ping",
-	CmdPong:                 "Pong",
-	CmdRequestBlockLocator:  "RequestBlockLocator",
-	CmdBlockLocator:         "BlockLocator",
-	CmdSelectedTip:          "SelectedTip",
-	CmdRequestSelectedTip:   "RequestSelectedTip",
-	CmdInvRelayBlock:        "InvRelayBlock",
-	CmdRequestRelayBlocks:   "RequestRelayBlocks",
-	CmdInvTransaction:       "InvTransaction",
-	CmdRequestTransactions:  "RequestTransactions",
-	CmdIBDBlock:             "IBDBlock",
-	CmdRequestNextIBDBlocks: "RequestNextIBDBlocks",
-	CmdDoneIBDBlocks:        "DoneIBDBlocks",
-	CmdTransactionNotFound:  "TransactionNotFound",
-	CmdReject:               "Reject",
+	CmdVersion:                        "Version",
+	CmdVerAck:                         "VerAck",
+	CmdRequestAddresses:               "RequestAddresses",
+	CmdAddresses:                      "Addresses",
+	CmdRequestHeaders:                 "RequestHeaders",
+	CmdBlock:                          "Block",
+	CmdTx:                             "Tx",
+	CmdPing:                           "Ping",
+	CmdPong:                           "Pong",
+	CmdRequestBlockLocator:            "RequestBlockLocator",
+	CmdBlockLocator:                   "BlockLocator",
+	CmdInvRelayBlock:                  "InvRelayBlock",
+	CmdRequestRelayBlocks:             "RequestRelayBlocks",
+	CmdInvTransaction:                 "InvTransaction",
+	CmdRequestTransactions:            "RequestTransactions",
+	CmdIBDBlock:                       "IBDBlock",
+	CmdDoneHeaders:                    "DoneHeaders",
+	CmdTransactionNotFound:            "TransactionNotFound",
+	CmdReject:                         "Reject",
+	CmdHeader:                         "Header",
+	CmdRequestNextHeaders:             "RequestNextHeaders",
+	CmdRequestIBDRootUTXOSetAndBlock:  "RequestPruningUTXOSetAndBlock",
+	CmdIBDRootUTXOSetChunk:            "IBDRootUTXOSetChunk",
+	CmdRequestIBDBlocks:               "RequestIBDBlocks",
+	CmdIBDRootNotFound:                "IBDRootNotFound",
+	CmdRequestIBDRootHash:             "IBDRequestIBDRootHash",
+	CmdIBDRootHash:                    "IBDIBDRootHash",
+	CmdIBDBlockLocator:                "IBDBlockLocator",
+	CmdIBDBlockLocatorHighestHash:     "IBDBlockLocatorHighestHash",
+	CmdBlockHeaders:                   "BlockHeaders",
+	CmdRequestNextIBDRootUTXOSetChunk: "RequestNextIBDRootUTXOSetChunk",
+	CmdDoneIBDRootUTXOSetChunks:       "DoneIBDRootUTXOSetChunks",
 }
 
 // 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",
+	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",
+	CmdNotifyVirtualSelectedParentChainChangedRequestMessage:      "NotifyVirtualSelectedParentChainChangedRequest",
+	CmdNotifyVirtualSelectedParentChainChangedResponseMessage:     "NotifyVirtualSelectedParentChainChangedResponse",
+	CmdVirtualSelectedParentChainChangedNotificationMessage:       "VirtualSelectedParentChainChangedNotification",
+	CmdGetBlockRequestMessage:                                     "GetBlockRequest",
+	CmdGetBlockResponseMessage:                                    "GetBlockResponse",
+	CmdGetSubnetworkRequestMessage:                                "GetSubnetworkRequest",
+	CmdGetSubnetworkResponseMessage:                               "GetSubnetworkResponse",
+	CmdGetVirtualSelectedParentChainFromBlockRequestMessage:       "GetVirtualSelectedParentChainFromBlockRequest",
+	CmdGetVirtualSelectedParentChainFromBlockResponseMessage:      "GetVirtualSelectedParentChainFromBlockResponse",
+	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:                            "GetMempoolEntriesRequest",
+	CmdGetMempoolEntriesResponseMessage:                           "GetMempoolEntriesResponse",
+	CmdGetHeadersRequestMessage:                                   "GetHeadersRequest",
+	CmdGetHeadersResponseMessage:                                  "GetHeadersResponse",
+	CmdNotifyUTXOsChangedRequestMessage:                           "NotifyUTXOsChangedRequest",
+	CmdNotifyUTXOsChangedResponseMessage:                          "NotifyUTXOsChangedResponse",
+	CmdUTXOsChangedNotificationMessage:                            "UTXOsChangedNotification",
+	CmdGetUTXOsByAddressesRequestMessage:                          "GetUTXOsByAddressesRequest",
+	CmdGetUTXOsByAddressesResponseMessage:                         "GetUTXOsByAddressesResponse",
+	CmdGetVirtualSelectedParentBlueScoreRequestMessage:            "GetVirtualSelectedParentBlueScoreRequest",
+	CmdGetVirtualSelectedParentBlueScoreResponseMessage:           "GetVirtualSelectedParentBlueScoreResponse",
+	CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage:  "NotifyVirtualSelectedParentBlueScoreChangedRequest",
+	CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage: "NotifyVirtualSelectedParentBlueScoreChangedResponse",
+	CmdVirtualSelectedParentBlueScoreChangedNotificationMessage:   "VirtualSelectedParentBlueScoreChangedNotification",
 }
 
 // Message is an interface that describes a kaspa message. A type that

app/appmessage/p2p_blockheader.go

@@ -1,195 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/pkg/errors"
-	"io"
-	"math"
-)
-
-// 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) * daghash.HashSize should be
-// added to this value
-const BaseBlockHeaderPayload = 25 + 3*(daghash.HashSize)
-
-// 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 * daghash.HashSize)
-
-// BlockHeader defines information about a block and is used in the kaspa
-// block (MsgBlock) and headers (MsgHeader) messages.
-type BlockHeader struct {
-	// Version of the block. This is not the same as the protocol version.
-	Version int32
-
-	// Hashes of the parent block headers in the blockDAG.
-	ParentHashes []*daghash.Hash
-
-	// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
-	HashMerkleRoot *daghash.Hash
-
-	// AcceptedIDMerkleRoot is merkle tree reference to hash all transactions
-	// accepted form the block.Blues
-	AcceptedIDMerkleRoot *daghash.Hash
-
-	// UTXOCommitment is an ECMH UTXO commitment to the block UTXO.
-	UTXOCommitment *daghash.Hash
-
-	// Time the block was created.
-	Timestamp mstime.Time
-
-	// Difficulty target for the block.
-	Bits uint32
-
-	// Nonce used to generate the block.
-	Nonce uint64
-}
-
-// NumParentBlocks return the number of entries in ParentHashes
-func (h *BlockHeader) NumParentBlocks() byte {
-	numParents := len(h.ParentHashes)
-	if numParents > math.MaxUint8 {
-		panic(errors.Errorf("number of parents is %d, which is more than one byte can fit", numParents))
-	}
-	return byte(numParents)
-}
-
-// BlockHash computes the block identifier hash for the given block header.
-func (h *BlockHeader) BlockHash() *daghash.Hash {
-	// Encode the header and double sha256 everything prior to the number of
-	// transactions.
-	writer := daghash.NewDoubleHashWriter()
-	err := writeBlockHeader(writer, 0, h)
-	if err != nil {
-		// It seems like this could only happen if the writer returned an error.
-		// and this writer should never return an error (no allocations or possible failures)
-		// the only non-writer error path here is unknown types in `WriteElement`
-		panic(fmt.Sprintf("BlockHash() failed. this should never fail unless BlockHeader was changed. err: %+v", err))
-	}
-
-	res := writer.Finalize()
-	return &res
-}
-
-// IsGenesis returns true iff this block is a genesis block
-func (h *BlockHeader) IsGenesis() bool {
-	return h.NumParentBlocks() == 0
-}
-
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-// See Deserialize for decoding block headers stored to disk, such as in a
-// database, as opposed to decoding block headers from the appmessage.
-func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
-	return readBlockHeader(r, pver, h)
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-// See Serialize for encoding block headers to be stored to disk, such as in a
-// database, as opposed to encoding block headers for the appmessage.
-func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
-	return writeBlockHeader(w, pver, h)
-}
-
-// Deserialize decodes a block header from r into the receiver using a format
-// that is suitable for long-term storage such as a database while respecting
-// the Version field.
-func (h *BlockHeader) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of readBlockHeader.
-	return readBlockHeader(r, 0, h)
-}
-
-// Serialize encodes a block header from r into the receiver using a format
-// that is suitable for long-term storage such as a database while respecting
-// the Version field.
-func (h *BlockHeader) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of writeBlockHeader.
-	return writeBlockHeader(w, 0, h)
-}
-
-// SerializeSize returns the number of bytes it would take to serialize the
-// block header.
-func (h *BlockHeader) SerializeSize() int {
-	return BaseBlockHeaderPayload + int(h.NumParentBlocks())*daghash.HashSize
-}
-
-// NewBlockHeader returns a new BlockHeader using the provided version, previous
-// block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
-// block with defaults or calclulated values for the remaining fields.
-func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot *daghash.Hash,
-	acceptedIDMerkleRoot *daghash.Hash, utxoCommitment *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
-
-	// Limit the timestamp to one millisecond precision since the protocol
-	// doesn't support better.
-	return &BlockHeader{
-		Version:              version,
-		ParentHashes:         parentHashes,
-		HashMerkleRoot:       hashMerkleRoot,
-		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
-		UTXOCommitment:       utxoCommitment,
-		Timestamp:            mstime.Now(),
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-}
-
-// readBlockHeader reads a kaspa block header from r. See Deserialize for
-// decoding block headers stored to disk, such as in a database, as opposed to
-// decoding from the appmessage.
-func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
-	var numParentBlocks byte
-	err := readElements(r, &bh.Version, &numParentBlocks)
-	if err != nil {
-		return err
-	}
-
-	bh.ParentHashes = make([]*daghash.Hash, numParentBlocks)
-	for i := byte(0); i < numParentBlocks; i++ {
-		hash := &daghash.Hash{}
-		err := ReadElement(r, hash)
-		if err != nil {
-			return err
-		}
-		bh.ParentHashes[i] = hash
-	}
-	bh.HashMerkleRoot = &daghash.Hash{}
-	bh.AcceptedIDMerkleRoot = &daghash.Hash{}
-	bh.UTXOCommitment = &daghash.Hash{}
-	return readElements(r, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment,
-		(*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
-}
-
-// writeBlockHeader writes a kaspa block header to w. See Serialize for
-// encoding block headers to be stored to disk, such as in a database, as
-// opposed to encoding for the appmessage.
-func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
-	timestamp := bh.Timestamp.UnixMilliseconds()
-	if err := writeElements(w, bh.Version, bh.NumParentBlocks()); err != nil {
-		return err
-	}
-	for _, hash := range bh.ParentHashes {
-		if err := WriteElement(w, hash); err != nil {
-			return err
-		}
-	}
-	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, timestamp, bh.Bits, bh.Nonce)
-}

app/appmessage/p2p_blockheader_test.go

@@ -1,345 +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"
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/random"
-	"reflect"
-	"testing"
-)
-
-// TestBlockHeader tests the BlockHeader API.
-func TestBlockHeader(t *testing.T) {
-	nonce, err := random.Uint64()
-	if err != nil {
-		t.Errorf("random.Uint64: Error generating nonce: %v", err)
-	}
-
-	hashes := []*daghash.Hash{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.IsEqual(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)
-	}
-}
-
-// TestBlockHeaderEncoding tests the BlockHeader appmessage encode and decode for various
-// protocol versions.
-func TestBlockHeaderEncoding(t *testing.T) {
-	nonce := uint64(123123) // 0x000000000001e0f3
-	pver := ProtocolVersion
-
-	// baseBlockHdr is used in the various tests as a baseline BlockHeader.
-	bits := uint32(0x1d00ffff)
-	baseBlockHdr := &BlockHeader{
-		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot:       mainnetGenesisMerkleRoot,
-		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
-		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-
-	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
-	baseBlockHdrEncoded := []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
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
-	}
-
-	tests := []struct {
-		in   *BlockHeader // Data to encode
-		out  *BlockHeader // Expected decoded data
-		buf  []byte       // Encoded data
-		pver uint32       // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version.
-		{
-			baseBlockHdr,
-			baseBlockHdr,
-			baseBlockHdrEncoded,
-			ProtocolVersion,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		var buf bytes.Buffer
-		err := writeBlockHeader(&buf, test.pver, test.in)
-		if err != nil {
-			t.Errorf("writeBlockHeader #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("writeBlockHeader #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		buf.Reset()
-		err = test.in.KaspaEncode(&buf, pver)
-		if err != nil {
-			t.Errorf("KaspaEncode #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode the block header from appmessage format.
-		var bh BlockHeader
-		rbuf := bytes.NewReader(test.buf)
-		err = readBlockHeader(rbuf, test.pver, &bh)
-		if err != nil {
-			t.Errorf("readBlockHeader #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&bh, test.out) {
-			t.Errorf("readBlockHeader #%d\n got: %s want: %s", i,
-				spew.Sdump(&bh), spew.Sdump(test.out))
-			continue
-		}
-
-		rbuf = bytes.NewReader(test.buf)
-		err = bh.KaspaDecode(rbuf, pver)
-		if err != nil {
-			t.Errorf("KaspaDecode #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&bh, test.out) {
-			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
-				spew.Sdump(&bh), spew.Sdump(test.out))
-			continue
-		}
-	}
-}
-
-// TestBlockHeaderSerialize tests BlockHeader serialize and deserialize.
-func TestBlockHeaderSerialize(t *testing.T) {
-	nonce := uint64(123123) // 0x01e0f3
-
-	// baseBlockHdr is used in the various tests as a baseline BlockHeader.
-	bits := uint32(0x1d00ffff)
-	baseBlockHdr := &BlockHeader{
-		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot:       mainnetGenesisMerkleRoot,
-		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
-		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-
-	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
-	baseBlockHdrEncoded := []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
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
-	}
-
-	tests := []struct {
-		in  *BlockHeader // Data to encode
-		out *BlockHeader // Expected decoded data
-		buf []byte       // Serialized data
-	}{
-		{
-			baseBlockHdr,
-			baseBlockHdr,
-			baseBlockHdrEncoded,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Serialize the block header.
-		var buf bytes.Buffer
-		err := test.in.Serialize(&buf)
-		if err != nil {
-			t.Errorf("Serialize #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("Serialize #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Deserialize the block header.
-		var bh BlockHeader
-		rbuf := bytes.NewReader(test.buf)
-		err = bh.Deserialize(rbuf)
-		if err != nil {
-			t.Errorf("Deserialize #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&bh, test.out) {
-			t.Errorf("Deserialize #%d\n got: %s want: %s", i,
-				spew.Sdump(&bh), spew.Sdump(test.out))
-			continue
-		}
-	}
-}
-
-// TestBlockHeaderSerializeSize performs tests to ensure the serialize size for
-// various block headers is accurate.
-func TestBlockHeaderSerializeSize(t *testing.T) {
-	nonce := uint64(123123) // 0x1e0f3
-	bits := uint32(0x1d00ffff)
-	timestamp := mstime.UnixMilliseconds(0x495fab29000)
-	baseBlockHdr := &BlockHeader{
-		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot:       mainnetGenesisMerkleRoot,
-		AcceptedIDMerkleRoot: &daghash.ZeroHash,
-		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            timestamp,
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-
-	genesisBlockHdr := &BlockHeader{
-		Version:              1,
-		ParentHashes:         []*daghash.Hash{},
-		HashMerkleRoot:       mainnetGenesisMerkleRoot,
-		AcceptedIDMerkleRoot: &daghash.ZeroHash,
-		UTXOCommitment:       &daghash.ZeroHash,
-		Timestamp:            timestamp,
-		Bits:                 bits,
-		Nonce:                nonce,
-	}
-	tests := []struct {
-		in   *BlockHeader // Block header to encode
-		size int          // Expected serialized size
-	}{
-		// Block with no transactions.
-		{genesisBlockHdr, 121},
-
-		// First block in the mainnet block DAG.
-		{baseBlockHdr, 185},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		serializedSize := test.in.SerializeSize()
-		if serializedSize != test.size {
-			t.Errorf("BlockHeader.SerializeSize: #%d got: %d, want: "+
-				"%d", i, serializedSize, test.size)
-
-			continue
-		}
-	}
-}
-
-func TestIsGenesis(t *testing.T) {
-	nonce := uint64(123123) // 0x1e0f3
-	bits := uint32(0x1d00ffff)
-	timestamp := mstime.UnixMilliseconds(0x495fab29000)
-
-	baseBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
-		HashMerkleRoot: mainnetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
-	}
-	genesisBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{},
-		HashMerkleRoot: mainnetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
-	}
-
-	tests := []struct {
-		in        *BlockHeader // Block header to encode
-		isGenesis bool         // Expected result for call of .IsGenesis
-	}{
-		{genesisBlockHdr, true},
-		{baseBlockHdr, false},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		isGenesis := test.in.IsGenesis()
-		if isGenesis != test.isGenesis {
-			t.Errorf("BlockHeader.IsGenesis: #%d got: %t, want: %t",
-				i, isGenesis, test.isGenesis)
-		}
-	}
-}

app/appmessage/p2p_blockheaders.go

@@ -0,0 +1,19 @@
+package appmessage
+
+// BlockHeadersMessage represents a kaspa BlockHeaders message
+type BlockHeadersMessage struct {
+	baseMessage
+	BlockHeaders []*MsgBlockHeader
+}
+
+// Command returns the protocol command string for the message
+func (msg *BlockHeadersMessage) Command() MessageCommand {
+	return CmdBlockHeaders
+}
+
+// NewBlockHeadersMessage returns a new kaspa BlockHeaders message
+func NewBlockHeadersMessage(blockHeaders []*MsgBlockHeader) *BlockHeadersMessage {
+	return &BlockHeadersMessage{
+		BlockHeaders: blockHeaders,
+	}
+}

app/appmessage/p2p_ibdrootnotfound.go

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

app/appmessage/p2p_msgaddresses.go

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

app/appmessage/p2p_msgaddresses_test.go

@@ -1,58 +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"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// TestAddresses tests the MsgAddresses API.
-func TestAddresses(t *testing.T) {
-	// Ensure the command is expected value.
-	wantCmd := MessageCommand(3)
-	msg := NewMsgAddresses(false, nil)
-	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
-			cmd, wantCmd)
-	}
-
-	// Ensure NetAddresses are added properly.
-	tcpAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
-	na := NewNetAddress(tcpAddr, SFNodeNetwork)
-	err := msg.AddAddress(na)
-	if err != nil {
-		t.Errorf("AddAddress: %v", err)
-	}
-	if msg.AddrList[0] != na {
-		t.Errorf("AddAddress: wrong address added - got %v, want %v",
-			spew.Sprint(msg.AddrList[0]), spew.Sprint(na))
-	}
-
-	// Ensure the address list is cleared properly.
-	msg.ClearAddresses()
-	if len(msg.AddrList) != 0 {
-		t.Errorf("ClearAddresses: address list is not empty - "+
-			"got %v [%v], want %v", len(msg.AddrList),
-			spew.Sprint(msg.AddrList[0]), 0)
-	}
-
-	// Ensure adding more than the max allowed addresses per message returns
-	// error.
-	for i := 0; i < MaxAddressesPerMsg+1; i++ {
-		err = msg.AddAddress(na)
-	}
-	if err == nil {
-		t.Errorf("AddAddress: expected error on too many addresses " +
-			"not received")
-	}
-	err = msg.AddAddresses(na)
-	if err == nil {
-		t.Errorf("AddAddresses: expected error on too many addresses " +
-			"not received")
-	}
-}

app/appmessage/p2p_msgblock.go

@@ -5,13 +5,7 @@
 package appmessage
 
 import (
-	"bytes"
-	"fmt"
-	"io"
-
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // defaultTransactionAlloc is the default size used for the backing array
@@ -46,7 +40,7 @@ type TxLoc struct {
 // response to a getdata message (MsgGetData) for a given block hash.
 type MsgBlock struct {
 	baseMessage
-	Header       BlockHeader
+	Header       MsgBlockHeader
 	Transactions []*MsgTx
 }
 
@@ -60,161 +54,6 @@ func (msg *MsgBlock) ClearTransactions() {
 	msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-// See Deserialize for decoding blocks stored to disk, such as in a database, as
-// opposed to decoding blocks from the appmessage.
-func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
-	err := readBlockHeader(r, pver, &msg.Header)
-	if err != nil {
-		return err
-	}
-
-	txCount, err := ReadVarInt(r)
-	if err != nil {
-		return err
-	}
-
-	// Prevent more transactions than could possibly fit into a block.
-	// It would be possible to cause memory exhaustion and panics without
-	// a sane upper bound on this count.
-	if txCount > MaxTxPerBlock {
-		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, MaxTxPerBlock)
-		return messageError("MsgBlock.KaspaDecode", str)
-	}
-
-	msg.Transactions = make([]*MsgTx, 0, txCount)
-	for i := uint64(0); i < txCount; i++ {
-		tx := MsgTx{}
-		err := tx.KaspaDecode(r, pver)
-		if err != nil {
-			return err
-		}
-		msg.Transactions = append(msg.Transactions, &tx)
-	}
-
-	return nil
-}
-
-// Deserialize decodes a block from r into the receiver using a format that is
-// suitable for long-term storage such as a database while respecting the
-// Version field in the block. This function differs from KaspaDecode in that
-// KaspaDecode decodes from the kaspa appmessage protocol as it was sent across the
-// network. The appmessage encoding can technically differ depending on the protocol
-// version and doesn't even really need to match the format of a stored block at
-// all. As of the time this comment was written, the encoded block is the same
-// in both instances, but there is a distinct difference and separating the two
-// allows the API to be flexible enough to deal with changes.
-func (msg *MsgBlock) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of KaspaDecode.
-	return msg.KaspaDecode(r, 0)
-}
-
-// DeserializeTxLoc decodes r in the same manner Deserialize does, but it takes
-// a byte buffer instead of a generic reader and returns a slice containing the
-// start and length of each transaction within the raw data that is being
-// deserialized.
-func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
-	fullLen := r.Len()
-
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of existing appmessage protocol functions.
-	err := readBlockHeader(r, 0, &msg.Header)
-	if err != nil {
-		return nil, err
-	}
-
-	txCount, err := ReadVarInt(r)
-	if err != nil {
-		return nil, err
-	}
-
-	// Prevent more transactions than could possibly fit into a block.
-	// It would be possible to cause memory exhaustion and panics without
-	// a sane upper bound on this count.
-	if txCount > MaxTxPerBlock {
-		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, MaxTxPerBlock)
-		return nil, messageError("MsgBlock.DeserializeTxLoc", str)
-	}
-
-	// Deserialize each transaction while keeping track of its location
-	// within the byte stream.
-	msg.Transactions = make([]*MsgTx, 0, txCount)
-	txLocs := make([]TxLoc, txCount)
-	for i := uint64(0); i < txCount; i++ {
-		txLocs[i].TxStart = fullLen - r.Len()
-		tx := MsgTx{}
-		err := tx.Deserialize(r)
-		if err != nil {
-			return nil, err
-		}
-		msg.Transactions = append(msg.Transactions, &tx)
-		txLocs[i].TxLen = (fullLen - r.Len()) - txLocs[i].TxStart
-	}
-
-	return txLocs, nil
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-// See Serialize for encoding blocks to be stored to disk, such as in a
-// database, as opposed to encoding blocks for the appmessage.
-func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
-	err := writeBlockHeader(w, pver, &msg.Header)
-	if err != nil {
-		return err
-	}
-
-	err = WriteVarInt(w, uint64(len(msg.Transactions)))
-	if err != nil {
-		return err
-	}
-
-	for _, tx := range msg.Transactions {
-		err = tx.KaspaEncode(w, pver)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Serialize encodes the block to w using a format that suitable for long-term
-// storage such as a database while respecting the Version field in the block.
-// This function differs from KaspaEncode in that KaspaEncode encodes the block to
-// the kaspa appmessage protocol in order to be sent across the network. The appmessage
-// encoding can technically differ depending on the protocol version and doesn't
-// even really need to match the format of a stored block at all. As of the
-// time this comment was written, the encoded block is the same in both
-// instances, but there is a distinct difference and separating the two allows
-// the API to be flexible enough to deal with changes.
-func (msg *MsgBlock) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of KaspaEncode.
-	return msg.KaspaEncode(w, 0)
-}
-
-// SerializeSize returns the number of bytes it would take to serialize the
-// block.
-func (msg *MsgBlock) SerializeSize() int {
-	// Block header bytes + Serialized varint size for the number of
-	// transactions.
-	n := msg.Header.SerializeSize() + VarIntSerializeSize(uint64(len(msg.Transactions)))
-
-	for _, tx := range msg.Transactions {
-		n += tx.SerializeSize()
-	}
-
-	return n
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
 func (msg *MsgBlock) Command() MessageCommand {
@@ -227,17 +66,12 @@ func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
 	return MaxMessagePayload
 }
 
-// BlockHash computes the block identifier hash for this block.
-func (msg *MsgBlock) BlockHash() *daghash.Hash {
-	return msg.Header.BlockHash()
-}
-
 // 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 *subnetworkid.SubnetworkID) {
+func (msg *MsgBlock) ConvertToPartial(subnetworkID *externalapi.DomainSubnetworkID) {
 	for _, tx := range msg.Transactions {
-		if !tx.SubnetworkID.IsEqual(subnetworkID) {
+		if !tx.SubnetworkID.Equal(subnetworkID) {
 			tx.Payload = []byte{}
 		}
 	}
@@ -245,7 +79,7 @@ func (msg *MsgBlock) ConvertToPartial(subnetworkID *subnetworkid.SubnetworkID) {
 
 // NewMsgBlock returns a new kaspa block message that conforms to the
 // Message interface. See MsgBlock for details.
-func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
+func NewMsgBlock(blockHeader *MsgBlockHeader) *MsgBlock {
 	return &MsgBlock{
 		Header:       *blockHeader,
 		Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),

app/appmessage/p2p_msgblock_test.go

@@ -5,17 +5,15 @@
 package appmessage
 
 import (
-	"bytes"
+	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/util/mstime"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-	"github.com/pkg/errors"
-	"io"
 	"math"
 	"reflect"
 	"testing"
 
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // TestBlock tests the MsgBlock API.
@@ -71,46 +69,31 @@ func TestBlock(t *testing.T) {
 	}
 }
 
-// TestBlockHash tests the ability to generate the hash of a block accurately.
-func TestBlockHash(t *testing.T) {
-	// Block 1 hash.
-	hashStr := "55d71bd49a8233bc9f0edbcbd0ad5d3eaebffe1fc6a6443a1c1f310fd02c11a5"
-	wantHash, err := daghash.NewHashFromStr(hashStr)
-	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
-	}
-
-	// Ensure the hash produced is expected.
-	blockHash := blockOne.BlockHash()
-	if !blockHash.IsEqual(wantHash) {
-		t.Errorf("BlockHash: wrong hash - got %v, want %v",
-			spew.Sprint(blockHash), spew.Sprint(wantHash))
-	}
-}
-
 func TestConvertToPartial(t *testing.T) {
+	localSubnetworkID := &externalapi.DomainSubnetworkID{0x12}
+
 	transactions := []struct {
-		subnetworkID          *subnetworkid.SubnetworkID
+		subnetworkID          *externalapi.DomainSubnetworkID
 		payload               []byte
 		expectedPayloadLength int
 	}{
 		{
-			subnetworkID:          subnetworkid.SubnetworkIDNative,
+			subnetworkID:          &subnetworks.SubnetworkIDNative,
 			payload:               []byte{},
 			expectedPayloadLength: 0,
 		},
 		{
-			subnetworkID:          subnetworkid.SubnetworkIDRegistry,
+			subnetworkID:          &subnetworks.SubnetworkIDRegistry,
 			payload:               []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
 			expectedPayloadLength: 0,
 		},
 		{
-			subnetworkID:          &subnetworkid.SubnetworkID{123},
+			subnetworkID:          localSubnetworkID,
 			payload:               []byte{0x01},
 			expectedPayloadLength: 1,
 		},
 		{
-			subnetworkID:          &subnetworkid.SubnetworkID{234},
+			subnetworkID:          &externalapi.DomainSubnetworkID{0x34},
 			payload:               []byte{0x02},
 			expectedPayloadLength: 0,
 		},
@@ -122,388 +105,33 @@ func TestConvertToPartial(t *testing.T) {
 		block.Transactions = append(block.Transactions, NewSubnetworkMsgTx(1, nil, nil, transaction.subnetworkID, 0, payload))
 	}
 
-	block.ConvertToPartial(&subnetworkid.SubnetworkID{123})
+	block.ConvertToPartial(localSubnetworkID)
 
-	for _, transaction := range transactions {
+	for _, testTransaction := range transactions {
 		var subnetworkTx *MsgTx
-		for _, tx := range block.Transactions {
-			if tx.SubnetworkID.IsEqual(transaction.subnetworkID) {
-				subnetworkTx = tx
+		for _, blockTransaction := range block.Transactions {
+			if blockTransaction.SubnetworkID.Equal(testTransaction.subnetworkID) {
+				subnetworkTx = blockTransaction
 			}
 		}
 		if subnetworkTx == nil {
-			t.Errorf("ConvertToPartial: subnetworkID '%s' not found in block!", transaction.subnetworkID)
+			t.Errorf("ConvertToPartial: subnetworkID '%s' not found in block!", testTransaction.subnetworkID)
 			continue
 		}
 
 		payloadLength := len(subnetworkTx.Payload)
-		if payloadLength != transaction.expectedPayloadLength {
+		if payloadLength != testTransaction.expectedPayloadLength {
 			t.Errorf("ConvertToPartial: unexpected payload length for subnetwork '%s': expected: %d, got: %d",
-				transaction.subnetworkID, transaction.expectedPayloadLength, payloadLength)
+				testTransaction.subnetworkID, testTransaction.expectedPayloadLength, payloadLength)
 		}
 	}
 }
 
-// TestBlockEncoding tests the MsgBlock appmessage encode and decode for various numbers
-// of transaction inputs and outputs and protocol versions.
-func TestBlockEncoding(t *testing.T) {
-	tests := []struct {
-		in     *MsgBlock // Message to encode
-		out    *MsgBlock // Expected decoded message
-		buf    []byte    // Encoded value
-		txLocs []TxLoc   // Expected transaction locations
-		pver   uint32    // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version.
-		{
-			&blockOne,
-			&blockOne,
-			blockOneBytes,
-			blockOneTxLocs,
-			ProtocolVersion,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode the message to appmessage format.
-		var buf bytes.Buffer
-		err := test.in.KaspaEncode(&buf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaEncode #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode the message from appmessage format.
-		var msg MsgBlock
-		rbuf := bytes.NewReader(test.buf)
-		err = msg.KaspaDecode(rbuf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaDecode #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&msg, test.out) {
-			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
-				spew.Sdump(&msg), spew.Sdump(test.out))
-			continue
-		}
-	}
-}
-
-// TestBlockEncodingErrors performs negative tests against appmessage encode and decode
-// of MsgBlock to confirm error paths work correctly.
-func TestBlockEncodingErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		in       *MsgBlock // Value to encode
-		buf      []byte    // Encoded value
-		pver     uint32    // Protocol version for appmessage encoding
-		max      int       // Max size of fixed buffer to induce errors
-		writeErr error     // Expected write error
-		readErr  error     // Expected read error
-	}{
-		// Force error in version.
-		{&blockOne, blockOneBytes, pver, 0, io.ErrShortWrite, io.EOF},
-		// Force error in num block hashes.
-		{&blockOne, blockOneBytes, pver, 4, io.ErrShortWrite, io.EOF},
-		// Force error in prev block hash #1.
-		{&blockOne, blockOneBytes, pver, 5, io.ErrShortWrite, io.EOF},
-		// Force error in prev block hash #2.
-		{&blockOne, blockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
-		// Force error in hash merkle root.
-		{&blockOne, blockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
-		// Force error in accepted ID merkle root.
-		{&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
-		// Force error in utxo commitment.
-		{&blockOne, blockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
-		// Force error in timestamp.
-		{&blockOne, blockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
-		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, pver, 173, io.ErrShortWrite, io.EOF},
-		// Force error in header nonce.
-		{&blockOne, blockOneBytes, pver, 177, io.ErrShortWrite, io.EOF},
-		// Force error in transaction count.
-		{&blockOne, blockOneBytes, pver, 185, io.ErrShortWrite, io.EOF},
-		// Force error in transactions.
-		{&blockOne, blockOneBytes, pver, 186, io.ErrShortWrite, io.EOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := test.in.KaspaEncode(w, test.pver)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		var msg MsgBlock
-		r := newFixedReader(test.max, test.buf)
-		err = msg.KaspaDecode(r, test.pver)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestBlockSerialize tests MsgBlock serialize and deserialize.
-func TestBlockSerialize(t *testing.T) {
-	tests := []struct {
-		in     *MsgBlock // Message to encode
-		out    *MsgBlock // Expected decoded message
-		buf    []byte    // Serialized data
-		txLocs []TxLoc   // Expected transaction locations
-	}{
-		{
-			&blockOne,
-			&blockOne,
-			blockOneBytes,
-			blockOneTxLocs,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Serialize the block.
-		var buf bytes.Buffer
-		err := test.in.Serialize(&buf)
-		if err != nil {
-			t.Errorf("Serialize #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("Serialize #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Deserialize the block.
-		var block MsgBlock
-		rbuf := bytes.NewReader(test.buf)
-		err = block.Deserialize(rbuf)
-		if err != nil {
-			t.Errorf("Deserialize #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&block, test.out) {
-			t.Errorf("Deserialize #%d\n got: %s want: %s", i,
-				spew.Sdump(&block), spew.Sdump(test.out))
-			continue
-		}
-
-		// Deserialize the block while gathering transaction location
-		// information.
-		var txLocBlock MsgBlock
-		br := bytes.NewBuffer(test.buf)
-		txLocs, err := txLocBlock.DeserializeTxLoc(br)
-		if err != nil {
-			t.Errorf("DeserializeTxLoc #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&txLocBlock, test.out) {
-			t.Errorf("DeserializeTxLoc #%d\n got: %s want: %s", i,
-				spew.Sdump(&txLocBlock), spew.Sdump(test.out))
-			continue
-		}
-		if !reflect.DeepEqual(txLocs, test.txLocs) {
-			t.Errorf("DeserializeTxLoc #%d\n got: %s want: %s", i,
-				spew.Sdump(txLocs), spew.Sdump(test.txLocs))
-			continue
-		}
-	}
-}
-
-// TestBlockSerializeErrors performs negative tests against appmessage encode and
-// decode of MsgBlock to confirm error paths work correctly.
-func TestBlockSerializeErrors(t *testing.T) {
-	tests := []struct {
-		in       *MsgBlock // Value to encode
-		buf      []byte    // Serialized data
-		max      int       // Max size of fixed buffer to induce errors
-		writeErr error     // Expected write error
-		readErr  error     // Expected read error
-	}{
-		// Force error in version.
-		{&blockOne, blockOneBytes, 0, io.ErrShortWrite, io.EOF},
-		// Force error in numParentBlocks.
-		{&blockOne, blockOneBytes, 4, io.ErrShortWrite, io.EOF},
-		// Force error in prev block hash #1.
-		{&blockOne, blockOneBytes, 5, io.ErrShortWrite, io.EOF},
-		// Force error in prev block hash #2.
-		{&blockOne, blockOneBytes, 37, io.ErrShortWrite, io.EOF},
-		// Force error in hash merkle root.
-		{&blockOne, blockOneBytes, 69, io.ErrShortWrite, io.EOF},
-		// Force error in accepted ID merkle root.
-		{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
-		// Force error in utxo commitment.
-		{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
-		// Force error in timestamp.
-		{&blockOne, blockOneBytes, 165, io.ErrShortWrite, io.EOF},
-		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, 173, io.ErrShortWrite, io.EOF},
-		// Force error in header nonce.
-		{&blockOne, blockOneBytes, 177, io.ErrShortWrite, io.EOF},
-		// Force error in transaction count.
-		{&blockOne, blockOneBytes, 185, io.ErrShortWrite, io.EOF},
-		// Force error in transactions.
-		{&blockOne, blockOneBytes, 186, io.ErrShortWrite, io.EOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Serialize the block.
-		w := newFixedWriter(test.max)
-		err := test.in.Serialize(w)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Deserialize the block.
-		var block MsgBlock
-		r := newFixedReader(test.max, test.buf)
-		err = block.Deserialize(r)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-
-		var txLocBlock MsgBlock
-		br := bytes.NewBuffer(test.buf[0:test.max])
-		_, err = txLocBlock.DeserializeTxLoc(br)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestBlockOverflowErrors  performs tests to ensure deserializing blocks which
-// are intentionally crafted to use large values for the number of transactions
-// are handled properly. This could otherwise potentially be used as an attack
-// vector.
-func TestBlockOverflowErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-		err  error  // Expected error
-	}{
-		// Block that claims to have ~uint64(0) transactions.
-		{
-			[]byte{
-				0x01, 0x00, 0x00, 0x00, // Version 1
-				0x02,                                           // NumParentBlocks
-				0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainnetGenesisHash
-				0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-				0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-				0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
-				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,
-				0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // HashMerkleRoot
-				0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-				0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-				0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
-				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,
-				0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
-				0xff, 0xff, 0x00, 0x1d, // Bits
-				0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0xff, // TxnCount
-			}, pver, &MessageError{},
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Decode from appmessage format.
-		var msg MsgBlock
-		r := bytes.NewReader(test.buf)
-		err := msg.KaspaDecode(r, test.pver)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
-				i, err, reflect.TypeOf(test.err))
-			continue
-		}
-
-		// Deserialize from appmessage format.
-		r = bytes.NewReader(test.buf)
-		err = msg.Deserialize(r)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
-				i, err, reflect.TypeOf(test.err))
-			continue
-		}
-
-		// Deserialize with transaction location info from appmessage format.
-		br := bytes.NewBuffer(test.buf)
-		_, err = msg.DeserializeTxLoc(br)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, "+
-				"want: %v", i, err, reflect.TypeOf(test.err))
-			continue
-		}
-	}
-}
-
-// TestBlockSerializeSize performs tests to ensure the serialize size for
-// various blocks is accurate.
-func TestBlockSerializeSize(t *testing.T) {
-	// Block with no transactions.
-	noTxBlock := NewMsgBlock(&blockOne.Header)
-
-	tests := []struct {
-		in   *MsgBlock // Block to encode
-		size int       // Expected serialized size
-	}{
-		// Block with no transactions.
-		{noTxBlock, 186},
-
-		// First block in the mainnet block DAG.
-		{&blockOne, len(blockOneBytes)},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		serializedSize := test.in.SerializeSize()
-		if serializedSize != test.size {
-			t.Errorf("MsgBlock.SerializeSize: #%d got: %d, want: "+
-				"%d", i, serializedSize, test.size)
-
-			continue
-		}
-	}
-}
-
-// blockOne is the first block in the mainnet block DAG.
+//blockOne is the first block in the mainnet block DAG.
 var blockOne = MsgBlock{
-	Header: BlockHeader{
-		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+	Header: MsgBlockHeader{
+		Version:              0,
+		ParentHashes:         []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
@@ -516,7 +144,7 @@ var blockOne = MsgBlock{
 			[]*TxIn{
 				{
 					PreviousOutpoint: Outpoint{
-						TxID:  daghash.TxID{},
+						TxID:  externalapi.DomainTransactionID{},
 						Index: 0xffffffff,
 					},
 					SignatureScript: []byte{
@@ -528,19 +156,21 @@ var blockOne = MsgBlock{
 			[]*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
-					},
+					ScriptPubKey: &externalapi.ScriptPublicKey{
+						Script: []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
+						},
+						Version: 0},
 				},
 			}),
 	},
@@ -548,7 +178,7 @@ var blockOne = MsgBlock{
 
 // Block one serialized bytes.
 var blockOneBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, // Version 1
+	0x00, 0x00, // Version 0
 	0x02,                                           // NumParentBlocks
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
@@ -574,7 +204,7 @@ var blockOneBytes = []byte{
 	0xff, 0xff, 0x00, 0x1d, // Bits
 	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	0x01,                   // TxnCount
-	0x01, 0x00, 0x00, 0x00, // Version
+	0x00, 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,

app/appmessage/p2p_msgblockheader.go

@@ -0,0 +1,108 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"math"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+
+	"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 uint16
+
+	// 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 consensushashing.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 uint16, parentHashes []*externalapi.DomainHash, hashMerkleRoot *externalapi.DomainHash,
+	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce uint64) *MsgBlockHeader {
+
+	// Limit the timestamp to one millisecond precision since the protocol
+	// doesn't support better.
+	return &MsgBlockHeader{
+		Version:              version,
+		ParentHashes:         parentHashes,
+		HashMerkleRoot:       hashMerkleRoot,
+		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
+		UTXOCommitment:       utxoCommitment,
+		Timestamp:            mstime.Now(),
+		Bits:                 bits,
+		Nonce:                nonce,
+	}
+}

app/appmessage/p2p_msgblockheader_test.go

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

app/appmessage/p2p_msgblocklocator.go

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

app/appmessage/p2p_msgblocklocator_test.go

@@ -3,19 +3,20 @@ package appmessage
 import (
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // TestBlockLocator tests the MsgBlockLocator API.
 func TestBlockLocator(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	locatorHash, err := daghash.NewHashFromStr(hashStr)
+	locatorHash, err := externalapi.NewDomainHashFromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	msg := NewMsgBlockLocator([]*daghash.Hash{locatorHash})
+	msg := NewMsgBlockLocator([]*externalapi.DomainHash{locatorHash})
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(10)

app/appmessage/p2p_msgdoneheaders.go

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

app/appmessage/p2p_msgdoneibdblocks.go

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

app/appmessage/p2p_msgdoneibdrootutxosetchunks.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgDoneIBDRootUTXOSetChunks represents a kaspa DoneIBDRootUTXOSetChunks message
+type MsgDoneIBDRootUTXOSetChunks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgDoneIBDRootUTXOSetChunks) Command() MessageCommand {
+	return CmdDoneIBDRootUTXOSetChunks
+}
+
+// NewMsgDoneIBDRootUTXOSetChunks returns a new MsgDoneIBDRootUTXOSetChunks.
+func NewMsgDoneIBDRootUTXOSetChunks() *MsgDoneIBDRootUTXOSetChunks {
+	return &MsgDoneIBDRootUTXOSetChunks{}
+}

app/appmessage/p2p_msgibdblock_test.go

@@ -5,7 +5,6 @@
 package appmessage
 
 import (
-	"bytes"
 	"reflect"
 	"testing"
 
@@ -26,7 +25,7 @@ func TestIBDBlock(t *testing.T) {
 	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
-	wantCmd := MessageCommand(17)
+	wantCmd := MessageCommand(15)
 	msg := NewMsgIBDBlock(NewMsgBlock(bh))
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",
@@ -64,55 +63,3 @@ func TestIBDBlock(t *testing.T) {
 			len(msg.Transactions), 0)
 	}
 }
-
-// TestIBDBlockEncoding tests the MsgIBDBlock appmessage encode and decode for various numbers
-// of transaction inputs and outputs and protocol versions.
-func TestIBDBlockEncoding(t *testing.T) {
-	tests := []struct {
-		in     *MsgIBDBlock // Message to encode
-		out    *MsgIBDBlock // Expected decoded message
-		buf    []byte       // Encoded value
-		txLocs []TxLoc      // Expected transaction locations
-		pver   uint32       // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version.
-		{
-			&MsgIBDBlock{MsgBlock: &blockOne},
-			&MsgIBDBlock{MsgBlock: &blockOne},
-			blockOneBytes,
-			blockOneTxLocs,
-			ProtocolVersion,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode the message to appmessage format.
-		var buf bytes.Buffer
-		err := test.in.KaspaEncode(&buf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaEncode #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode the message from appmessage format.
-		var msg MsgIBDBlock
-		msg.MsgBlock = new(MsgBlock)
-		rbuf := bytes.NewReader(test.buf)
-		err = msg.KaspaDecode(rbuf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaDecode #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&msg, test.out) {
-			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
-				spew.Sdump(&msg), spew.Sdump(test.out))
-			continue
-		}
-	}
-}

app/appmessage/p2p_msgibdblocklocator.go

@@ -0,0 +1,27 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgIBDBlockLocator represents a kaspa ibdBlockLocator message
+type MsgIBDBlockLocator struct {
+	baseMessage
+	TargetHash         *externalapi.DomainHash
+	BlockLocatorHashes []*externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgIBDBlockLocator) Command() MessageCommand {
+	return CmdIBDBlockLocator
+}
+
+// NewMsgIBDBlockLocator returns a new kaspa ibdBlockLocator message
+func NewMsgIBDBlockLocator(targetHash *externalapi.DomainHash,
+	blockLocatorHashes []*externalapi.DomainHash) *MsgIBDBlockLocator {
+
+	return &MsgIBDBlockLocator{
+		TargetHash:         targetHash,
+		BlockLocatorHashes: blockLocatorHashes,
+	}
+}

app/appmessage/p2p_msgibdblocklocatorhighesthash.go

@@ -0,0 +1,23 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgIBDBlockLocatorHighestHash represents a kaspa BlockLocatorHighestHash message
+type MsgIBDBlockLocatorHighestHash struct {
+	baseMessage
+	HighestHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgIBDBlockLocatorHighestHash) Command() MessageCommand {
+	return CmdIBDBlockLocatorHighestHash
+}
+
+// NewMsgIBDBlockLocatorHighestHash returns a new BlockLocatorHighestHash message
+func NewMsgIBDBlockLocatorHighestHash(highestHash *externalapi.DomainHash) *MsgIBDBlockLocatorHighestHash {
+	return &MsgIBDBlockLocatorHighestHash{
+		HighestHash: highestHash,
+	}
+}

app/appmessage/p2p_msgibdroothash.go

@@ -0,0 +1,26 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgIBDRootHashMessage implements the Message interface and represents a kaspa
+// IBDRootHash message. It is used as a reply to IBD root hash requests.
+type MsgIBDRootHashMessage struct {
+	baseMessage
+	Hash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDRootHashMessage) Command() MessageCommand {
+	return CmdIBDRootHash
+}
+
+// NewMsgIBDRootHashMessage returns a new kaspa IBDRootHash message that conforms to
+// the Message interface. See MsgIBDRootHashMessage for details.
+func NewMsgIBDRootHashMessage(hash *externalapi.DomainHash) *MsgIBDRootHashMessage {
+	return &MsgIBDRootHashMessage{
+		Hash: hash,
+	}
+}

app/appmessage/p2p_msgibdrootutxosetchunk.go

@@ -0,0 +1,19 @@
+package appmessage
+
+// MsgIBDRootUTXOSetChunk represents a kaspa IBDRootUTXOSetChunk message
+type MsgIBDRootUTXOSetChunk struct {
+	baseMessage
+	Chunk []byte
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgIBDRootUTXOSetChunk) Command() MessageCommand {
+	return CmdIBDRootUTXOSetChunk
+}
+
+// NewMsgIBDRootUTXOSetChunk returns a new MsgIBDRootUTXOSetChunk.
+func NewMsgIBDRootUTXOSetChunk(chunk []byte) *MsgIBDRootUTXOSetChunk {
+	return &MsgIBDRootUTXOSetChunk{
+		Chunk: chunk,
+	}
+}

app/appmessage/p2p_msginvrelayblock.go

@@ -1,7 +1,7 @@
 package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgInvRelayBlock implements the Message interface and represents a kaspa
@@ -9,7 +9,7 @@ import (
 // by sending their hash, and let the receiving node decide if it needs it.
 type MsgInvRelayBlock struct {
 	baseMessage
-	Hash *daghash.Hash
+	Hash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -20,7 +20,7 @@ func (msg *MsgInvRelayBlock) Command() MessageCommand {
 
 // NewMsgInvBlock returns a new kaspa invrelblk message that conforms to
 // the Message interface. See MsgInvRelayBlock for details.
-func NewMsgInvBlock(hash *daghash.Hash) *MsgInvRelayBlock {
+func NewMsgInvBlock(hash *externalapi.DomainHash) *MsgInvRelayBlock {
 	return &MsgInvRelayBlock{
 		Hash: hash,
 	}

app/appmessage/p2p_msginvtransaction.go

@@ -1,7 +1,7 @@
 package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MaxInvPerTxInvMsg is the maximum number of hashes that can
@@ -13,7 +13,7 @@ const MaxInvPerTxInvMsg = MaxInvPerMsg
 // by sending their ID, and let the receiving node decide if it needs it.
 type MsgInvTransaction struct {
 	baseMessage
-	TxIDs []*daghash.TxID
+	TxIDs []*externalapi.DomainTransactionID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -24,7 +24,7 @@ func (msg *MsgInvTransaction) Command() MessageCommand {
 
 // NewMsgInvTransaction returns a new kaspa TxInv message that conforms to
 // the Message interface. See MsgInvTransaction for details.
-func NewMsgInvTransaction(ids []*daghash.TxID) *MsgInvTransaction {
+func NewMsgInvTransaction(ids []*externalapi.DomainTransactionID) *MsgInvTransaction {
 	return &MsgInvTransaction{
 		TxIDs: ids,
 	}

app/appmessage/p2p_msgrequestaddresses.go

@@ -5,7 +5,7 @@
 package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgRequestAddresses implements the Message interface and represents a kaspa
@@ -17,7 +17,7 @@ import (
 type MsgRequestAddresses struct {
 	baseMessage
 	IncludeAllSubnetworks bool
-	SubnetworkID          *subnetworkid.SubnetworkID
+	SubnetworkID          *externalapi.DomainSubnetworkID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -28,7 +28,7 @@ func (msg *MsgRequestAddresses) Command() MessageCommand {
 
 // NewMsgRequestAddresses returns a new kaspa RequestAddresses message that conforms to the
 // Message interface. See MsgRequestAddresses for details.
-func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) *MsgRequestAddresses {
+func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) *MsgRequestAddresses {
 	return &MsgRequestAddresses{
 		IncludeAllSubnetworks: includeAllSubnetworks,
 		SubnetworkID:          subnetworkID,

app/appmessage/p2p_msgrequestblocklocator.go

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

app/appmessage/p2p_msgrequestblocklocator_test.go

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

app/appmessage/p2p_msgrequestheaders.go

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

app/appmessage/p2p_msgrequestheaders_test.go

@@ -7,34 +7,34 @@ package appmessage
 import (
 	"testing"
 
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
-// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
+// TestRequstIBDBlocks tests the MsgRequestHeaders API.
 func TestRequstIBDBlocks(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	lowHash, err := daghash.NewHashFromStr(hashStr)
+	lowHash, err := externalapi.NewDomainHashFromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	hashStr = "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	highHash, err := daghash.NewHashFromStr(hashStr)
+	hashStr = "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	highHash, err := externalapi.NewDomainHashFromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
 	// Ensure we get the same data back out.
-	msg := NewMsgRequstIBDBlocks(lowHash, highHash)
-	if !msg.HighHash.IsEqual(highHash) {
-		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
+	msg := NewMsgRequstHeaders(lowHash, highHash)
+	if !msg.HighHash.Equal(highHash) {
+		t.Errorf("NewMsgRequstHeaders: wrong high hash - got %v, want %v",
 			msg.HighHash, highHash)
 	}
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(4)
 	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgRequstIBDBlocks: wrong command - got %v want %v",
+		t.Errorf("NewMsgRequstHeaders: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}
 }

app/appmessage/p2p_msgrequestibdblocks.go

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

app/appmessage/p2p_msgrequestibdrootutxosetandblock.go

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

app/appmessage/p2p_msgrequestnextheaders.go

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

app/appmessage/p2p_msgrequestnextibdblocks.go

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

app/appmessage/p2p_msgrequestnextibdrootutxosetchunk.go

@@ -0,0 +1,16 @@
+package appmessage
+
+// MsgRequestNextIBDRootUTXOSetChunk represents a kaspa RequestNextIBDRootUTXOSetChunk message
+type MsgRequestNextIBDRootUTXOSetChunk struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *MsgRequestNextIBDRootUTXOSetChunk) Command() MessageCommand {
+	return CmdRequestNextIBDRootUTXOSetChunk
+}
+
+// NewMsgRequestNextIBDRootUTXOSetChunk returns a new MsgRequestNextIBDRootUTXOSetChunk.
+func NewMsgRequestNextIBDRootUTXOSetChunk() *MsgRequestNextIBDRootUTXOSetChunk {
+	return &MsgRequestNextIBDRootUTXOSetChunk{}
+}

app/appmessage/p2p_msgrequestrelayblocks.go

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

app/appmessage/p2p_msgrequestselectedtip.go

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

app/appmessage/p2p_msgselectedtip.go

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

app/appmessage/p2p_msgselectedtip_test.go

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

app/appmessage/p2p_msgtransactionnotfound.go

@@ -5,14 +5,14 @@
 package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgTransactionNotFound defines a kaspa TransactionNotFound message which is sent in response to
 // a RequestTransactions message if any of the requested data in not available on the peer.
 type MsgTransactionNotFound struct {
 	baseMessage
-	ID *daghash.TxID
+	ID *externalapi.DomainTransactionID
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,7 +23,7 @@ func (msg *MsgTransactionNotFound) Command() MessageCommand {
 
 // NewMsgTransactionNotFound returns a new kaspa transactionsnotfound message that conforms to the
 // Message interface. See MsgTransactionNotFound for details.
-func NewMsgTransactionNotFound(id *daghash.TxID) *MsgTransactionNotFound {
+func NewMsgTransactionNotFound(id *externalapi.DomainTransactionID) *MsgTransactionNotFound {
 	return &MsgTransactionNotFound{
 		ID: id,
 	}

app/appmessage/p2p_msgtx.go

@@ -6,49 +6,21 @@ package appmessage
 
 import (
 	"encoding/binary"
-	"fmt"
-	"io"
-	"math"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 	"strconv"
 
-	"github.com/kaspanet/kaspad/util/binaryserializer"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 const (
-	// TxVersion is the current latest supported transaction version.
-	TxVersion = 1
-
-	// MaxTxInSequenceNum is the maximum sequence number the sequence field
-	// of a transaction input can be.
-	MaxTxInSequenceNum uint64 = math.MaxUint64
-
 	// MaxPrevOutIndex is the maximum index the index field of a previous
 	// outpoint can be.
 	MaxPrevOutIndex uint32 = 0xffffffff
 
-	// SequenceLockTimeDisabled is a flag that if set on a transaction
-	// input's sequence number, the sequence number will not be interpreted
-	// as a relative locktime.
-	SequenceLockTimeDisabled = 1 << 31
-
-	// SequenceLockTimeIsSeconds is a flag that if set on a transaction
-	// input's sequence number, the relative locktime has units of 512
-	// seconds.
-	SequenceLockTimeIsSeconds = 1 << 22
-
-	// SequenceLockTimeMask is a mask that extracts the relative locktime
-	// when masked against the transaction input sequence number.
-	SequenceLockTimeMask = 0x0000ffff
-
-	// SequenceLockTimeGranularity is the defined time based granularity
-	// for milliseconds-based relative time locks. When converting from milliseconds
-	// to a sequence number, the value is right shifted by this amount,
-	// therefore the granularity of relative time locks in 524288 or 2^19
-	// seconds. Enforced relative lock times are multiples of 524288 milliseconds.
-	SequenceLockTimeGranularity = 19
-
 	// defaultTxInOutAlloc is the default size used for the backing array for
 	// transaction inputs and outputs. The array will dynamically grow as needed,
 	// but this figure is intended to provide enough space for the number of
@@ -59,15 +31,15 @@ const (
 	// 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 + daghash.HashSize
+	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
+	// Value 8 bytes + version 2 bytes + Varint for ScriptPublicKey length 1 byte.
+	MinTxOutPayload = 11
 
 	// maxTxOutPerMessage is the maximum number of transactions outputs that
 	// a transaction which fits into a message could possibly have.
@@ -81,102 +53,18 @@ const (
 	// number of transaction outputs 1 byte + LockTime 4 bytes + min input
 	// payload + min output payload.
 	minTxPayload = 10
-
-	// freeListMaxScriptSize is the size of each buffer in the free list
-	// that	is used for deserializing scripts from the appmessage before they are
-	// concatenated into a single contiguous buffers. This value was chosen
-	// because it is slightly more than twice the size of the vast majority
-	// of all "standard" scripts. Larger scripts are still deserialized
-	// properly as the free list will simply be bypassed for them.
-	freeListMaxScriptSize = 512
-
-	// freeListMaxItems is the number of buffers to keep in the free list
-	// to use for script deserialization. This value allows up to 100
-	// scripts per transaction being simultaneously deserialized by 125
-	// peers. Thus, the peak usage of the free list is 12,500 * 512 =
-	// 6,400,000 bytes.
-	freeListMaxItems = 12500
 )
 
-// txEncoding is a bitmask defining which transaction fields we
-// want to encode and which to ignore.
-type txEncoding uint8
-
-const (
-	txEncodingFull txEncoding = 0
-
-	txEncodingExcludePayload txEncoding = 1 << iota
-
-	txEncodingExcludeSignatureScript
-)
-
-// scriptFreeList defines a free list of byte slices (up to the maximum number
-// defined by the freeListMaxItems constant) that have a cap according to the
-// freeListMaxScriptSize constant. It is used to provide temporary buffers for
-// deserializing scripts in order to greatly reduce the number of allocations
-// required.
-//
-// The caller can obtain a buffer from the free list by calling the Borrow
-// function and should return it via the Return function when done using it.
-type scriptFreeList chan []byte
-
-// Borrow returns a byte slice from the free list with a length according the
-// provided size. A new buffer is allocated if there are any items available.
-//
-// When the size is larger than the max size allowed for items on the free list
-// a new buffer of the appropriate size is allocated and returned. It is safe
-// to attempt to return said buffer via the Return function as it will be
-// ignored and allowed to go the garbage collector.
-func (c scriptFreeList) Borrow(size uint64) []byte {
-	if size > freeListMaxScriptSize {
-		return make([]byte, size)
-	}
-
-	var buf []byte
-	select {
-	case buf = <-c:
-	default:
-		buf = make([]byte, freeListMaxScriptSize)
-	}
-	return buf[:size]
-}
-
-// Return puts the provided byte slice back on the free list when it has a cap
-// of the expected length. The buffer is expected to have been obtained via
-// the Borrow function. Any slices that are not of the appropriate size, such
-// as those whose size is greater than the largest allowed free list item size
-// are simply ignored so they can go to the garbage collector.
-func (c scriptFreeList) Return(buf []byte) {
-	// Ignore any buffers returned that aren't the expected size for the
-	// free list.
-	if cap(buf) != freeListMaxScriptSize {
-		return
-	}
-
-	// Return the buffer to the free list when it's not full. Otherwise let
-	// it be garbage collected.
-	select {
-	case c <- buf:
-	default:
-		// Let it go to the garbage collector.
-	}
-}
-
-// Create the concurrent safe free list to use for script deserialization. As
-// previously described, this free list is maintained to significantly reduce
-// the number of allocations.
-var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)
-
 // Outpoint defines a kaspa data type that is used to track previous
 // transaction outputs.
 type Outpoint struct {
-	TxID  daghash.TxID
+	TxID  externalapi.DomainTransactionID
 	Index uint32
 }
 
 // NewOutpoint returns a new kaspa transaction outpoint point with the
 // provided hash and index.
-func NewOutpoint(txID *daghash.TxID, index uint32) *Outpoint {
+func NewOutpoint(txID *externalapi.DomainTransactionID, index uint32) *Outpoint {
 	return &Outpoint{
 		TxID:  *txID,
 		Index: index,
@@ -191,9 +79,9 @@ func (o Outpoint) String() string {
 	// 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*daghash.HashSize+1, 2*daghash.HashSize+1+10)
+	buf := make([]byte, 2*externalapi.DomainHashSize+1, 2*externalapi.DomainHashSize+1+10)
 	copy(buf, o.TxID.String())
-	buf[2*daghash.HashSize] = ':'
+	buf[2*externalapi.DomainHashSize] = ':'
 	buf = strconv.AppendUint(buf, uint64(o.Index), 10)
 	return string(buf)
 }
@@ -205,55 +93,26 @@ type TxIn struct {
 	Sequence         uint64
 }
 
-// SerializeSize returns the number of bytes it would take to serialize the
-// the transaction input.
-func (t *TxIn) SerializeSize() int {
-	return t.serializeSize(txEncodingFull)
-}
-
-func (t *TxIn) serializeSize(encodingFlags txEncoding) int {
-	// Outpoint ID 32 bytes + Outpoint Index 4 bytes + Sequence 8 bytes +
-	// serialized varint size for the length of SignatureScript +
-	// SignatureScript bytes.
-	return 44 + serializeSignatureScriptSize(t.SignatureScript, encodingFlags)
-}
-
-func serializeSignatureScriptSize(signatureScript []byte, encodingFlags txEncoding) int {
-	if encodingFlags&txEncodingExcludeSignatureScript != txEncodingExcludeSignatureScript {
-		return VarIntSerializeSize(uint64(len(signatureScript))) +
-			len(signatureScript)
-	}
-	return VarIntSerializeSize(0)
-}
-
 // 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 {
+func NewTxIn(prevOut *Outpoint, signatureScript []byte, sequence uint64) *TxIn {
 	return &TxIn{
 		PreviousOutpoint: *prevOut,
 		SignatureScript:  signatureScript,
-		Sequence:         MaxTxInSequenceNum,
+		Sequence:         sequence,
 	}
 }
 
 // TxOut defines a kaspa transaction output.
 type TxOut struct {
 	Value        uint64
-	ScriptPubKey []byte
-}
-
-// SerializeSize returns the number of bytes it would take to serialize the
-// the transaction output.
-func (t *TxOut) SerializeSize() int {
-	// Value 8 bytes + serialized varint size for the length of ScriptPubKey +
-	// ScriptPubKey bytes.
-	return 8 + VarIntSerializeSize(uint64(len(t.ScriptPubKey))) + len(t.ScriptPubKey)
+	ScriptPubKey *externalapi.ScriptPublicKey
 }
 
 // NewTxOut returns a new kaspa transaction output with the provided
 // transaction value and public key script.
-func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
+func NewTxOut(value uint64, scriptPubKey *externalapi.ScriptPublicKey) *TxOut {
 	return &TxOut{
 		Value:        value,
 		ScriptPubKey: scriptPubKey,
@@ -268,13 +127,13 @@ func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
 // inputs and outputs.
 type MsgTx struct {
 	baseMessage
-	Version      int32
+	Version      uint16
 	TxIn         []*TxIn
 	TxOut        []*TxOut
 	LockTime     uint64
-	SubnetworkID subnetworkid.SubnetworkID
+	SubnetworkID externalapi.DomainSubnetworkID
 	Gas          uint64
-	PayloadHash  *daghash.Hash
+	PayloadHash  externalapi.DomainHash
 	Payload      []byte
 }
 
@@ -295,41 +154,17 @@ func (msg *MsgTx) AddTxOut(to *TxOut) {
 // 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.IsEqual(subnetworkid.SubnetworkIDCoinbase)
+	return msg.SubnetworkID == subnetworks.SubnetworkIDCoinbase
 }
 
 // TxHash generates the Hash for the transaction.
-func (msg *MsgTx) TxHash() *daghash.Hash {
-	// Encode the transaction and calculate double sha256 on the result.
-	writer := daghash.NewDoubleHashWriter()
-	err := msg.serialize(writer, txEncodingExcludePayload)
-	if err != nil {
-		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
-		// and we assume we never construct malformed transactions.
-		panic(fmt.Sprintf("TxHash() failed. this should never fail for structurally-valid transactions. err: %+v", err))
-	}
-
-	hash := writer.Finalize()
-	return &hash
+func (msg *MsgTx) TxHash() *externalapi.DomainHash {
+	return consensushashing.TransactionHash(MsgTxToDomainTransaction(msg))
 }
 
 // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
-func (msg *MsgTx) TxID() *daghash.TxID {
-	// Encode the transaction, replace signature script with zeroes, cut off
-	// payload and calculate double sha256 on the result.
-	var encodingFlags txEncoding
-	if !msg.IsCoinBase() {
-		encodingFlags = txEncodingExcludeSignatureScript | txEncodingExcludePayload
-	}
-	writer := daghash.NewDoubleHashWriter()
-	err := msg.serialize(writer, encodingFlags)
-	if err != nil {
-		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
-		// and we assume we never construct malformed transactions.
-		panic(fmt.Sprintf("TxID() failed. this should never fail for structurally-valid transactions. err: %+v", err))
-	}
-	txID := daghash.TxID(writer.Finalize())
-	return &txID
+func (msg *MsgTx) TxID() *externalapi.DomainTransactionID {
+	return consensushashing.TransactionID(MsgTxToDomainTransaction(msg))
 }
 
 // Copy creates a deep copy of a transaction so that the original does not get
@@ -357,7 +192,7 @@ func (msg *MsgTx) Copy() *MsgTx {
 		// Deep copy the old previous outpoint.
 		oldOutpoint := oldTxIn.PreviousOutpoint
 		newOutpoint := Outpoint{}
-		newOutpoint.TxID.SetBytes(oldOutpoint.TxID[:])
+		newOutpoint.TxID = oldOutpoint.TxID
 		newOutpoint.Index = oldOutpoint.Index
 
 		// Deep copy the old signature script.
@@ -382,20 +217,20 @@ func (msg *MsgTx) Copy() *MsgTx {
 
 	// Deep copy the old TxOut data.
 	for _, oldTxOut := range msg.TxOut {
-		// Deep copy the old ScriptPubKey
-		var newScript []byte
+		// Deep copy the old ScriptPublicKey
+		var newScript externalapi.ScriptPublicKey
 		oldScript := oldTxOut.ScriptPubKey
-		oldScriptLen := len(oldScript)
+		oldScriptLen := len(oldScript.Script)
 		if oldScriptLen > 0 {
-			newScript = make([]byte, oldScriptLen)
-			copy(newScript, oldScript[:oldScriptLen])
+			newScript = externalapi.ScriptPublicKey{Script: make([]byte, oldScriptLen), Version: oldScript.Version}
+			copy(newScript.Script, oldScript.Script[:oldScriptLen])
 		}
 
 		// Create new txOut with the deep copied data and append it to
 		// new Tx.
 		newTxOut := TxOut{
 			Value:        oldTxOut.Value,
-			ScriptPubKey: newScript,
+			ScriptPubKey: &newScript,
 		}
 		newTx.TxOut = append(newTx.TxOut, &newTxOut)
 	}
@@ -403,368 +238,6 @@ func (msg *MsgTx) Copy() *MsgTx {
 	return &newTx
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-// See Deserialize for decoding transactions stored to disk, such as in a
-// database, as opposed to decoding transactions from the appmessage.
-func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
-	version, err := binaryserializer.Uint32(r, littleEndian)
-	if err != nil {
-		return err
-	}
-	msg.Version = int32(version)
-
-	count, err := ReadVarInt(r)
-	if err != nil {
-		return err
-	}
-
-	// Prevent more input transactions than could possibly fit into a
-	// message. It would be possible to cause memory exhaustion and panics
-	// without a sane upper bound on this count.
-	if count > uint64(maxTxInPerMessage) {
-		str := fmt.Sprintf("too many input transactions to fit into "+
-			"max message size [count %d, max %d]", count,
-			maxTxInPerMessage)
-		return messageError("MsgTx.KaspaDecode", str)
-	}
-
-	// returnScriptBuffers is a closure that returns any script buffers that
-	// were borrowed from the pool when there are any deserialization
-	// errors. This is only valid to call before the final step which
-	// replaces the scripts with the location in a contiguous buffer and
-	// returns them.
-	returnScriptBuffers := func() {
-		for _, txIn := range msg.TxIn {
-			if txIn == nil || txIn.SignatureScript == nil {
-				continue
-			}
-			scriptPool.Return(txIn.SignatureScript)
-		}
-		for _, txOut := range msg.TxOut {
-			if txOut == nil || txOut.ScriptPubKey == nil {
-				continue
-			}
-			scriptPool.Return(txOut.ScriptPubKey)
-		}
-	}
-
-	// Deserialize the inputs.
-	var totalScriptSize uint64
-	txIns := make([]TxIn, count)
-	msg.TxIn = make([]*TxIn, count)
-	for i := uint64(0); i < count; i++ {
-		// The pointer is set now in case a script buffer is borrowed
-		// and needs to be returned to the pool on error.
-		ti := &txIns[i]
-		msg.TxIn[i] = ti
-		err = readTxIn(r, pver, msg.Version, ti)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-		totalScriptSize += uint64(len(ti.SignatureScript))
-	}
-
-	count, err = ReadVarInt(r)
-	if err != nil {
-		returnScriptBuffers()
-		return err
-	}
-
-	// Prevent more output transactions than could possibly fit into a
-	// message. It would be possible to cause memory exhaustion and panics
-	// without a sane upper bound on this count.
-	if count > uint64(maxTxOutPerMessage) {
-		returnScriptBuffers()
-		str := fmt.Sprintf("too many output transactions to fit into "+
-			"max message size [count %d, max %d]", count,
-			maxTxOutPerMessage)
-		return messageError("MsgTx.KaspaDecode", str)
-	}
-
-	// Deserialize the outputs.
-	txOuts := make([]TxOut, count)
-	msg.TxOut = make([]*TxOut, count)
-	for i := uint64(0); i < count; i++ {
-		// The pointer is set now in case a script buffer is borrowed
-		// and needs to be returned to the pool on error.
-		to := &txOuts[i]
-		msg.TxOut[i] = to
-		err = readTxOut(r, pver, msg.Version, to)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-		totalScriptSize += uint64(len(to.ScriptPubKey))
-	}
-
-	lockTime, err := binaryserializer.Uint64(r, littleEndian)
-	msg.LockTime = lockTime
-	if err != nil {
-		returnScriptBuffers()
-		return err
-	}
-
-	_, err = io.ReadFull(r, msg.SubnetworkID[:])
-	if err != nil {
-		returnScriptBuffers()
-		return err
-	}
-
-	if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
-		msg.Gas, err = binaryserializer.Uint64(r, littleEndian)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-
-		var payloadHash daghash.Hash
-		err = ReadElement(r, &payloadHash)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-		msg.PayloadHash = &payloadHash
-
-		payloadLength, err := ReadVarInt(r)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-
-		msg.Payload = make([]byte, payloadLength)
-		_, err = io.ReadFull(r, msg.Payload)
-		if err != nil {
-			returnScriptBuffers()
-			return err
-		}
-	}
-
-	// Create a single allocation to house all of the scripts and set each
-	// input signature script and output public key script to the
-	// appropriate subslice of the overall contiguous buffer. Then, return
-	// each individual script buffer back to the pool so they can be reused
-	// for future deserializations. This is done because it significantly
-	// reduces the number of allocations the garbage collector needs to
-	// track, which in turn improves performance and drastically reduces the
-	// amount of runtime overhead that would otherwise be needed to keep
-	// track of millions of small allocations.
-	//
-	// NOTE: It is no longer valid to call the returnScriptBuffers closure
-	// after these blocks of code run because it is already done and the
-	// scripts in the transaction inputs and outputs no longer point to the
-	// buffers.
-	var offset uint64
-	scripts := make([]byte, totalScriptSize)
-	for i := 0; i < len(msg.TxIn); i++ {
-		// Copy the signature script into the contiguous buffer at the
-		// appropriate offset.
-		signatureScript := msg.TxIn[i].SignatureScript
-		copy(scripts[offset:], signatureScript)
-
-		// Reset the signature script of the transaction input to the
-		// slice of the contiguous buffer where the script lives.
-		scriptSize := uint64(len(signatureScript))
-		end := offset + scriptSize
-		msg.TxIn[i].SignatureScript = scripts[offset:end:end]
-		offset += scriptSize
-
-		// Return the temporary script buffer to the pool.
-		scriptPool.Return(signatureScript)
-	}
-	for i := 0; i < len(msg.TxOut); i++ {
-		// Copy the public key script into the contiguous buffer at the
-		// appropriate offset.
-		scriptPubKey := msg.TxOut[i].ScriptPubKey
-		copy(scripts[offset:], scriptPubKey)
-
-		// Reset the public key script of the transaction output to the
-		// slice of the contiguous buffer where the script lives.
-		scriptSize := uint64(len(scriptPubKey))
-		end := offset + scriptSize
-		msg.TxOut[i].ScriptPubKey = scripts[offset:end:end]
-		offset += scriptSize
-
-		// Return the temporary script buffer to the pool.
-		scriptPool.Return(scriptPubKey)
-	}
-
-	return nil
-}
-
-// Deserialize decodes a transaction from r into the receiver using a format
-// that is suitable for long-term storage such as a database while respecting
-// the Version field in the transaction. This function differs from KaspaDecode
-// in that KaspaDecode decodes from the kaspa appmessage protocol as it was sent
-// across the network. The appmessage encoding can technically differ depending on
-// the protocol version and doesn't even really need to match the format of a
-// stored transaction at all. As of the time this comment was written, the
-// encoded transaction is the same in both instances, but there is a distinct
-// difference and separating the two allows the API to be flexible enough to
-// deal with changes.
-func (msg *MsgTx) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of KaspaDecode.
-	return msg.KaspaDecode(r, 0)
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-// See Serialize for encoding transactions to be stored to disk, such as in a
-// database, as opposed to encoding transactions for the appmessage.
-func (msg *MsgTx) KaspaEncode(w io.Writer, pver uint32) error {
-	return msg.encode(w, pver, txEncodingFull)
-}
-
-func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) error {
-	err := binaryserializer.PutUint32(w, littleEndian, uint32(msg.Version))
-	if err != nil {
-		return err
-	}
-
-	count := uint64(len(msg.TxIn))
-	err = WriteVarInt(w, count)
-	if err != nil {
-		return err
-	}
-
-	for _, ti := range msg.TxIn {
-		err = writeTxIn(w, pver, msg.Version, ti, encodingFlags)
-		if err != nil {
-			return err
-		}
-	}
-
-	count = uint64(len(msg.TxOut))
-	err = WriteVarInt(w, count)
-	if err != nil {
-		return err
-	}
-
-	for _, to := range msg.TxOut {
-		err = WriteTxOut(w, pver, msg.Version, to)
-		if err != nil {
-			return err
-		}
-	}
-
-	err = binaryserializer.PutUint64(w, littleEndian, msg.LockTime)
-	if err != nil {
-		return err
-	}
-
-	_, err = w.Write(msg.SubnetworkID[:])
-	if err != nil {
-		return err
-	}
-
-	if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
-		if msg.SubnetworkID.IsBuiltIn() && msg.Gas != 0 {
-			str := "Transactions from built-in should have 0 gas"
-			return messageError("MsgTx.KaspaEncode", str)
-		}
-
-		err = binaryserializer.PutUint64(w, littleEndian, msg.Gas)
-		if err != nil {
-			return err
-		}
-
-		err = WriteElement(w, msg.PayloadHash)
-		if err != nil {
-			return err
-		}
-
-		if encodingFlags&txEncodingExcludePayload != txEncodingExcludePayload {
-			err = WriteVarInt(w, uint64(len(msg.Payload)))
-			w.Write(msg.Payload)
-		} else {
-			err = WriteVarInt(w, 0)
-		}
-		if err != nil {
-			return err
-		}
-	} else if msg.Payload != nil {
-		str := "Transactions from native subnetwork should have <nil> payload"
-		return messageError("MsgTx.KaspaEncode", str)
-	} else if msg.PayloadHash != nil {
-		str := "Transactions from native subnetwork should have <nil> payload hash"
-		return messageError("MsgTx.KaspaEncode", str)
-	} else if msg.Gas != 0 {
-		str := "Transactions from native subnetwork should have 0 gas"
-		return messageError("MsgTx.KaspaEncode", str)
-	}
-
-	return nil
-}
-
-// Serialize encodes the transaction to w using a format that suitable for
-// long-term storage such as a database while respecting the Version field in
-// the transaction. This function differs from KaspaEncode in that KaspaEncode
-// encodes the transaction to the kaspa appmessage protocol in order to be sent
-// across the network. The appmessage encoding can technically differ depending on
-// the protocol version and doesn't even really need to match the format of a
-// stored transaction at all. As of the time this comment was written, the
-// encoded transaction is the same in both instances, but there is a distinct
-// difference and separating the two allows the API to be flexible enough to
-// deal with changes.
-func (msg *MsgTx) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of KaspaEncode.
-	return msg.KaspaEncode(w, 0)
-}
-
-func (msg *MsgTx) serialize(w io.Writer, encodingFlags txEncoding) error {
-	// At the current time, there is no difference between the appmessage encoding
-	// at protocol version 0 and the stable long-term storage format. As
-	// a result, make use of `encode`.
-	return msg.encode(w, 0, encodingFlags)
-}
-
-// SerializeSize returns the number of bytes it would take to serialize
-// the transaction.
-func (msg *MsgTx) SerializeSize() int {
-	return msg.serializeSize(txEncodingFull)
-}
-
-// SerializeSize returns the number of bytes it would take to serialize
-// the transaction.
-func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
-	// Version 4 bytes + LockTime 8 bytes + SubnetworkID 20
-	// bytes + Serialized varint size for the number of transaction
-	// inputs and outputs.
-	n := 32 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
-		VarIntSerializeSize(uint64(len(msg.TxOut)))
-
-	if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
-		// Gas 8 bytes
-		n += 8
-
-		// PayloadHash
-		n += daghash.HashSize
-
-		// Serialized varint size for the length of the payload
-		if encodingFlags&txEncodingExcludePayload != txEncodingExcludePayload {
-			n += VarIntSerializeSize(uint64(len(msg.Payload)))
-			n += len(msg.Payload)
-		} else {
-			n += VarIntSerializeSize(0)
-		}
-	}
-
-	for _, txIn := range msg.TxIn {
-		n += txIn.serializeSize(encodingFlags)
-	}
-
-	for _, txOut := range msg.TxOut {
-		n += txOut.SerializeSize()
-	}
-
-	return n
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
 func (msg *MsgTx) Command() MessageCommand {
@@ -777,52 +250,14 @@ func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
 	return MaxMessagePayload
 }
 
-// ScriptPubKeyLocs returns a slice containing the start of each public key script
-// within the raw serialized transaction. The caller can easily obtain the
-// length of each script by using len on the script available via the
-// appropriate transaction output entry.
-func (msg *MsgTx) ScriptPubKeyLocs() []int {
-	numTxOut := len(msg.TxOut)
-	if numTxOut == 0 {
-		return nil
-	}
-
-	// The starting offset in the serialized transaction of the first
-	// transaction output is:
-	//
-	// Version 4 bytes + serialized varint size for the number of
-	// transaction inputs and outputs + serialized size of each transaction
-	// input.
-	n := 4 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
-		VarIntSerializeSize(uint64(numTxOut))
-
-	for _, txIn := range msg.TxIn {
-		n += txIn.SerializeSize()
-	}
-
-	// Calculate and set the appropriate offset for each public key script.
-	scriptPubKeyLocs := make([]int, numTxOut)
-	for i, txOut := range msg.TxOut {
-		// The offset of the script in the transaction output is:
-		//
-		// Value 8 bytes + serialized varint size for the length of
-		// ScriptPubKey.
-		n += 8 + VarIntSerializeSize(uint64(len(txOut.ScriptPubKey)))
-		scriptPubKeyLocs[i] = n
-		n += len(txOut.ScriptPubKey)
-	}
-
-	return scriptPubKeyLocs
-}
-
 // 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 *subnetworkid.SubnetworkID) bool {
+func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *externalapi.DomainSubnetworkID) bool {
 	return subnetworkID == nil ||
-		subnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) ||
-		subnetworkID.IsEqual(&msg.SubnetworkID)
+		subnetworkID.Equal(&subnetworks.SubnetworkIDNative) ||
+		subnetworkID.Equal(&msg.SubnetworkID)
 }
 
 // newMsgTx returns a new tx message that conforms to the Message interface.
@@ -834,7 +269,7 @@ func (msg *MsgTx) IsSubnetworkCompatible(subnetworkID *subnetworkid.SubnetworkID
 // 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 *subnetworkid.SubnetworkID,
+func newMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
 	gas uint64, payload []byte, lockTime uint64) *MsgTx {
 
 	if txIn == nil {
@@ -845,9 +280,9 @@ func newMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *subnetw
 		txOut = make([]*TxOut, 0, defaultTxInOutAlloc)
 	}
 
-	var payloadHash *daghash.Hash
-	if !subnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
-		payloadHash = daghash.DoubleHashP(payload)
+	var payloadHash externalapi.DomainHash
+	if *subnetworkID != subnetworks.SubnetworkIDNative {
+		payloadHash = *hashes.PayloadHash(payload)
 	}
 
 	return &MsgTx{
@@ -863,12 +298,12 @@ func newMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *subnetw
 }
 
 // NewNativeMsgTx returns a new tx message in the native subnetwork
-func NewNativeMsgTx(version int32, txIn []*TxIn, txOut []*TxOut) *MsgTx {
-	return newMsgTx(version, txIn, txOut, subnetworkid.SubnetworkIDNative, 0, nil, 0)
+func NewNativeMsgTx(version uint16, 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 *subnetworkid.SubnetworkID,
+func NewSubnetworkMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, subnetworkID *externalapi.DomainSubnetworkID,
 	gas uint64, payload []byte) *MsgTx {
 
 	return newMsgTx(version, txIn, txOut, subnetworkID, gas, payload, 0)
@@ -877,128 +312,14 @@ func NewSubnetworkMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkI
 // 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, subnetworkid.SubnetworkIDNative, 0, nil, locktime)
+func NewNativeMsgTxWithLocktime(version uint16, 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 {
+func NewRegistryMsgTx(version uint16, txIn []*TxIn, txOut []*TxOut, gasLimit uint64) *MsgTx {
 	payload := make([]byte, 8)
 	binary.LittleEndian.PutUint64(payload, gasLimit)
 
-	return NewSubnetworkMsgTx(version, txIn, txOut, subnetworkid.SubnetworkIDRegistry, 0, payload)
-}
-
-// readOutpoint reads the next sequence of bytes from r as an Outpoint.
-func readOutpoint(r io.Reader, pver uint32, version int32, op *Outpoint) error {
-	_, err := io.ReadFull(r, op.TxID[:])
-	if err != nil {
-		return err
-	}
-
-	op.Index, err = binaryserializer.Uint32(r, littleEndian)
-	return err
-}
-
-// writeOutpoint encodes op to the kaspa protocol encoding for an Outpoint
-// to w.
-func writeOutpoint(w io.Writer, pver uint32, version int32, op *Outpoint) error {
-	_, err := w.Write(op.TxID[:])
-	if err != nil {
-		return err
-	}
-
-	return binaryserializer.PutUint32(w, littleEndian, op.Index)
-}
-
-// readScript reads a variable length byte array that represents a transaction
-// script. It is encoded as a varInt containing the length of the array
-// followed by the bytes themselves. An error is returned if the length is
-// greater than the passed maxAllowed parameter which helps protect against
-// memory exhaustion attacks and forced panics through malformed messages. The
-// fieldName parameter is only used for the error message so it provides more
-// context in the error.
-func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) ([]byte, error) {
-	count, err := ReadVarInt(r)
-	if err != nil {
-		return nil, err
-	}
-
-	// Prevent byte array larger than the max message size. It would
-	// be possible to cause memory exhaustion and panics without a sane
-	// upper bound on this count.
-	if count > uint64(maxAllowed) {
-		str := fmt.Sprintf("%s is larger than the max allowed size "+
-			"[count %d, max %d]", fieldName, count, maxAllowed)
-		return nil, messageError("readScript", str)
-	}
-
-	b := scriptPool.Borrow(count)
-	_, err = io.ReadFull(r, b)
-	if err != nil {
-		scriptPool.Return(b)
-		return nil, err
-	}
-	return b, nil
-}
-
-// readTxIn reads the next sequence of bytes from r as a transaction input
-// (TxIn).
-func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
-	err := readOutpoint(r, pver, version, &ti.PreviousOutpoint)
-	if err != nil {
-		return err
-	}
-
-	ti.SignatureScript, err = readScript(r, pver, MaxMessagePayload,
-		"transaction input signature script")
-	if err != nil {
-		return err
-	}
-
-	return ReadElement(r, &ti.Sequence)
-}
-
-// writeTxIn encodes ti to the kaspa protocol encoding for a transaction
-// input (TxIn) to w.
-func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn, encodingFlags txEncoding) error {
-	err := writeOutpoint(w, pver, version, &ti.PreviousOutpoint)
-	if err != nil {
-		return err
-	}
-
-	if encodingFlags&txEncodingExcludeSignatureScript != txEncodingExcludeSignatureScript {
-		err = WriteVarBytes(w, pver, ti.SignatureScript)
-	} else {
-		err = WriteVarBytes(w, pver, []byte{})
-	}
-	if err != nil {
-		return err
-	}
-
-	return binaryserializer.PutUint64(w, littleEndian, ti.Sequence)
-}
-
-// readTxOut reads the next sequence of bytes from r as a transaction output
-// (TxOut).
-func readTxOut(r io.Reader, pver uint32, version int32, to *TxOut) error {
-	err := ReadElement(r, &to.Value)
-	if err != nil {
-		return err
-	}
-
-	to.ScriptPubKey, err = readScript(r, pver, MaxMessagePayload,
-		"transaction output public key script")
-	return err
-}
-
-// WriteTxOut encodes to into the kaspa protocol encoding for a transaction
-// output (TxOut) to w.
-func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error {
-	err := binaryserializer.PutUint64(w, littleEndian, uint64(to.Value))
-	if err != nil {
-		return err
-	}
-
-	return WriteVarBytes(w, pver, to.ScriptPubKey)
+	return NewSubnetworkMsgTx(version, txIn, txOut, &subnetworks.SubnetworkIDRegistry, 0, payload)
 }

app/appmessage/p2p_msgtx_test.go

@@ -7,24 +7,25 @@ package appmessage
 import (
 	"bytes"
 	"fmt"
-	"github.com/pkg/errors"
-	"io"
 	"math"
 	"reflect"
 	"testing"
-	"unsafe"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+
+	"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/util/daghash"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // TestTx tests the MsgTx API.
 func TestTx(t *testing.T) {
 	pver := ProtocolVersion
 
-	txIDStr := "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	txID, err := daghash.NewTxIDFromStr(txIDStr)
+	txIDStr := "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	txID, err := transactionid.FromString(txIDStr)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
 	}
@@ -51,7 +52,7 @@ func TestTx(t *testing.T) {
 	// testing package functionality.
 	prevOutIndex := uint32(1)
 	prevOut := NewOutpoint(txID, prevOutIndex)
-	if !prevOut.TxID.IsEqual(txID) {
+	if !prevOut.TxID.Equal(txID) {
 		t.Errorf("NewOutpoint: wrong ID - got %v, want %v",
 			spew.Sprint(&prevOut.TxID), spew.Sprint(txID))
 	}
@@ -67,7 +68,7 @@ func TestTx(t *testing.T) {
 
 	// Ensure we get the same transaction input back out.
 	sigScript := []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}
-	txIn := NewTxIn(prevOut, sigScript)
+	txIn := NewTxIn(prevOut, sigScript, constants.MaxTxInSequenceNum)
 	if !reflect.DeepEqual(&txIn.PreviousOutpoint, prevOut) {
 		t.Errorf("NewTxIn: wrong prev outpoint - got %v, want %v",
 			spew.Sprint(&txIn.PreviousOutpoint),
@@ -81,26 +82,28 @@ func TestTx(t *testing.T) {
 
 	// 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
-	}
+	scriptPubKey := &externalapi.ScriptPublicKey{
+		Script: []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
+		},
+		Version: 0}
 	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) {
+	if !bytes.Equal(txOut.ScriptPubKey.Script, scriptPubKey.Script) {
 		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
 			spew.Sdump(txOut.ScriptPubKey),
 			spew.Sdump(scriptPubKey))
@@ -130,17 +133,21 @@ func TestTx(t *testing.T) {
 
 // TestTxHash tests the ability to generate the hash of a transaction accurately.
 func TestTxHashAndID(t *testing.T) {
-	txID1Str := "edca872f27279674c7a52192b32fd68b8b8be714bfea52d98b2c3c86c30e85c6"
-	wantTxID1, err := daghash.NewTxIDFromStr(txID1Str)
+	txHash1Str := "4bee9ee495bd93a755de428376bd582a2bb6ec37c041753b711c0606d5745c13"
+	txID1Str := "f868bd20e816256b80eac976821be4589d24d21141bd1cec6e8005d0c16c6881"
+	wantTxID1, err := transactionid.FromString(txID1Str)
 	if err != nil {
-		t.Errorf("NewTxIDFromStr: %v", err)
-		return
+		t.Fatalf("NewTxIDFromStr: %v", err)
+	}
+	wantTxHash1, err := transactionid.FromString(txHash1Str)
+	if err != nil {
+		t.Fatalf("NewTxIDFromStr: %v", err)
 	}
 
 	// A coinbase transaction
 	txIn := &TxIn{
 		PreviousOutpoint: Outpoint{
-			TxID:  daghash.TxID{},
+			TxID:  externalapi.DomainTransactionID{},
 			Index: math.MaxUint32,
 		},
 		SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
@@ -148,7 +155,7 @@ func TestTxHashAndID(t *testing.T) {
 	}
 	txOut := &TxOut{
 		Value: 5000000000,
-		ScriptPubKey: []byte{
+		ScriptPubKey: &externalapi.ScriptPublicKey{Script: []byte{
 			0x41, // OP_DATA_65
 			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -160,33 +167,33 @@ func TestTxHashAndID(t *testing.T) {
 			0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
 			0xa6, // 65-byte signature
 			0xac, // OP_CHECKSIG
-		},
+		}, Version: 0},
 	}
-	tx1 := NewSubnetworkMsgTx(1, []*TxIn{txIn}, []*TxOut{txOut}, subnetworkid.SubnetworkIDCoinbase, 0, nil)
+	tx1 := NewSubnetworkMsgTx(0, []*TxIn{txIn}, []*TxOut{txOut}, &subnetworks.SubnetworkIDCoinbase, 0, nil)
 
 	// Ensure the hash produced is expected.
 	tx1Hash := tx1.TxHash()
-	if !tx1Hash.IsEqual((*daghash.Hash)(wantTxID1)) {
+	if *tx1Hash != (externalapi.DomainHash)(*wantTxHash1) {
 		t.Errorf("TxHash: wrong hash - got %v, want %v",
-			spew.Sprint(tx1Hash), spew.Sprint(wantTxID1))
+			spew.Sprint(tx1Hash), spew.Sprint(wantTxHash1))
 	}
 
 	// Ensure the TxID for coinbase transaction is the same as TxHash.
 	tx1ID := tx1.TxID()
-	if !tx1ID.IsEqual(wantTxID1) {
+	if !tx1ID.Equal(wantTxID1) {
 		t.Errorf("TxID: wrong ID - got %v, want %v",
 			spew.Sprint(tx1ID), spew.Sprint(wantTxID1))
 	}
 
-	hash2Str := "b11924b7eeffea821522222576c53dc5b8ddd97602f81e5e124d2626646d74ca"
-	wantHash2, err := daghash.NewHashFromStr(hash2Str)
+	hash2Str := "cb1bdb4a83d4885535fb3cceb5c96597b7df903db83f0ffcd779d703affd8efd"
+	wantHash2, err := externalapi.NewDomainHashFromString(hash2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}
 
-	id2Str := "750499ae9e6d44961ef8bad8af27a44dd4bcbea166b71baf181e8d3997e1ff72"
-	wantID2, err := daghash.NewTxIDFromStr(id2Str)
+	id2Str := "ca080073d4ddf5b84443a0964af633f3c70a5b290fd3bc35a7e6f93fd33f9330"
+	wantID2, err := transactionid.FromString(id2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
 		return
@@ -195,7 +202,7 @@ func TestTxHashAndID(t *testing.T) {
 	txIns := []*TxIn{{
 		PreviousOutpoint: Outpoint{
 			Index: 0,
-			TxID:  daghash.TxID{1, 2, 3},
+			TxID:  *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{1, 2, 3}),
 		},
 		SignatureScript: []byte{
 			0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xDA, 0x0D, 0xC6, 0xAE, 0xCE, 0xFE, 0x1E, 0x06, 0xEF, 0xDF,
@@ -213,730 +220,42 @@ func TestTxHashAndID(t *testing.T) {
 	txOuts := []*TxOut{
 		{
 			Value: 244623243,
-			ScriptPubKey: []byte{
+			ScriptPubKey: &externalapi.ScriptPublicKey{Script: []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,
-			},
+			}, Version: 0},
 		},
 		{
 			Value: 44602432,
-			ScriptPubKey: []byte{
+			ScriptPubKey: &externalapi.ScriptPublicKey{Script: []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,
-			},
+			}, Version: 0},
 		},
 	}
-	tx2 := NewSubnetworkMsgTx(1, txIns, txOuts, &subnetworkid.SubnetworkID{1, 2, 3}, 0, payload)
+	tx2 := NewSubnetworkMsgTx(1, txIns, txOuts, &externalapi.DomainSubnetworkID{1, 2, 3}, 0, payload)
 
 	// Ensure the hash produced is expected.
 	tx2Hash := tx2.TxHash()
-	if !tx2Hash.IsEqual(wantHash2) {
+	if !tx2Hash.Equal(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.IsEqual(wantID2) {
+	if !tx2ID.Equal(wantID2) {
 		t.Errorf("TxID: wrong ID - got %v, want %v",
 			spew.Sprint(tx2ID), spew.Sprint(wantID2))
 	}
 
-	if tx2ID.IsEqual((*daghash.TxID)(tx2Hash)) {
+	if tx2ID.Equal((*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.IsEqual((*daghash.TxID)(newTx2Hash)) {
-		t.Errorf("tx2ID and newTx2Hash should be the same for transaction with an empty signature")
+	if *tx2ID == (externalapi.DomainTransactionID)(*newTx2Hash) {
+		t.Errorf("tx2ID and newTx2Hash should not be the same even for transaction with an empty signature")
 	}
 }
-
-// TestTxEncoding tests the MsgTx appmessage encode and decode for various numbers
-// of transaction inputs and outputs and protocol versions.
-func TestTxEncoding(t *testing.T) {
-	// Empty tx message.
-	noTx := NewNativeMsgTx(1, nil, nil)
-	noTxEncoded := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version
-		0x00,                                           // Varint for number of input transactions
-		0x00,                                           // Varint for number of output transactions
-		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, // Sub Network ID
-	}
-
-	tests := []struct {
-		in   *MsgTx // Message to encode
-		out  *MsgTx // Expected decoded message
-		buf  []byte // Encoded value
-		pver uint32 // Protocol version for appmessage encoding
-	}{
-		// Latest protocol version with no transactions.
-		{
-			noTx,
-			noTx,
-			noTxEncoded,
-			ProtocolVersion,
-		},
-
-		// Latest protocol version with multiple transactions.
-		{
-			multiTx,
-			multiTx,
-			multiTxEncoded,
-			ProtocolVersion,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode the message to appmessage format.
-		var buf bytes.Buffer
-		err := test.in.KaspaEncode(&buf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaEncode #%d error %v", i, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Decode the message from appmessage format.
-		var msg MsgTx
-		rbuf := bytes.NewReader(test.buf)
-		err = msg.KaspaDecode(rbuf, test.pver)
-		if err != nil {
-			t.Errorf("KaspaDecode #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&msg, test.out) {
-			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
-				spew.Sdump(&msg), spew.Sdump(test.out))
-			continue
-		}
-	}
-}
-
-// TestTxEncodingErrors performs negative tests against appmessage encode and decode
-// of MsgTx to confirm error paths work correctly.
-func TestTxEncodingErrors(t *testing.T) {
-	pver := ProtocolVersion
-
-	tests := []struct {
-		in       *MsgTx // Value to encode
-		buf      []byte // Encoded value
-		pver     uint32 // Protocol version for appmessage encoding
-		max      int    // Max size of fixed buffer to induce errors
-		writeErr error  // Expected write error
-		readErr  error  // Expected read error
-	}{
-		// Force error in version.
-		{multiTx, multiTxEncoded, pver, 0, io.ErrShortWrite, io.EOF},
-		// Force error in number of transaction inputs.
-		{multiTx, multiTxEncoded, pver, 4, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input previous block hash.
-		{multiTx, multiTxEncoded, pver, 5, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input previous block output index.
-		{multiTx, multiTxEncoded, pver, 37, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input signature script length.
-		{multiTx, multiTxEncoded, pver, 41, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input signature script.
-		{multiTx, multiTxEncoded, pver, 42, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input sequence.
-		{multiTx, multiTxEncoded, pver, 49, io.ErrShortWrite, io.EOF},
-		// Force error in number of transaction outputs.
-		{multiTx, multiTxEncoded, pver, 57, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output value.
-		{multiTx, multiTxEncoded, pver, 58, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output scriptPubKey length.
-		{multiTx, multiTxEncoded, pver, 66, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output scriptPubKey.
-		{multiTx, multiTxEncoded, pver, 67, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output lock time.
-		{multiTx, multiTxEncoded, pver, 210, io.ErrShortWrite, io.EOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Encode to appmessage format.
-		w := newFixedWriter(test.max)
-		err := test.in.KaspaEncode(w, test.pver)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Decode from appmessage format.
-		var msg MsgTx
-		r := newFixedReader(test.max, test.buf)
-		err = msg.KaspaDecode(r, test.pver)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-}
-
-// TestTxSerialize tests MsgTx serialize and deserialize.
-func TestTxSerialize(t *testing.T) {
-	noTx := NewNativeMsgTx(1, nil, nil)
-	noTxEncoded := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version
-		0x00,                                           // Varint for number of input transactions
-		0x00,                                           // Varint for number of output transactions
-		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, // Sub Network ID
-	}
-
-	registryTx := NewRegistryMsgTx(1, nil, nil, 16)
-	registryTxEncoded := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version
-		0x00,                                           // Varint for number of input transactions
-		0x00,                                           // Varint for number of output transactions
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
-		0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, // Sub Network ID
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
-		0x77, 0x56, 0x36, 0xb4, 0x89, 0x32, 0xe9, 0xa8,
-		0xbb, 0x67, 0xe6, 0x54, 0x84, 0x36, 0x93, 0x8d,
-		0x9f, 0xc5, 0x62, 0x49, 0x79, 0x5c, 0x0d, 0x0a,
-		0x86, 0xaf, 0x7c, 0x5d, 0x54, 0x45, 0x4c, 0x4b, // Payload hash
-		0x08,                                           // Payload length varint
-		0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Payload / Gas limit
-	}
-
-	subnetworkTx := NewSubnetworkMsgTx(1, nil, nil, &subnetworkid.SubnetworkID{0xff}, 5, []byte{0, 1, 2})
-
-	subnetworkTxEncoded := []byte{
-		0x01, 0x00, 0x00, 0x00, // Version
-		0x00,                                           // Varint for number of input transactions
-		0x00,                                           // Varint for number of output transactions
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
-		0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, // Sub Network ID
-		0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
-		0x35, 0xf9, 0xf2, 0x93, 0x0e, 0xa3, 0x44, 0x61,
-		0x88, 0x22, 0x79, 0x5e, 0xee, 0xc5, 0x68, 0xae,
-		0x67, 0xab, 0x29, 0x87, 0xd8, 0xb1, 0x9e, 0x45,
-		0x91, 0xe1, 0x05, 0x27, 0xba, 0xa1, 0xdf, 0x3d, // Payload hash
-		0x03,             // Payload length varint
-		0x00, 0x01, 0x02, // Payload
-	}
-
-	tests := []struct {
-		name             string
-		in               *MsgTx // Message to encode
-		out              *MsgTx // Expected decoded message
-		buf              []byte // Serialized data
-		scriptPubKeyLocs []int  // Expected output script locations
-	}{
-		// No transactions.
-		{
-			"noTx",
-			noTx,
-			noTx,
-			noTxEncoded,
-			nil,
-		},
-
-		// Registry Transaction.
-		{
-			"registryTx",
-			registryTx,
-			registryTx,
-			registryTxEncoded,
-			nil,
-		},
-
-		// Sub Network Transaction.
-		{
-			"subnetworkTx",
-			subnetworkTx,
-			subnetworkTx,
-			subnetworkTxEncoded,
-			nil,
-		},
-
-		// Multiple transactions.
-		{
-			"multiTx",
-			multiTx,
-			multiTx,
-			multiTxEncoded,
-			multiTxScriptPubKeyLocs,
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Serialize the transaction.
-		var buf bytes.Buffer
-		err := test.in.Serialize(&buf)
-		if err != nil {
-			t.Errorf("Serialize %s: error %v", test.name, err)
-			continue
-		}
-		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("Serialize %s:\n got: %s want: %s", test.name,
-				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
-			continue
-		}
-
-		// Deserialize the transaction.
-		var tx MsgTx
-		rbuf := bytes.NewReader(test.buf)
-		err = tx.Deserialize(rbuf)
-		if err != nil {
-			t.Errorf("Deserialize #%d error %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(&tx, test.out) {
-			t.Errorf("Deserialize #%d\n got: %s want: %s", i,
-				spew.Sdump(&tx), spew.Sdump(test.out))
-			continue
-		}
-
-		// Ensure the public key script locations are accurate.
-		scriptPubKeyLocs := test.in.ScriptPubKeyLocs()
-		if !reflect.DeepEqual(scriptPubKeyLocs, test.scriptPubKeyLocs) {
-			t.Errorf("ScriptPubKeyLocs #%d\n got: %s want: %s", i,
-				spew.Sdump(scriptPubKeyLocs),
-				spew.Sdump(test.scriptPubKeyLocs))
-			continue
-		}
-		for j, loc := range scriptPubKeyLocs {
-			wantScriptPubKey := test.in.TxOut[j].ScriptPubKey
-			gotScriptPubKey := test.buf[loc : loc+len(wantScriptPubKey)]
-			if !bytes.Equal(gotScriptPubKey, wantScriptPubKey) {
-				t.Errorf("ScriptPubKeyLocs #%d:%d\n unexpected "+
-					"script got: %s want: %s", i, j,
-					spew.Sdump(gotScriptPubKey),
-					spew.Sdump(wantScriptPubKey))
-			}
-		}
-	}
-}
-
-// TestTxSerializeErrors performs negative tests against appmessage encode and decode
-// of MsgTx to confirm error paths work correctly.
-func TestTxSerializeErrors(t *testing.T) {
-	tests := []struct {
-		in       *MsgTx // Value to encode
-		buf      []byte // Serialized data
-		max      int    // Max size of fixed buffer to induce errors
-		writeErr error  // Expected write error
-		readErr  error  // Expected read error
-	}{
-		// Force error in version.
-		{multiTx, multiTxEncoded, 0, io.ErrShortWrite, io.EOF},
-		// Force error in number of transaction inputs.
-		{multiTx, multiTxEncoded, 4, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input previous block hash.
-		{multiTx, multiTxEncoded, 5, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input previous block output index.
-		{multiTx, multiTxEncoded, 37, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input signature script length.
-		{multiTx, multiTxEncoded, 41, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input signature script.
-		{multiTx, multiTxEncoded, 42, io.ErrShortWrite, io.EOF},
-		// Force error in transaction input sequence.
-		{multiTx, multiTxEncoded, 49, io.ErrShortWrite, io.EOF},
-		// Force error in number of transaction outputs.
-		{multiTx, multiTxEncoded, 57, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output value.
-		{multiTx, multiTxEncoded, 58, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output scriptPubKey length.
-		{multiTx, multiTxEncoded, 66, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output scriptPubKey.
-		{multiTx, multiTxEncoded, 67, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output lock time.
-		{multiTx, multiTxEncoded, 210, io.ErrShortWrite, io.EOF},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Serialize the transaction.
-		w := newFixedWriter(test.max)
-		err := test.in.Serialize(w)
-		if !errors.Is(err, test.writeErr) {
-			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
-				i, err, test.writeErr)
-			continue
-		}
-
-		// Deserialize the transaction.
-		var tx MsgTx
-		r := newFixedReader(test.max, test.buf)
-		err = tx.Deserialize(r)
-		if !errors.Is(err, test.readErr) {
-			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
-				i, err, test.readErr)
-			continue
-		}
-	}
-
-	registryTx := NewSubnetworkMsgTx(1, nil, nil, subnetworkid.SubnetworkIDRegistry, 1, nil)
-
-	w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
-	err := registryTx.Serialize(w)
-	str := "Transactions from built-in should have 0 gas"
-	expectedErr := messageError("MsgTx.KaspaEncode", str)
-	if err == nil || err.Error() != expectedErr.Error() {
-		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
-	}
-
-	nativeTx := NewSubnetworkMsgTx(1, nil, nil, subnetworkid.SubnetworkIDNative, 1, nil)
-	w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
-	err = nativeTx.Serialize(w)
-
-	str = "Transactions from native subnetwork should have 0 gas"
-	expectedErr = messageError("MsgTx.KaspaEncode", str)
-	if err == nil || err.Error() != expectedErr.Error() {
-		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
-	}
-
-	nativeTx.Gas = 0
-	nativeTx.Payload = []byte{1, 2, 3}
-	nativeTx.PayloadHash = daghash.DoubleHashP(nativeTx.Payload)
-	w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
-	err = nativeTx.Serialize(w)
-
-	str = "Transactions from native subnetwork should have <nil> payload"
-	expectedErr = messageError("MsgTx.KaspaEncode", str)
-	if err == nil || err.Error() != expectedErr.Error() {
-		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
-	}
-}
-
-// TestTxOverflowErrors performs tests to ensure deserializing transactions
-// which are intentionally crafted to use large values for the variable number
-// of inputs and outputs are handled properly. This could otherwise potentially
-// be used as an attack vector.
-func TestTxOverflowErrors(t *testing.T) {
-	pver := ProtocolVersion
-	txVer := uint32(1)
-
-	tests := []struct {
-		buf     []byte // Encoded value
-		pver    uint32 // Protocol version for appmessage encoding
-		version uint32 // Transaction version
-		err     error  // Expected error
-	}{
-		// Transaction that claims to have ~uint64(0) inputs.
-		{
-			[]byte{
-				0x00, 0x00, 0x00, 0x01, // Version
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0xff, // Varint for number of input transactions
-			}, pver, txVer, &MessageError{},
-		},
-
-		// Transaction that claims to have ~uint64(0) outputs.
-		{
-			[]byte{
-				0x00, 0x00, 0x00, 0x01, // Version
-				0x00, // Varint for number of input transactions
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0xff, // Varint for number of output transactions
-			}, pver, txVer, &MessageError{},
-		},
-
-		// Transaction that has an input with a signature script that
-		// claims to have ~uint64(0) length.
-		{
-			[]byte{
-				0x00, 0x00, 0x00, 0x01, // Version
-				0x01, // Varint for number of input transactions
-				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
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0xff, // Varint for length of signature script
-			}, pver, txVer, &MessageError{},
-		},
-
-		// Transaction that has an output with a public key script
-		// that claims to have ~uint64(0) length.
-		{
-			[]byte{
-				0x00, 0x00, 0x00, 0x01, // Version
-				0x01, // Varint for number of input transactions
-				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
-				0x00,                                           // Varint for length of signature script
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
-				0x01,                                           // Varint for number of output transactions
-				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Transaction amount
-				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-				0xff, // Varint for length of public key script
-			}, pver, txVer, &MessageError{},
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Decode from appmessage format.
-		var msg MsgTx
-		r := bytes.NewReader(test.buf)
-		err := msg.KaspaDecode(r, test.pver)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
-				i, err, reflect.TypeOf(test.err))
-			continue
-		}
-
-		// Decode from appmessage format.
-		r = bytes.NewReader(test.buf)
-		err = msg.Deserialize(r)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
-				i, err, reflect.TypeOf(test.err))
-			continue
-		}
-	}
-}
-
-// TestTxSerializeSize performs tests to ensure the serialize size for
-// various transactions is accurate.
-func TestTxSerializeSize(t *testing.T) {
-	// Empty tx message.
-	noTx := NewNativeMsgTx(1, nil, nil)
-
-	tests := []struct {
-		in   *MsgTx // Tx to encode
-		size int    // Expected serialized size
-	}{
-		// No inputs or outpus.
-		{noTx, 34},
-
-		// Transcaction with an input and an output.
-		{multiTx, 238},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		serializedSize := test.in.SerializeSize()
-		if serializedSize != test.size {
-			t.Errorf("MsgTx.SerializeSize: #%d got: %d, want: %d", i,
-				serializedSize, test.size)
-			continue
-		}
-	}
-}
-
-func TestIsSubnetworkCompatible(t *testing.T) {
-	testTx := NewSubnetworkMsgTx(1, nil, nil, &subnetworkid.SubnetworkID{123}, 0, []byte{})
-	tests := []struct {
-		name           string
-		subnetworkID   *subnetworkid.SubnetworkID
-		expectedResult bool
-	}{
-		{
-			name:           "Native subnetwork",
-			subnetworkID:   subnetworkid.SubnetworkIDNative,
-			expectedResult: true,
-		},
-		{
-			name:           "same subnetwork as test tx",
-			subnetworkID:   &subnetworkid.SubnetworkID{123},
-			expectedResult: true,
-		},
-		{
-			name:           "other subnetwork",
-			subnetworkID:   &subnetworkid.SubnetworkID{234},
-			expectedResult: false,
-		},
-	}
-
-	for _, test := range tests {
-		result := testTx.IsSubnetworkCompatible(test.subnetworkID)
-		if result != test.expectedResult {
-			t.Errorf("IsSubnetworkCompatible got unexpected result in test '%s': "+
-				"expected: %t, want: %t", test.name, test.expectedResult, result)
-		}
-	}
-}
-
-func TestScriptFreeList(t *testing.T) {
-	var list scriptFreeList = make(chan []byte, freeListMaxItems)
-
-	expectedCapacity := 512
-	expectedLengthFirst := 12
-	expectedLengthSecond := 13
-
-	first := list.Borrow(uint64(expectedLengthFirst))
-	if cap(first) != expectedCapacity {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected capacity for first %d, but got %d",
-			expectedCapacity, cap(first))
-	}
-	if len(first) != expectedLengthFirst {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected length for first %d, but got %d",
-			expectedLengthFirst, len(first))
-	}
-	list.Return(first)
-
-	// Borrow again, and check that the underlying array is re-used for second
-	second := list.Borrow(uint64(expectedLengthSecond))
-	if cap(second) != expectedCapacity {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected capacity for second %d, but got %d",
-			expectedCapacity, cap(second))
-	}
-	if len(second) != expectedLengthSecond {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected length for second %d, but got %d",
-			expectedLengthSecond, len(second))
-	}
-
-	firstArrayAddress := underlyingArrayAddress(first)
-	secondArrayAddress := underlyingArrayAddress(second)
-
-	if firstArrayAddress != secondArrayAddress {
-		t.Errorf("First underlying array is at address %d and second at address %d, "+
-			"which means memory was not re-used", firstArrayAddress, secondArrayAddress)
-	}
-
-	list.Return(second)
-
-	// test for buffers bigger than freeListMaxScriptSize
-	expectedCapacityBig := freeListMaxScriptSize + 1
-	expectedLengthBig := expectedCapacityBig
-	big := list.Borrow(uint64(expectedCapacityBig))
-
-	if cap(big) != expectedCapacityBig {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected capacity for second %d, but got %d",
-			expectedCapacityBig, cap(big))
-	}
-	if len(big) != expectedLengthBig {
-		t.Errorf("MsgTx.TestScriptFreeList: Expected length for second %d, but got %d",
-			expectedLengthBig, len(big))
-	}
-
-	list.Return(big)
-
-	// test there's no crash when channel is full because borrowed too much
-	buffers := make([][]byte, freeListMaxItems+1)
-	for i := 0; i < freeListMaxItems+1; i++ {
-		buffers[i] = list.Borrow(1)
-	}
-	for i := 0; i < freeListMaxItems+1; i++ {
-		list.Return(buffers[i])
-	}
-}
-
-func underlyingArrayAddress(buf []byte) uint64 {
-	return uint64((*reflect.SliceHeader)(unsafe.Pointer(&buf)).Data)
-}
-
-// multiTx is a MsgTx with an input and output and used in various tests.
-var multiTxIns = []*TxIn{
-	{
-		PreviousOutpoint: Outpoint{
-			TxID:  daghash.TxID{},
-			Index: 0xffffffff,
-		},
-		SignatureScript: []byte{
-			0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62,
-		},
-		Sequence: math.MaxUint64,
-	},
-}
-var multiTxOuts = []*TxOut{
-	{
-		Value: 0x12a05f200,
-		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
-		},
-	},
-	{
-		Value: 0x5f5e100,
-		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
-		},
-	},
-}
-var multiTx = NewNativeMsgTx(1, multiTxIns, multiTxOuts)
-
-// multiTxEncoded is the appmessage encoded bytes for multiTx using protocol version
-// 60002 and is used in the various tests.
-var multiTxEncoded = []byte{
-	0x01, 0x00, 0x00, 0x00, // Version
-	0x01, // Varint for number of input transactions
-	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, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62, // Signature script
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
-	0x02,                                           // Varint for number of output transactions
-	0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of scriptPubKey
-	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
-	0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of scriptPubKey
-	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
-	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, // Sub Network ID
-}
-
-// multiTxScriptPubKeyLocs is the location information for the public key scripts
-// located in multiTx.
-var multiTxScriptPubKeyLocs = []int{67, 143}

app/appmessage/p2p_msgversion.go

@@ -6,14 +6,13 @@ package appmessage
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/version"
 	"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"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
 )
 
 // MaxUserAgentLen is the maximum allowed length for the user agent field in a
@@ -54,14 +53,11 @@ type MsgVersion struct {
 	// on the appmessage. This has a max length of MaxUserAgentLen.
 	UserAgent string
 
-	// The selected tip hash of the generator of the version message.
-	SelectedTipHash *daghash.Hash
-
 	// Don't announce transactions to peer.
 	DisableRelayTx bool
 
 	// The subnetwork of the generator of the version message. Should be nil in full nodes
-	SubnetworkID *subnetworkid.SubnetworkID
+	SubnetworkID *externalapi.DomainSubnetworkID
 }
 
 // HasService returns whether the specified service is supported by the peer
@@ -86,7 +82,7 @@ func (msg *MsgVersion) Command() MessageCommand {
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
 func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
-	selectedTipHash *daghash.Hash, subnetworkID *subnetworkid.SubnetworkID) *MsgVersion {
+	subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
@@ -98,7 +94,6 @@ func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
 		Address:         addr,
 		ID:              id,
 		UserAgent:       DefaultUserAgent,
-		SelectedTipHash: selectedTipHash,
 		DisableRelayTx:  false,
 		SubnetworkID:    subnetworkID,
 	}

app/appmessage/p2p_msgversion_test.go

@@ -5,12 +5,12 @@
 package appmessage
 
 import (
-	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"net"
 	"reflect"
 	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
 // TestVersion tests the MsgVersion API.
@@ -18,7 +18,6 @@ func TestVersion(t *testing.T) {
 	pver := ProtocolVersion
 
 	// Create version message data.
-	selectedTipHash := &daghash.Hash{12, 34}
 	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
 	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
 	generatedID, err := id.GenerateID()
@@ -27,7 +26,7 @@ func TestVersion(t *testing.T) {
 	}
 
 	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
+	msg := NewMsgVersion(me, generatedID, "mainnet", nil)
 	if msg.ProtocolVersion != pver {
 		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
 			msg.ProtocolVersion, pver)
@@ -44,10 +43,6 @@ func TestVersion(t *testing.T) {
 		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
 			msg.UserAgent, DefaultUserAgent)
 	}
-	if !msg.SelectedTipHash.IsEqual(selectedTipHash) {
-		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
-			msg.SelectedTipHash, selectedTipHash)
-	}
 	if msg.DisableRelayTx {
 		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
 			"default - got %v, want %v", msg.DisableRelayTx, false)

app/appmessage/p2p_requestibdroothash.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgRequestIBDRootHashMessage implements the Message interface and represents a kaspa
+// MsgRequestIBDRootHashMessage message. It is used to request the IBD root hash
+// from a peer during IBD.
+//
+// This message has no payload.
+type MsgRequestIBDRootHashMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDRootHashMessage) Command() MessageCommand {
+	return CmdRequestIBDRootHash
+}
+
+// NewMsgRequestIBDRootHashMessage returns a new kaspa RequestIBDRootHash message that conforms to the
+// Message interface.
+func NewMsgRequestIBDRootHashMessage() *MsgRequestIBDRootHashMessage {
+	return &MsgRequestIBDRootHashMessage{}
+}

app/appmessage/rpc_get_block.go

@@ -6,8 +6,6 @@ type GetBlockRequestMessage struct {
 	baseMessage
 	Hash                          string
 	SubnetworkID                  string
-	IncludeBlockHex               bool
-	IncludeBlockVerboseData       bool
 	IncludeTransactionVerboseData bool
 }
 
@@ -17,13 +15,10 @@ func (msg *GetBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockRequestMessage returns a instance of the message
-func NewGetBlockRequestMessage(hash string, subnetworkID string, includeBlockHex bool,
-	includeBlockVerboseData bool, includeTransactionVerboseData bool) *GetBlockRequestMessage {
+func NewGetBlockRequestMessage(hash string, subnetworkID string, includeTransactionVerboseData bool) *GetBlockRequestMessage {
 	return &GetBlockRequestMessage{
 		Hash:                          hash,
 		SubnetworkID:                  subnetworkID,
-		IncludeBlockHex:               includeBlockHex,
-		IncludeBlockVerboseData:       includeBlockVerboseData,
 		IncludeTransactionVerboseData: includeTransactionVerboseData,
 	}
 }
@@ -32,7 +27,6 @@ func NewGetBlockRequestMessage(hash string, subnetworkID string, includeBlockHex
 // its respective RPC message
 type GetBlockResponseMessage struct {
 	baseMessage
-	BlockHex         string
 	BlockVerboseData *BlockVerboseData
 
 	Error *RPCError
@@ -51,11 +45,7 @@ func NewGetBlockResponseMessage() *GetBlockResponseMessage {
 // BlockVerboseData holds verbose data about a block
 type BlockVerboseData struct {
 	Hash                   string
-	Confirmations          uint64
-	Size                   int32
-	BlueScore              uint64
-	IsChainBlock           bool
-	Version                int32
+	Version                uint16
 	VersionHex             string
 	HashMerkleRoot         string
 	AcceptedIDMerkleRoot   string
@@ -68,17 +58,16 @@ type BlockVerboseData struct {
 	Difficulty             float64
 	ParentHashes           []string
 	SelectedParentHash     string
-	ChildHashes            []string
-	AcceptedBlockHashes    []string
+	BlueScore              uint64
+	IsHeaderOnly           bool
 }
 
 // TransactionVerboseData holds verbose data about a transaction
 type TransactionVerboseData struct {
-	Hex                       string
 	TxID                      string
 	Hash                      string
-	Size                      int32
-	Version                   int32
+	Size                      uint64
+	Version                   uint16
 	LockTime                  uint64
 	SubnetworkID              string
 	Gas                       uint64
@@ -87,8 +76,6 @@ type TransactionVerboseData struct {
 	TransactionVerboseInputs  []*TransactionVerboseInput
 	TransactionVerboseOutputs []*TransactionVerboseOutput
 	BlockHash                 string
-	AcceptedBy                string
-	IsInMempool               bool
 	Time                      uint64
 	BlockTime                 uint64
 }
@@ -116,7 +103,6 @@ type TransactionVerboseOutput struct {
 
 // 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,5 +1,7 @@
 package appmessage
 
+import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 // GetBlockCountRequestMessage is an appmessage corresponding to
 // its respective RPC message
 type GetBlockCountRequestMessage struct {
@@ -20,7 +22,8 @@ func NewGetBlockCountRequestMessage() *GetBlockCountRequestMessage {
 // its respective RPC message
 type GetBlockCountResponseMessage struct {
 	baseMessage
-	BlockCount uint64
+	BlockCount  uint64
+	HeaderCount uint64
 
 	Error *RPCError
 }
@@ -31,8 +34,9 @@ func (msg *GetBlockCountResponseMessage) Command() MessageCommand {
 }
 
 // NewGetBlockCountResponseMessage returns a instance of the message
-func NewGetBlockCountResponseMessage(blockCount uint64) *GetBlockCountResponseMessage {
+func NewGetBlockCountResponseMessage(syncInfo *externalapi.SyncInfo) *GetBlockCountResponseMessage {
 	return &GetBlockCountResponseMessage{
-		BlockCount: blockCount,
+		BlockCount:  syncInfo.BlockCount,
+		HeaderCount: syncInfo.HeaderCount,
 	}
 }

app/appmessage/rpc_get_block_dag_info.go

@@ -22,6 +22,7 @@ type GetBlockDAGInfoResponseMessage struct {
 	baseMessage
 	NetworkName         string
 	BlockCount          uint64
+	HeaderCount         uint64
 	TipHashes           []string
 	VirtualParentHashes []string
 	Difficulty          float64

app/appmessage/rpc_get_block_template.go

@@ -5,7 +5,6 @@ package appmessage
 type GetBlockTemplateRequestMessage struct {
 	baseMessage
 	PayAddress string
-	LongPollID string
 }
 
 // Command returns the protocol command string for the message
@@ -14,10 +13,9 @@ func (msg *GetBlockTemplateRequestMessage) Command() MessageCommand {
 }
 
 // NewGetBlockTemplateRequestMessage returns a instance of the message
-func NewGetBlockTemplateRequestMessage(payAddress string, longPollID string) *GetBlockTemplateRequestMessage {
+func NewGetBlockTemplateRequestMessage(payAddress string) *GetBlockTemplateRequestMessage {
 	return &GetBlockTemplateRequestMessage{
 		PayAddress: payAddress,
-		LongPollID: longPollID,
 	}
 }
 
@@ -25,23 +23,8 @@ func NewGetBlockTemplateRequestMessage(payAddress string, longPollID string) *Ge
 // its respective RPC message
 type GetBlockTemplateResponseMessage struct {
 	baseMessage
-	Bits                 string
-	CurrentTime          int64
-	ParentHashes         []string
-	MassLimit            int
-	Transactions         []GetBlockTemplateTransactionMessage
-	HashMerkleRoot       string
-	AcceptedIDMerkleRoot string
-	UTXOCommitment       string
-	Version              int32
-	LongPollID           string
-	TargetDifficulty     string
-	MinTime              int64
-	MaxTime              int64
-	MutableFields        []string
-	NonceRange           string
-	IsSynced             bool
-	IsConnected          bool
+	MsgBlock *MsgBlock
+	IsSynced bool
 
 	Error *RPCError
 }
@@ -52,27 +35,9 @@ func (msg *GetBlockTemplateResponseMessage) Command() MessageCommand {
 }
 
 // NewGetBlockTemplateResponseMessage returns a instance of the message
-func NewGetBlockTemplateResponseMessage() *GetBlockTemplateResponseMessage {
-	return &GetBlockTemplateResponseMessage{}
-}
-
-// GetBlockTemplateTransactionMessage is an appmessage corresponding to
-// its respective RPC message
-type GetBlockTemplateTransactionMessage struct {
-	baseMessage
-	Data    string
-	ID      string
-	Depends []int64
-	Mass    uint64
-	Fee     uint64
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetBlockTemplateTransactionMessage) Command() MessageCommand {
-	return CmdGetBlockTemplateTransactionMessage
-}
-
-// NewGetBlockTemplateTransactionMessage returns a instance of the message
-func NewGetBlockTemplateTransactionMessage() *GetBlockTemplateTransactionMessage {
-	return &GetBlockTemplateTransactionMessage{}
+func NewGetBlockTemplateResponseMessage(msgBlock *MsgBlock, isSynced bool) *GetBlockTemplateResponseMessage {
+	return &GetBlockTemplateResponseMessage{
+		MsgBlock: msgBlock,
+		IsSynced: isSynced,
+	}
 }

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

@@ -41,11 +41,10 @@ type GetConnectedPeerInfoMessage struct {
 	ID                        string
 	Address                   string
 	LastPingDuration          int64
-	SelectedTipHash           string
-	IsSyncNode                bool
 	IsOutbound                bool
 	TimeOffset                int64
 	UserAgent                 string
 	AdvertisedProtocolVersion uint32
 	TimeConnected             int64
+	IsIBDPeer                 bool
 }

app/appmessage/rpc_get_headers.go

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

app/appmessage/rpc_get_peer_addresses.go

@@ -20,7 +20,8 @@ func NewGetPeerAddressesRequestMessage() *GetPeerAddressesRequestMessage {
 // its respective RPC message
 type GetPeerAddressesResponseMessage struct {
 	baseMessage
-	Addresses []*GetPeerAddressesKnownAddressMessage
+	Addresses       []*GetPeerAddressesKnownAddressMessage
+	BannedAddresses []*GetPeerAddressesKnownAddressMessage
 
 	Error *RPCError
 }
@@ -31,9 +32,10 @@ func (msg *GetPeerAddressesResponseMessage) Command() MessageCommand {
 }
 
 // NewGetPeerAddressesResponseMessage returns a instance of the message
-func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
+func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage, bannedAddresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
 	return &GetPeerAddressesResponseMessage{
-		Addresses: addresses,
+		Addresses:       addresses,
+		BannedAddresses: bannedAddresses,
 	}
 }
 

app/appmessage/rpc_get_utxos_by_addresses.go

@@ -0,0 +1,41 @@
+package appmessage
+
+// GetUTXOsByAddressesRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetUTXOsByAddressesRequestMessage struct {
+	baseMessage
+	Addresses []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetUTXOsByAddressesRequestMessage) Command() MessageCommand {
+	return CmdGetUTXOsByAddressesRequestMessage
+}
+
+// NewGetUTXOsByAddressesRequestMessage returns a instance of the message
+func NewGetUTXOsByAddressesRequestMessage(addresses []string) *GetUTXOsByAddressesRequestMessage {
+	return &GetUTXOsByAddressesRequestMessage{
+		Addresses: addresses,
+	}
+}
+
+// GetUTXOsByAddressesResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetUTXOsByAddressesResponseMessage struct {
+	baseMessage
+	Entries []*UTXOsByAddressesEntry
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetUTXOsByAddressesResponseMessage) Command() MessageCommand {
+	return CmdGetUTXOsByAddressesResponseMessage
+}
+
+// NewGetUTXOsByAddressesResponseMessage returns a instance of the message
+func NewGetUTXOsByAddressesResponseMessage(entries []*UTXOsByAddressesEntry) *GetUTXOsByAddressesResponseMessage {
+	return &GetUTXOsByAddressesResponseMessage{
+		Entries: entries,
+	}
+}

app/appmessage/rpc_get_virtual_selected_parent_blue_score.go

@@ -0,0 +1,38 @@
+package appmessage
+
+// GetVirtualSelectedParentBlueScoreRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetVirtualSelectedParentBlueScoreRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetVirtualSelectedParentBlueScoreRequestMessage) Command() MessageCommand {
+	return CmdGetVirtualSelectedParentBlueScoreRequestMessage
+}
+
+// NewGetVirtualSelectedParentBlueScoreRequestMessage returns a instance of the message
+func NewGetVirtualSelectedParentBlueScoreRequestMessage() *GetVirtualSelectedParentBlueScoreRequestMessage {
+	return &GetVirtualSelectedParentBlueScoreRequestMessage{}
+}
+
+// GetVirtualSelectedParentBlueScoreResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetVirtualSelectedParentBlueScoreResponseMessage struct {
+	baseMessage
+	BlueScore uint64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetVirtualSelectedParentBlueScoreResponseMessage) Command() MessageCommand {
+	return CmdGetVirtualSelectedParentBlueScoreResponseMessage
+}
+
+// NewGetVirtualSelectedParentBlueScoreResponseMessage returns a instance of the message
+func NewGetVirtualSelectedParentBlueScoreResponseMessage(blueScore uint64) *GetVirtualSelectedParentBlueScoreResponseMessage {
+	return &GetVirtualSelectedParentBlueScoreResponseMessage{
+		BlueScore: blueScore,
+	}
+}

app/appmessage/rpc_get_virtual_selected_parent_chain_from_block.go

@@ -0,0 +1,45 @@
+package appmessage
+
+// GetVirtualSelectedParentChainFromBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetVirtualSelectedParentChainFromBlockRequestMessage struct {
+	baseMessage
+	StartHash string
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetVirtualSelectedParentChainFromBlockRequestMessage) Command() MessageCommand {
+	return CmdGetVirtualSelectedParentChainFromBlockRequestMessage
+}
+
+// NewGetVirtualSelectedParentChainFromBlockRequestMessage returns a instance of the message
+func NewGetVirtualSelectedParentChainFromBlockRequestMessage(startHash string) *GetVirtualSelectedParentChainFromBlockRequestMessage {
+	return &GetVirtualSelectedParentChainFromBlockRequestMessage{
+		StartHash: startHash,
+	}
+}
+
+// GetVirtualSelectedParentChainFromBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetVirtualSelectedParentChainFromBlockResponseMessage struct {
+	baseMessage
+	RemovedChainBlockHashes []string
+	AddedChainBlocks        []*ChainBlock
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetVirtualSelectedParentChainFromBlockResponseMessage) Command() MessageCommand {
+	return CmdGetVirtualSelectedParentChainFromBlockResponseMessage
+}
+
+// NewGetVirtualSelectedParentChainFromBlockResponseMessage returns a instance of the message
+func NewGetVirtualSelectedParentChainFromBlockResponseMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock) *GetVirtualSelectedParentChainFromBlockResponseMessage {
+
+	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+	}
+}

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

@@ -0,0 +1,62 @@
+package appmessage
+
+// NotifyUTXOsChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyUTXOsChangedRequestMessage struct {
+	baseMessage
+	Addresses []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyUTXOsChangedRequestMessage) Command() MessageCommand {
+	return CmdNotifyUTXOsChangedRequestMessage
+}
+
+// NewNotifyUTXOsChangedRequestMessage returns a instance of the message
+func NewNotifyUTXOsChangedRequestMessage(addresses []string) *NotifyUTXOsChangedRequestMessage {
+	return &NotifyUTXOsChangedRequestMessage{
+		Addresses: addresses,
+	}
+}
+
+// NotifyUTXOsChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyUTXOsChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyUTXOsChangedResponseMessage) Command() MessageCommand {
+	return CmdNotifyUTXOsChangedResponseMessage
+}
+
+// NewNotifyUTXOsChangedResponseMessage returns a instance of the message
+func NewNotifyUTXOsChangedResponseMessage() *NotifyUTXOsChangedResponseMessage {
+	return &NotifyUTXOsChangedResponseMessage{}
+}
+
+// UTXOsChangedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type UTXOsChangedNotificationMessage struct {
+	baseMessage
+	Added   []*UTXOsByAddressesEntry
+	Removed []*UTXOsByAddressesEntry
+}
+
+// UTXOsByAddressesEntry represents a UTXO of some address
+type UTXOsByAddressesEntry struct {
+	Address   string
+	Outpoint  *RPCOutpoint
+	UTXOEntry *RPCUTXOEntry
+}
+
+// Command returns the protocol command string for the message
+func (msg *UTXOsChangedNotificationMessage) Command() MessageCommand {
+	return CmdUTXOsChangedNotificationMessage
+}
+
+// NewUTXOsChangedNotificationMessage returns a instance of the message
+func NewUTXOsChangedNotificationMessage() *UTXOsChangedNotificationMessage {
+	return &UTXOsChangedNotificationMessage{}
+}

app/appmessage/rpc_notify_virtual_selected_parent_chain_blue_score_changed.go

@@ -0,0 +1,55 @@
+package appmessage
+
+// NotifyVirtualSelectedParentBlueScoreChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyVirtualSelectedParentBlueScoreChangedRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyVirtualSelectedParentBlueScoreChangedRequestMessage) Command() MessageCommand {
+	return CmdNotifyVirtualSelectedParentBlueScoreChangedRequestMessage
+}
+
+// NewNotifyVirtualSelectedParentBlueScoreChangedRequestMessage returns a instance of the message
+func NewNotifyVirtualSelectedParentBlueScoreChangedRequestMessage() *NotifyVirtualSelectedParentBlueScoreChangedRequestMessage {
+	return &NotifyVirtualSelectedParentBlueScoreChangedRequestMessage{}
+}
+
+// NotifyVirtualSelectedParentBlueScoreChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyVirtualSelectedParentBlueScoreChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyVirtualSelectedParentBlueScoreChangedResponseMessage) Command() MessageCommand {
+	return CmdNotifyVirtualSelectedParentBlueScoreChangedResponseMessage
+}
+
+// NewNotifyVirtualSelectedParentBlueScoreChangedResponseMessage returns a instance of the message
+func NewNotifyVirtualSelectedParentBlueScoreChangedResponseMessage() *NotifyVirtualSelectedParentBlueScoreChangedResponseMessage {
+	return &NotifyVirtualSelectedParentBlueScoreChangedResponseMessage{}
+}
+
+// VirtualSelectedParentBlueScoreChangedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type VirtualSelectedParentBlueScoreChangedNotificationMessage struct {
+	baseMessage
+	VirtualSelectedParentBlueScore uint64
+}
+
+// Command returns the protocol command string for the message
+func (msg *VirtualSelectedParentBlueScoreChangedNotificationMessage) Command() MessageCommand {
+	return CmdVirtualSelectedParentBlueScoreChangedNotificationMessage
+}
+
+// NewVirtualSelectedParentBlueScoreChangedNotificationMessage returns a instance of the message
+func NewVirtualSelectedParentBlueScoreChangedNotificationMessage(
+	virtualSelectedParentBlueScore uint64) *VirtualSelectedParentBlueScoreChangedNotificationMessage {
+
+	return &VirtualSelectedParentBlueScoreChangedNotificationMessage{
+		VirtualSelectedParentBlueScore: virtualSelectedParentBlueScore,
+	}
+}

app/appmessage/rpc_notify_virtual_selected_parent_chain_changed.go

@@ -0,0 +1,69 @@
+package appmessage
+
+// NotifyVirtualSelectedParentChainChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyVirtualSelectedParentChainChangedRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyVirtualSelectedParentChainChangedRequestMessage) Command() MessageCommand {
+	return CmdNotifyVirtualSelectedParentChainChangedRequestMessage
+}
+
+// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns a instance of the message
+func NewNotifyVirtualSelectedParentChainChangedRequestMessage() *NotifyVirtualSelectedParentChainChangedRequestMessage {
+	return &NotifyVirtualSelectedParentChainChangedRequestMessage{}
+}
+
+// NotifyVirtualSelectedParentChainChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyVirtualSelectedParentChainChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyVirtualSelectedParentChainChangedResponseMessage) Command() MessageCommand {
+	return CmdNotifyVirtualSelectedParentChainChangedResponseMessage
+}
+
+// NewNotifyVirtualSelectedParentChainChangedResponseMessage returns a instance of the message
+func NewNotifyVirtualSelectedParentChainChangedResponseMessage() *NotifyVirtualSelectedParentChainChangedResponseMessage {
+	return &NotifyVirtualSelectedParentChainChangedResponseMessage{}
+}
+
+// VirtualSelectedParentChainChangedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type VirtualSelectedParentChainChangedNotificationMessage 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
+	AcceptedTransactionIDs []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *VirtualSelectedParentChainChangedNotificationMessage) Command() MessageCommand {
+	return CmdVirtualSelectedParentChainChangedNotificationMessage
+}
+
+// NewVirtualSelectedParentChainChangedNotificationMessage returns a instance of the message
+func NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock) *VirtualSelectedParentChainChangedNotificationMessage {
+
+	return &VirtualSelectedParentChainChangedNotificationMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+	}
+}

app/appmessage/rpc_submit_block.go

@@ -4,7 +4,7 @@ package appmessage
 // its respective RPC message
 type SubmitBlockRequestMessage struct {
 	baseMessage
-	BlockHex string
+	Block *MsgBlock
 }
 
 // Command returns the protocol command string for the message
@@ -13,17 +13,39 @@ func (msg *SubmitBlockRequestMessage) Command() MessageCommand {
 }
 
 // NewSubmitBlockRequestMessage returns a instance of the message
-func NewSubmitBlockRequestMessage(blockHex string) *SubmitBlockRequestMessage {
+func NewSubmitBlockRequestMessage(block *MsgBlock) *SubmitBlockRequestMessage {
 	return &SubmitBlockRequestMessage{
-		BlockHex: blockHex,
+		Block: block,
 	}
 }
 
+// RejectReason describes the reason why a block sent by SubmitBlock was rejected
+type RejectReason byte
+
+// RejectReason constants
+// Not using iota, since in the .proto file those are hardcoded
+const (
+	RejectReasonNone         RejectReason = 0
+	RejectReasonBlockInvalid RejectReason = 1
+	RejectReasonIsInIBD      RejectReason = 2
+)
+
+var rejectReasonToString = map[RejectReason]string{
+	RejectReasonNone:         "None",
+	RejectReasonBlockInvalid: "Block is invalid",
+	RejectReasonIsInIBD:      "Node is in IBD",
+}
+
+func (rr RejectReason) String() string {
+	return rejectReasonToString[rr]
+}
+
 // SubmitBlockResponseMessage is an appmessage corresponding to
 // its respective RPC message
 type SubmitBlockResponseMessage struct {
 	baseMessage
-	Error *RPCError
+	RejectReason RejectReason
+	Error        *RPCError
 }
 
 // Command returns the protocol command string for the message

app/appmessage/rpc_submit_transaction.go

@@ -4,7 +4,7 @@ package appmessage
 // its respective RPC message
 type SubmitTransactionRequestMessage struct {
 	baseMessage
-	TransactionHex string
+	Transaction *RPCTransaction
 }
 
 // Command returns the protocol command string for the message
@@ -13,9 +13,9 @@ func (msg *SubmitTransactionRequestMessage) Command() MessageCommand {
 }
 
 // NewSubmitTransactionRequestMessage returns a instance of the message
-func NewSubmitTransactionRequestMessage(transactionHex string) *SubmitTransactionRequestMessage {
+func NewSubmitTransactionRequestMessage(transaction *RPCTransaction) *SubmitTransactionRequestMessage {
 	return &SubmitTransactionRequestMessage{
-		TransactionHex: transactionHex,
+		Transaction: transaction,
 	}
 }
 
@@ -23,7 +23,7 @@ func NewSubmitTransactionRequestMessage(transactionHex string) *SubmitTransactio
 // its respective RPC message
 type SubmitTransactionResponseMessage struct {
 	baseMessage
-	TxID string
+	TransactionID string
 
 	Error *RPCError
 }
@@ -34,8 +34,58 @@ func (msg *SubmitTransactionResponseMessage) Command() MessageCommand {
 }
 
 // NewSubmitTransactionResponseMessage returns a instance of the message
-func NewSubmitTransactionResponseMessage(txID string) *SubmitTransactionResponseMessage {
+func NewSubmitTransactionResponseMessage(transactionID string) *SubmitTransactionResponseMessage {
 	return &SubmitTransactionResponseMessage{
-		TxID: txID,
+		TransactionID: transactionID,
 	}
 }
+
+// RPCTransaction is a kaspad transaction representation meant to be
+// used over RPC
+type RPCTransaction struct {
+	Version      uint16
+	Inputs       []*RPCTransactionInput
+	Outputs      []*RPCTransactionOutput
+	LockTime     uint64
+	SubnetworkID string
+	Gas          uint64
+	PayloadHash  string
+	Payload      string
+}
+
+// RPCTransactionInput is a kaspad transaction input representation
+// meant to be used over RPC
+type RPCTransactionInput struct {
+	PreviousOutpoint *RPCOutpoint
+	SignatureScript  string
+	Sequence         uint64
+}
+
+// RPCScriptPublicKey is a kaspad ScriptPublicKey representation
+type RPCScriptPublicKey struct {
+	Version uint16
+	Script  string
+}
+
+// RPCTransactionOutput is a kaspad transaction output representation
+// meant to be used over RPC
+type RPCTransactionOutput struct {
+	Amount          uint64
+	ScriptPublicKey *RPCScriptPublicKey
+}
+
+// RPCOutpoint is a kaspad outpoint representation meant to be used
+// over RPC
+type RPCOutpoint struct {
+	TransactionID string
+	Index         uint32
+}
+
+// RPCUTXOEntry is a kaspad utxo entry representation meant to be used
+// over RPC
+type RPCUTXOEntry struct {
+	Amount          uint64
+	ScriptPublicKey *RPCScriptPublicKey
+	BlockBlueScore  uint64
+	IsCoinbase      bool
+}

app/component_manager.go

@@ -4,6 +4,12 @@ import (
 	"fmt"
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/domain/utxoindex"
+
+	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"
@@ -11,13 +17,7 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol"
 	"github.com/kaspanet/kaspad/app/rpc"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
-	"github.com/kaspanet/kaspad/domain/mempool"
-	"github.com/kaspanet/kaspad/domain/mining"
-	"github.com/kaspanet/kaspad/domain/txscript"
 	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
@@ -72,46 +72,44 @@ func (a *ComponentManager) Stop() {
 		log.Errorf("Error stopping the net adapter: %+v", err)
 	}
 
-	err = a.addressManager.Stop()
-	if err != nil {
-		log.Errorf("Error stopping address manager: %s", err)
-	}
-
 	return
 }
 
 // NewComponentManager returns a new ComponentManager instance.
 // Use Start() to begin all services within this ComponentManager
-func NewComponentManager(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt chan<- struct{}) (*ComponentManager, error) {
-	indexManager, acceptanceIndex := setupIndexes(cfg)
+func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database, interrupt chan<- struct{}) (
+	*ComponentManager, error) {
 
-	sigCache := txscript.NewSigCache(cfg.SigCacheMaxSize)
-
-	// Create a new block DAG instance with the appropriate configuration.
-	dag, err := setupDAG(cfg, databaseContext, sigCache, indexManager)
+	domain, err := domain.New(cfg.ActiveNetParams, db, cfg.IsArchivalNode)
 	if err != nil {
 		return nil, err
 	}
 
-	txMempool := setupMempool(cfg, dag, sigCache)
-
 	netAdapter, err := netadapter.NewNetAdapter(cfg)
 	if err != nil {
 		return nil, err
 	}
-	addressManager, err := addressmanager.New(cfg, databaseContext)
+
+	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg))
 	if err != nil {
 		return nil, err
 	}
+
+	var utxoIndex *utxoindex.UTXOIndex
+	if cfg.UTXOIndex {
+		utxoIndex = utxoindex.New(domain.Consensus(), db)
+		log.Infof("UTXO index started")
+	}
+
 	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
 	if err != nil {
 		return nil, err
 	}
-	protocolManager, err := protocol.NewManager(cfg, dag, netAdapter, addressManager, txMempool, connectionManager)
+	protocolManager, err := protocol.NewManager(cfg, domain, netAdapter, addressManager, connectionManager)
 	if err != nil {
 		return nil, err
 	}
-	rpcManager := setupRPC(cfg, txMempool, dag, sigCache, netAdapter, protocolManager, connectionManager, addressManager, acceptanceIndex, interrupt)
+	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, interrupt)
 
 	return &ComponentManager{
 		cfg:               cfg,
@@ -126,60 +124,30 @@ func NewComponentManager(cfg *config.Config, databaseContext *dbaccess.DatabaseC
 
 func setupRPC(
 	cfg *config.Config,
-	txMempool *mempool.TxPool,
-	dag *blockdag.BlockDAG,
-	sigCache *txscript.SigCache,
+	domain domain.Domain,
 	netAdapter *netadapter.NetAdapter,
 	protocolManager *protocol.Manager,
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
-	acceptanceIndex *indexers.AcceptanceIndex,
+	utxoIndex *utxoindex.UTXOIndex,
 	shutDownChan chan<- struct{},
 ) *rpc.Manager {
 
-	blockTemplateGenerator := mining.NewBlkTmplGenerator(&mining.Policy{BlockMaxMass: cfg.BlockMaxMass}, txMempool, dag, sigCache)
-	rpcManager := rpc.NewManager(cfg, netAdapter, dag, protocolManager, connectionManager, blockTemplateGenerator, txMempool, addressManager, acceptanceIndex, shutDownChan)
+	rpcManager := rpc.NewManager(
+		cfg,
+		domain,
+		netAdapter,
+		protocolManager,
+		connectionManager,
+		addressManager,
+		utxoIndex,
+		shutDownChan,
+	)
 	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
-	protocolManager.SetOnTransactionAddedToMempoolHandler(rpcManager.NotifyTransactionAddedToMempool)
-	dag.Subscribe(func(notification *blockdag.Notification) {
-		err := handleBlockDAGNotifications(notification, acceptanceIndex, rpcManager)
-		if err != nil {
-			panic(err)
-		}
-	})
+
 	return rpcManager
 }
 
-func handleBlockDAGNotifications(notification *blockdag.Notification,
-	acceptanceIndex *indexers.AcceptanceIndex, rpcManager *rpc.Manager) error {
-
-	switch notification.Type {
-	case blockdag.NTChainChanged:
-		if acceptanceIndex == nil {
-			return nil
-		}
-		chainChangedNotificationData := notification.Data.(*blockdag.ChainChangedNotificationData)
-		err := rpcManager.NotifyChainChanged(chainChangedNotificationData.RemovedChainBlockHashes,
-			chainChangedNotificationData.AddedChainBlockHashes)
-		if err != nil {
-			return err
-		}
-	case blockdag.NTFinalityConflict:
-		finalityConflictNotificationData := notification.Data.(*blockdag.FinalityConflictNotificationData)
-		err := rpcManager.NotifyFinalityConflict(finalityConflictNotificationData.ViolatingBlockHash.String())
-		if err != nil {
-			return err
-		}
-	case blockdag.NTFinalityConflictResolved:
-		finalityConflictResolvedNotificationData := notification.Data.(*blockdag.FinalityConflictResolvedNotificationData)
-		err := rpcManager.NotifyFinalityConflictResolved(finalityConflictResolvedNotificationData.FinalityBlockHash.String())
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func (a *ComponentManager) maybeSeedFromDNS() {
 	if !a.cfg.DisableDNSSeed {
 		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
@@ -187,68 +155,16 @@ func (a *ComponentManager) maybeSeedFromDNS() {
 				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
 				// IPs of nodes and not its own IP, we can not know real IP of
 				// source. So we'll take first returned address as source.
-				a.addressManager.AddAddresses(addresses, addresses[0], nil)
+				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, addresses[0], nil)
+				a.addressManager.AddAddresses(addresses...)
 			})
 	}
 }
 
-func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext,
-	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
-
-	dag, err := blockdag.New(&blockdag.Config{
-		DatabaseContext:  databaseContext,
-		DAGParams:        cfg.NetParams(),
-		TimeSource:       blockdag.NewTimeSource(),
-		SigCache:         sigCache,
-		IndexManager:     indexManager,
-		SubnetworkID:     cfg.SubnetworkID,
-		MaxUTXOCacheSize: cfg.MaxUTXOCacheSize,
-	})
-	return dag, err
-}
-
-func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.AcceptanceIndex) {
-	// Create indexes if needed.
-	var indexes []indexers.Indexer
-	var acceptanceIndex *indexers.AcceptanceIndex
-	if cfg.AcceptanceIndex {
-		log.Info("acceptance index is enabled")
-		acceptanceIndex = indexers.NewAcceptanceIndex()
-		indexes = append(indexes, acceptanceIndex)
-	}
-
-	// Create an index manager if any of the optional indexes are enabled.
-	if len(indexes) < 0 {
-		return nil, nil
-	}
-	indexManager := indexers.NewManager(indexes)
-	return indexManager, acceptanceIndex
-}
-
-func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript.SigCache) *mempool.TxPool {
-	mempoolConfig := mempool.Config{
-		Policy: mempool.Policy{
-			AcceptNonStd:    cfg.RelayNonStd,
-			MaxOrphanTxs:    cfg.MaxOrphanTxs,
-			MaxOrphanTxSize: config.DefaultMaxOrphanTxSize,
-			MinRelayTxFee:   cfg.MinRelayTxFee,
-			MaxTxVersion:    1,
-		},
-		CalcTxSequenceLockFromReferencedUTXOEntries: dag.CalcTxSequenceLockFromReferencedUTXOEntries,
-		SigCache: sigCache,
-		DAG:      dag,
-	}
-
-	return mempool.New(&mempoolConfig)
-}
-
 // P2PNodeID returns the network ID associated with this ComponentManager
 func (a *ComponentManager) P2PNodeID() *id.ID {
 	return a.netAdapter.ID()

app/protocol/blocklogger/blocklogger.go

@@ -5,11 +5,11 @@
 package blocklogger
 
 import (
-	"github.com/kaspanet/kaspad/util/mstime"
 	"sync"
 	"time"
 
-	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/util/mstime"
 )
 
 var (
@@ -22,17 +22,17 @@ var (
 // LogBlock logs a new block blue score as an information message
 // to show progress to the user. In order to prevent spam, it limits logging to
 // one message every 10 seconds with duration and totals included.
-func LogBlock(block *util.Block) error {
+func LogBlock(block *externalapi.DomainBlock) {
 	mtx.Lock()
 	defer mtx.Unlock()
 
 	receivedLogBlocks++
-	receivedLogTx += int64(len(block.MsgBlock().Transactions))
+	receivedLogTx += int64(len(block.Transactions))
 
 	now := mstime.Now()
 	duration := now.Sub(lastBlockLogTime)
 	if duration < time.Second*10 {
-		return nil
+		return
 	}
 
 	// Truncate the duration to 10s of milliseconds.
@@ -48,17 +48,11 @@ func LogBlock(block *util.Block) error {
 		txStr = "transaction"
 	}
 
-	blueScore, err := block.BlueScore()
-	if err != nil {
-		return err
-	}
-
-	log.Infof("Processed %d %s in the last %s (%d %s, blue score %d, %s)",
+	log.Infof("Processed %d %s in the last %s (%d %s, %s)",
 		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
-		txStr, blueScore, block.MsgBlock().Header.Timestamp)
+		txStr, mstime.UnixMilliseconds(block.Header.TimeInMilliseconds()))
 
 	receivedLogBlocks = 0
 	receivedLogTx = 0
 	lastBlockLogTime = now
-	return nil
 }

app/protocol/flowcontext/blocks.go

@@ -1,49 +1,82 @@
 package flowcontext
 
 import (
-	"sync/atomic"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/pkg/errors"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // OnNewBlock updates the mempool after a new block arrival, and
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *util.Block) error {
-	transactionsAcceptedToMempool, err := f.txPool.HandleNewBlock(block)
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
+	blockInsertionResult *externalapi.BlockInsertionResult) error {
+
+	hash := consensushashing.BlockHash(block)
+	log.Debugf("OnNewBlock start for block %s", hash)
+	defer log.Debugf("OnNewBlock end for block %s", hash)
+
+	unorphaningResults, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
-	if f.onBlockAddedToDAGHandler != nil {
-		err := f.onBlockAddedToDAGHandler(block)
+
+	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
+
+	newBlocks := []*externalapi.DomainBlock{block}
+	newBlockInsertionResults := []*externalapi.BlockInsertionResult{blockInsertionResult}
+	for _, unorphaningResult := range unorphaningResults {
+		newBlocks = append(newBlocks, unorphaningResult.block)
+		newBlockInsertionResults = append(newBlockInsertionResults, unorphaningResult.blockInsertionResult)
+	}
+
+	for i, newBlock := range newBlocks {
+		blocklogger.LogBlock(block)
+
+		log.Debugf("OnNewBlock: passing block %s transactions to mining manager", hash)
+		_, err = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
 		if err != nil {
 			return err
 		}
+
+		if f.onBlockAddedToDAGHandler != nil {
+			log.Debugf("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
+			blockInsertionResult = newBlockInsertionResults[i]
+			err := f.onBlockAddedToDAGHandler(newBlock, blockInsertionResult)
+			if err != nil {
+				return err
+			}
+		}
 	}
 
-	return f.broadcastTransactionsAfterBlockAdded(block, transactionsAcceptedToMempool)
+	return nil
 }
 
-func (f *FlowContext) broadcastTransactionsAfterBlockAdded(block *util.Block, transactionsAcceptedToMempool []*util.Tx) error {
+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 {
+	if f.IsIBDRunning() {
 		return nil
 	}
 
-	var txIDsToRebroadcast []*daghash.TxID
+	var txIDsToRebroadcast []*externalapi.DomainTransactionID
 	if f.shouldRebroadcastTransactions() {
 		txIDsToRebroadcast = f.txIDsToRebroadcast()
 	}
 
-	txIDsToBroadcast := make([]*daghash.TxID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
+	txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
 	for i, tx := range transactionsAcceptedToMempool {
-		txIDsToBroadcast[i] = tx.ID()
+		txIDsToBroadcast[i] = consensushashing.TransactionID(tx)
 	}
 	offset := len(transactionsAcceptedToMempool)
 	for i, txID := range txIDsToRebroadcast {
@@ -67,14 +100,62 @@ func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks
 }
 
 // AddBlock adds the given block to the DAG and propagates it.
-func (f *FlowContext) AddBlock(block *util.Block, flags blockdag.BehaviorFlags) error {
-	_, _, err := f.DAG().ProcessBlock(block, flags)
+func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
+	blockInsertionResult, err := f.Domain().Consensus().ValidateAndInsertBlock(block)
+	if err != nil {
+		if errors.As(err, &ruleerrors.RuleError{}) {
+			log.Warnf("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
+		}
+		return err
+	}
+	err = f.OnNewBlock(block, blockInsertionResult)
 	if err != nil {
 		return err
 	}
-	err = f.OnNewBlock(block)
-	if err != nil {
-		return err
-	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(block.Hash()))
+	return f.Broadcast(appmessage.NewMsgInvBlock(consensushashing.BlockHash(block)))
+}
+
+// IsIBDRunning returns true if IBD is currently marked as running
+func (f *FlowContext) IsIBDRunning() bool {
+	f.ibdPeerMutex.RLock()
+	defer f.ibdPeerMutex.RUnlock()
+
+	return f.ibdPeer != nil
+}
+
+// TrySetIBDRunning attempts to set `isInIBD`. Returns false
+// if it is already set
+func (f *FlowContext) TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool {
+	f.ibdPeerMutex.Lock()
+	defer f.ibdPeerMutex.Unlock()
+
+	if f.ibdPeer != nil {
+		return false
+	}
+	f.ibdPeer = ibdPeer
+	log.Infof("IBD started")
+
+	return true
+}
+
+// UnsetIBDRunning unsets isInIBD
+func (f *FlowContext) UnsetIBDRunning() {
+	f.ibdPeerMutex.Lock()
+	defer f.ibdPeerMutex.Unlock()
+
+	if f.ibdPeer == nil {
+		panic("attempted to unset isInIBD when it was not set to begin with")
+	}
+
+	f.ibdPeer = nil
+	log.Infof("IBD finished")
+}
+
+// IBDPeer returns the current IBD peer or null if the node is not
+// in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	f.ibdPeerMutex.RLock()
+	defer f.ibdPeerMutex.RUnlock()
+
+	return f.ibdPeer
 }

app/protocol/flowcontext/consensus.go

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

app/protocol/flowcontext/domain.go

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

app/protocol/flowcontext/flow_context.go

@@ -1,26 +1,27 @@
 package flowcontext
 
 import (
+	"github.com/kaspanet/kaspad/util/mstime"
 	"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"
+	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/mempool"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // OnBlockAddedToDAGHandler is a handler function that's triggered
 // when a block is added to the DAG
-type OnBlockAddedToDAGHandler func(block *util.Block) error
+type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
 
 // OnTransactionAddedToMempoolHandler is a handler function that's triggered
 // when a transaction is added to the mempool
@@ -31,45 +32,48 @@ type OnTransactionAddedToMempoolHandler func()
 type FlowContext struct {
 	cfg               *config.Config
 	netAdapter        *netadapter.NetAdapter
-	txPool            *mempool.TxPool
-	dag               *blockdag.BlockDAG
+	domain            domain.Domain
 	addressManager    *addressmanager.AddressManager
 	connectionManager *connmanager.ConnectionManager
 
+	timeStarted int64
+
 	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
 	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
 
 	transactionsToRebroadcastLock sync.Mutex
-	transactionsToRebroadcast     map[daghash.TxID]*util.Tx
+	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
 	lastRebroadcastTime           time.Time
-	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
+	sharedRequestedTransactions   *transactionrelay.SharedRequestedTransactions
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	isInIBD       uint32
-	startIBDMutex sync.Mutex
-	ibdPeer       *peerpkg.Peer
+	ibdPeer      *peerpkg.Peer
+	ibdPeerMutex sync.RWMutex
 
 	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, dag *blockdag.BlockDAG, addressManager *addressmanager.AddressManager,
-	txPool *mempool.TxPool, netAdapter *netadapter.NetAdapter,
-	connectionManager *connmanager.ConnectionManager) *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,
-		dag:                         dag,
+		domain:                      domain,
 		addressManager:              addressManager,
 		connectionManager:           connectionManager,
-		txPool:                      txPool,
-		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
+		sharedRequestedTransactions: transactionrelay.NewSharedRequestedTransactions(),
 		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
 		peers:                       make(map[id.ID]*peerpkg.Peer),
-		transactionsToRebroadcast:   make(map[daghash.TxID]*util.Tx),
+		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
+		orphans:                     make(map[externalapi.DomainHash]*externalapi.DomainBlock),
+		timeStarted:                 mstime.Now().UnixMilliseconds(),
 	}
 }
 

app/protocol/flowcontext/ibd.go

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

app/protocol/flowcontext/orphans.go

@@ -0,0 +1,162 @@
+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/consensushashing"
+	"github.com/pkg/errors"
+)
+
+// maxOrphans is the maximum amount of orphans allowed in the
+// orphans collection. This number is an approximation of how
+// many orphans there can possibly be on average. It is based
+// on: 2^orphanResolutionRange * PHANTOM K.
+const maxOrphans = 600
+
+// UnorphaningResult is the result of unorphaning a block
+type UnorphaningResult struct {
+	block                *externalapi.DomainBlock
+	blockInsertionResult *externalapi.BlockInsertionResult
+}
+
+// AddOrphan adds the block to the orphan set
+func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
+	f.orphansMutex.Lock()
+	defer f.orphansMutex.Unlock()
+
+	orphanHash := consensushashing.BlockHash(orphanBlock)
+	f.orphans[*orphanHash] = orphanBlock
+
+	if len(f.orphans) > maxOrphans {
+		log.Debugf("Orphan collection size exceeded. Evicting a random orphan")
+		f.evictRandomOrphan()
+	}
+
+	log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
+}
+
+func (f *FlowContext) evictRandomOrphan() {
+	var toEvict externalapi.DomainHash
+	for hash := range f.orphans {
+		toEvict = hash
+		break
+	}
+	delete(f.orphans, toEvict)
+	log.Debugf("Evicted %s from the orphan collection", toEvict)
+}
+
+// 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) ([]*UnorphaningResult, 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 := consensushashing.BlockHash(rootBlock)
+	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
+
+	var unorphaningResults []*UnorphaningResult
+	for len(processQueue) > 0 {
+		var orphanHash externalapi.DomainHash
+		orphanHash, processQueue = processQueue[0], processQueue[1:]
+		orphanBlock := f.orphans[orphanHash]
+
+		log.Debugf("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 || orphanBlockParentInfo.BlockStatus == externalapi.StatusHeaderOnly {
+				log.Debugf("Cannot unorphan block %s. It's missing at "+
+					"least the following parent: %s", orphanHash, orphanBlockParentHash)
+
+				canBeUnorphaned = false
+				break
+			}
+		}
+		if canBeUnorphaned {
+			blockInsertionResult, unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
+			if err != nil {
+				return nil, err
+			}
+			if unorphaningSucceeded {
+				unorphaningResults = append(unorphaningResults, &UnorphaningResult{
+					block:                orphanBlock,
+					blockInsertionResult: blockInsertionResult,
+				})
+				processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
+			}
+		}
+	}
+
+	return unorphaningResults, 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.Equal(blockHash) {
+				childOrphans = append(childOrphans, orphanHash)
+				break
+			}
+		}
+	}
+	return childOrphans
+}
+
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externalapi.BlockInsertionResult, bool, error) {
+	orphanBlock, ok := f.orphans[orphanHash]
+	if !ok {
+		return nil, false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+	}
+	delete(f.orphans, orphanHash)
+
+	blockInsertionResult, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
+	if err != nil {
+		if errors.As(err, &ruleerrors.RuleError{}) {
+			log.Warnf("Validation failed for orphan block %s: %s", orphanHash, err)
+			return nil, false, nil
+		}
+		return nil, false, err
+	}
+
+	log.Infof("Unorphaned block %s", orphanHash)
+	return blockInsertionResult, true, nil
+}

app/protocol/flowcontext/should_mine.go

@@ -0,0 +1,43 @@
+package flowcontext
+
+import "github.com/kaspanet/kaspad/util/mstime"
+
+const (
+	maxSelectedParentTimeDiffToAllowMiningInMilliSeconds = 300_000
+)
+
+// ShouldMine returns whether it's ok to use block template from this node
+// for mining purposes.
+func (f *FlowContext) ShouldMine() (bool, error) {
+	peers := f.Peers()
+	if len(peers) == 0 {
+		log.Debugf("The node is not connected, so ShouldMine returns false")
+		return false, nil
+	}
+
+	if f.IsIBDRunning() {
+		log.Debugf("IBD is running, so ShouldMine returns false")
+		return false, nil
+	}
+
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+
+	virtualSelectedParentHeader, err := f.domain.Consensus().GetBlockHeader(virtualSelectedParent)
+	if err != nil {
+		return false, err
+	}
+
+	now := mstime.Now().UnixMilliseconds()
+	if now-virtualSelectedParentHeader.TimeInMilliseconds() < maxSelectedParentTimeDiffToAllowMiningInMilliSeconds {
+		log.Debugf("The selected tip timestamp is recent (%d), so ShouldMine returns true",
+			virtualSelectedParentHeader.TimeInMilliseconds())
+		return true, nil
+	}
+
+	log.Debugf("The selected tip timestamp is old (%d), so ShouldMine returns false",
+		virtualSelectedParentHeader.TimeInMilliseconds())
+	return false, nil
+}

app/protocol/flowcontext/transactions.go

@@ -1,42 +1,38 @@
 package flowcontext
 
 import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
-	"github.com/kaspanet/kaspad/domain/mempool"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/pkg/errors"
 	"time"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 )
 
 // AddTransaction adds transaction to the mempool and propagates it.
-func (f *FlowContext) AddTransaction(tx *util.Tx) error {
+func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
 	f.transactionsToRebroadcastLock.Lock()
 	defer f.transactionsToRebroadcastLock.Unlock()
 
-	transactionsAcceptedToMempool, err := f.txPool.ProcessTransaction(tx, false)
+	err := f.Domain().MiningManager().ValidateAndInsertTransaction(tx, false)
 	if err != nil {
 		return err
 	}
 
-	if len(transactionsAcceptedToMempool) > 1 {
-		return errors.New("got more than one accepted transactions when no orphans were allowed")
-	}
-
-	f.transactionsToRebroadcast[*tx.ID()] = tx
-	inv := appmessage.NewMsgInvTransaction([]*daghash.TxID{tx.ID()})
+	transactionID := consensushashing.TransactionID(tx)
+	f.transactionsToRebroadcast[*transactionID] = tx
+	inv := appmessage.NewMsgInvTransaction([]*externalapi.DomainTransactionID{transactionID})
 	return f.Broadcast(inv)
 }
 
-func (f *FlowContext) updateTransactionsToRebroadcast(block *util.Block) {
+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, *tx.ID())
+	for _, tx := range block.Transactions {
+		delete(f.transactionsToRebroadcast, *consensushashing.TransactionID(tx))
 	}
 }
 
@@ -45,30 +41,25 @@ func (f *FlowContext) shouldRebroadcastTransactions() bool {
 	return time.Since(f.lastRebroadcastTime) > rebroadcastInterval
 }
 
-func (f *FlowContext) txIDsToRebroadcast() []*daghash.TxID {
+func (f *FlowContext) txIDsToRebroadcast() []*externalapi.DomainTransactionID {
 	f.transactionsToRebroadcastLock.Lock()
 	defer f.transactionsToRebroadcastLock.Unlock()
 
-	txIDs := make([]*daghash.TxID, len(f.transactionsToRebroadcast))
+	txIDs := make([]*externalapi.DomainTransactionID, len(f.transactionsToRebroadcast))
 	i := 0
 	for _, tx := range f.transactionsToRebroadcast {
-		txIDs[i] = tx.ID()
+		txIDs[i] = consensushashing.TransactionID(tx)
 		i++
 	}
 	return txIDs
 }
 
-// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
+// SharedRequestedTransactions returns a *transactionrelay.SharedRequestedTransactions for sharing
 // data about requested transactions between different peers.
-func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
+func (f *FlowContext) SharedRequestedTransactions() *transactionrelay.SharedRequestedTransactions {
 	return f.sharedRequestedTransactions
 }
 
-// TxPool returns the transaction pool associated to the manager.
-func (f *FlowContext) TxPool() *mempool.TxPool {
-	return f.txPool
-}
-
 // OnTransactionAddedToMempool notifies the handler function that a transaction
 // has been added to the mempool
 func (f *FlowContext) OnTransactionAddedToMempool() {

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -20,10 +20,6 @@ type ReceiveAddressesContext interface {
 func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
 	peer *peerpkg.Peer) error {
 
-	if !context.AddressManager().NeedMoreAddresses() {
-		return nil
-	}
-
 	subnetworkID := peer.SubnetworkID()
 	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
 	err := outgoingRoute.Enqueue(msgGetAddresses)
@@ -37,21 +33,10 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 	}
 
 	msgAddresses := message.(*appmessage.MsgAddresses)
-	if len(msgAddresses.AddrList) > addressmanager.GetAddressesMax {
+	if len(msgAddresses.AddressList) > addressmanager.GetAddressesMax {
 		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
 	}
 
-	if msgAddresses.IncludeAllSubnetworks {
-		return protocolerrors.Errorf(true, "got unexpected "+
-			"IncludeAllSubnetworks=true in [%s] command", msgAddresses.Command())
-	}
-	if !msgAddresses.SubnetworkID.IsEqual(context.Config().SubnetworkID) && msgAddresses.SubnetworkID != nil {
-		return protocolerrors.Errorf(false, "only full nodes and %s subnetwork IDs "+
-			"are allowed in [%s] command, but got subnetwork ID %s",
-			context.Config().SubnetworkID, msgAddresses.Command(), msgAddresses.SubnetworkID)
-	}
-
-	sourceAddress := peer.Connection().NetAddress()
-	context.AddressManager().AddAddresses(msgAddresses.AddrList, sourceAddress, msgAddresses.SubnetworkID)
+	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
 	return nil
 }

app/protocol/flows/addressexchange/sendaddresses.go

@@ -1,10 +1,12 @@
 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"
-	"math/rand"
 )
 
 // SendAddressesContext is the interface for the context needed for the SendAddresses flow.
@@ -14,21 +16,25 @@ type SendAddressesContext interface {
 
 // SendAddresses sends addresses to a peer that requests it.
 func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	message, err := incomingRoute.Dequeue()
-	if err != nil {
-		return err
-	}
+	for {
+		message, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
 
-	msgGetAddresses := message.(*appmessage.MsgRequestAddresses)
-	addresses := context.AddressManager().AddressCache(msgGetAddresses.IncludeAllSubnetworks,
-		msgGetAddresses.SubnetworkID)
-	msgAddresses := appmessage.NewMsgAddresses(msgGetAddresses.IncludeAllSubnetworks, msgGetAddresses.SubnetworkID)
-	err = msgAddresses.AddAddresses(shuffleAddresses(addresses)...)
-	if err != nil {
-		return err
-	}
+		_, 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))
 
-	return outgoingRoute.Enqueue(msgAddresses)
+		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.

app/protocol/flows/blockrelay/block_locator.go

@@ -0,0 +1,29 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+func (flow *handleRelayInvsFlow) sendGetBlockLocator(lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash, limit uint32) error {
+
+	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(lowHash, highHash, limit)
+	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
+}
+
+func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
+	if !ok {
+		return nil,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
+	}
+	return msgBlockLocator.BlockLocatorHashes, nil
+}

app/protocol/flows/blockrelay/handle_ibd_block_locator.go

@@ -0,0 +1,77 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"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"
+)
+
+// HandleIBDBlockLocatorContext is the interface for the context needed for the HandleIBDBlockLocator flow.
+type HandleIBDBlockLocatorContext interface {
+	Domain() domain.Domain
+}
+
+// HandleIBDBlockLocator listens to appmessage.MsgIBDBlockLocator messages and sends
+// the highest known block that's in the selected parent chain of `targetHash` to the
+// requesting peer.
+func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peer.Peer) error {
+
+	for {
+		message, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		ibdBlockLocatorMessage := message.(*appmessage.MsgIBDBlockLocator)
+
+		targetHash := ibdBlockLocatorMessage.TargetHash
+		log.Debugf("Received IBDBlockLocator from %s with targetHash %s", peer, targetHash)
+
+		blockInfo, err := context.Domain().Consensus().GetBlockInfo(targetHash)
+		if err != nil {
+			return err
+		}
+		if !blockInfo.Exists {
+			return protocolerrors.Errorf(true, "received IBDBlockLocator "+
+				"with an unknown targetHash %s", targetHash)
+		}
+
+		foundHighestHashInTheSelectedParentChainOfTargetHash := false
+		for _, blockLocatorHash := range ibdBlockLocatorMessage.BlockLocatorHashes {
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(blockLocatorHash)
+			if err != nil {
+				return err
+			}
+			if !blockInfo.Exists {
+				continue
+			}
+
+			isBlockLocatorHashInSelectedParentChainOfHighHash, err :=
+				context.Domain().Consensus().IsInSelectedParentChainOf(blockLocatorHash, targetHash)
+			if err != nil {
+				return err
+			}
+			if !isBlockLocatorHashInSelectedParentChainOfHighHash {
+				continue
+			}
+
+			foundHighestHashInTheSelectedParentChainOfTargetHash = true
+			log.Debugf("Found a known hash %s amongst peer %s's "+
+				"blockLocator that's in the selected parent chain of targetHash %s", blockLocatorHash, peer, targetHash)
+
+			ibdBlockLocatorHighestHashMessage := appmessage.NewMsgIBDBlockLocatorHighestHash(blockLocatorHash)
+			err = outgoingRoute.Enqueue(ibdBlockLocatorHighestHashMessage)
+			if err != nil {
+				return err
+			}
+			break
+		}
+
+		if !foundHighestHashInTheSelectedParentChainOfTargetHash {
+			return protocolerrors.Errorf(true, "no hash was found in the blockLocator "+
+				"that was in the selected parent chain of targetHash %s", targetHash)
+		}
+	}
+}

app/protocol/flows/blockrelay/handle_ibd_block_requests.go

@@ -0,0 +1,54 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// HandleIBDBlockRequestsContext is the interface for the context needed for the HandleIBDBlockRequests flow.
+type HandleIBDBlockRequestsContext interface {
+	Domain() domain.Domain
+}
+
+// HandleIBDBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
+// their corresponding blocks to the requesting peer.
+func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route) error {
+
+	for {
+		message, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
+		log.Debugf("Got request for %d ibd blocks", len(msgRequestIBDBlocks.Hashes))
+		for i, hash := range msgRequestIBDBlocks.Hashes {
+			// Fetch the block from the database.
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			if err != nil {
+				return err
+			}
+			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+				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
+
+			blockMessage := appmessage.DomainBlockToMsgBlock(block)
+			ibdBlockMessage := appmessage.NewMsgIBDBlock(blockMessage)
+			err = outgoingRoute.Enqueue(ibdBlockMessage)
+			if err != nil {
+				return err
+			}
+			log.Debugf("sent %d out of %d", i, len(msgRequestIBDBlocks.Hashes))
+		}
+	}
+}

app/protocol/flows/blockrelay/handle_ibd_root_hash_requests.go

@@ -0,0 +1,51 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleIBDRootHashRequestsFlowContext is the interface for the context needed for the handleIBDRootHashRequestsFlow flow.
+type HandleIBDRootHashRequestsFlowContext interface {
+	Domain() domain.Domain
+}
+
+type handleIBDRootHashRequestsFlow struct {
+	HandleIBDRootHashRequestsFlowContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleIBDRootHashRequests listens to appmessage.MsgRequestIBDRootHashMessage messages and sends
+// the IBD root hash as response.
+func HandleIBDRootHashRequests(context HandleIBDRootHashRequestsFlowContext, incomingRoute,
+	outgoingRoute *router.Route) error {
+	flow := &handleIBDRootHashRequestsFlow{
+		HandleIBDRootHashRequestsFlowContext: context,
+		incomingRoute:                        incomingRoute,
+		outgoingRoute:                        outgoingRoute,
+	}
+
+	return flow.start()
+}
+
+func (flow *handleIBDRootHashRequestsFlow) start() error {
+	for {
+		_, err := flow.incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		log.Debugf("Got request for IBD root hash")
+
+		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
+		if err != nil {
+			return err
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootHashMessage(pruningPoint))
+		if err != nil {
+			return err
+		}
+		log.Debugf("Sent IBD root hash %s", pruningPoint)
+	}
+}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -4,14 +4,15 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
 
 // RelayBlockRequestsContext is the interface for the context needed for the HandleRelayBlockRequests flow.
 type RelayBlockRequestsContext interface {
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 }
 
 // HandleRelayBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
@@ -25,31 +26,28 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 			return err
 		}
 		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
+		log.Debugf("Got request for relay blocks with hashes %s", getRelayBlocksMessage.Hashes)
 		for _, hash := range getRelayBlocksMessage.Hashes {
 			// Fetch the block from the database.
-			block, err := context.DAG().BlockByHash(hash)
-			if blockdag.IsNotInDAGErr(err) {
-				return protocolerrors.Errorf(true, "block %s not found", hash)
-			} else if err != nil {
-				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
-			}
-			msgBlock := block.MsgBlock()
-
-			// If we are a full node and the peer is a partial node, we must convert
-			// the block to a partial block.
-			nodeSubnetworkID := context.DAG().SubnetworkID()
-			peerSubnetworkID := peer.SubnetworkID()
-
-			isNodeFull := nodeSubnetworkID == nil
-			isPeerFull := peerSubnetworkID == nil
-			if isNodeFull && !isPeerFull {
-				msgBlock.ConvertToPartial(peerSubnetworkID)
-			}
-
-			err = outgoingRoute.Enqueue(msgBlock)
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
 			if err != nil {
 				return err
 			}
+			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+				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
+			}
+			log.Debugf("Relayed block with hash %s", hash)
 		}
 	}
 }

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -2,28 +2,37 @@ package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	mathUtil "github.com/kaspanet/kaspad/util/math"
 	"github.com/pkg/errors"
 )
 
+// orphanResolutionRange is the maximum amount of blockLocator hashes
+// to search for known blocks. See isBlockInOrphanResolutionRange for
+// further details
+var orphanResolutionRange uint32 = 5
+
 // RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
 type RelayInvsContext interface {
+	Domain() domain.Domain
+	Config() *config.Config
 	NetAdapter() *netadapter.NetAdapter
-	DAG() *blockdag.BlockDAG
-	OnNewBlock(block *util.Block) error
+	OnNewBlock(block *externalapi.DomainBlock, blockInsertionResult *externalapi.BlockInsertionResult) error
 	SharedRequestedBlocks() *SharedRequestedBlocks
-	StartIBDIfRequired()
-	IsInIBD() bool
 	Broadcast(message appmessage.Message) error
+	AddOrphan(orphanBlock *externalapi.DomainBlock)
+	IsOrphan(blockHash *externalapi.DomainHash) bool
+	IsIBDRunning() bool
+	TrySetIBDRunning(ibdPeer *peerpkg.Peer) bool
+	UnsetIBDRunning()
 }
 
 type handleRelayInvsFlow struct {
@@ -50,6 +59,7 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 
 func (flow *handleRelayInvsFlow) start() error {
 	for {
+		log.Debugf("Waiting for inv")
 		inv, err := flow.readInv()
 		if err != nil {
 			return err
@@ -57,34 +67,68 @@ func (flow *handleRelayInvsFlow) start() error {
 
 		log.Debugf("Got relay inv for block %s", inv.Hash)
 
-		if flow.DAG().IsKnownBlock(inv.Hash) {
-			if flow.DAG().IsKnownInvalid(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)
 			}
+			log.Debugf("Block %s already exists. continuing...", inv.Hash)
 			continue
 		}
 
-		flow.StartIBDIfRequired()
-		if flow.IsInIBD() {
-			// Block relay is disabled during IBD
+		if flow.IsOrphan(inv.Hash) {
+			log.Debugf("Block %s is a known orphan. continuing...", inv.Hash)
 			continue
 		}
 
-		requestQueue := newHashesQueueSet()
-		requestQueue.enqueueIfNotExists(inv.Hash)
+		// Block relay is disabled during IBD
+		if flow.IsIBDRunning() {
+			log.Debugf("Got block %s while in IBD. continuing...", inv.Hash)
+			continue
+		}
 
-		for requestQueue.len() > 0 {
-			err := flow.requestBlocks(requestQueue)
+		log.Debugf("Requesting block %s", inv.Hash)
+		block, exists, err := flow.requestBlock(inv.Hash)
+		if err != nil {
+			return err
+		}
+		if exists {
+			log.Debugf("Aborting requesting block %s because it already exists", inv.Hash)
+			continue
+		}
+
+		log.Debugf("Processing block %s", inv.Hash)
+		missingParents, blockInsertionResult, err := flow.processBlock(block)
+		if err != nil {
+			return err
+		}
+		if len(missingParents) > 0 {
+			log.Debugf("Block %s contains orphans: %s", inv.Hash, missingParents)
+			err := flow.processOrphan(block, missingParents)
 			if err != nil {
 				return err
 			}
+			continue
+		}
+
+		log.Debugf("Relaying block %s", inv.Hash)
+		err = flow.relayBlock(block)
+		if err != nil {
+			return err
+		}
+		log.Infof("Accepted block %s via relay", inv.Hash)
+		err = flow.OnNewBlock(block, blockInsertionResult)
+		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:]
@@ -104,72 +148,40 @@ func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error)
 	return inv, nil
 }
 
-func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
-	numHashesToRequest := mathUtil.MinInt(appmessage.MsgRequestRelayBlocksHashes, requestQueue.len())
-	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
-
-	pendingBlocks := map[daghash.Hash]struct{}{}
-	var filteredHashesToRequest []*daghash.Hash
-	for _, hash := range hashesToRequest {
-		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
-		if exists {
-			continue
-		}
-
-		// The block can become known from another peer in the process of orphan resolution
-		if flow.DAG().IsKnownBlock(hash) {
-			continue
-		}
-
-		pendingBlocks[*hash] = struct{}{}
-		filteredHashesToRequest = append(filteredHashesToRequest, hash)
+func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
+	exists := flow.SharedRequestedBlocks().addIfNotExists(requestHash)
+	if exists {
+		return nil, true, nil
 	}
 
-	// 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
+	// In case the function returns earlier than expected, we want to make sure flow.SharedRequestedBlocks() is
 	// clean from any pending blocks.
-	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+	defer flow.SharedRequestedBlocks().remove(requestHash)
 
-	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks([]*externalapi.DomainHash{requestHash})
 	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
 	if err != nil {
-		return err
+		return nil, false, err
 	}
 
-	for len(pendingBlocks) > 0 {
-		msgBlock, err := flow.readMsgBlock()
-		if err != nil {
-			return err
-		}
-
-		block := util.NewBlock(msgBlock)
-		blockHash := block.Hash()
-
-		if _, ok := pendingBlocks[*blockHash]; !ok {
-			return protocolerrors.Errorf(true, "got unrequested block %s", block.Hash())
-		}
-
-		err = flow.processAndRelayBlock(requestQueue, block)
-		if err != nil {
-			return err
-		}
-
-		delete(pendingBlocks, *blockHash)
-		flow.SharedRequestedBlocks().remove(blockHash)
+	msgBlock, err := flow.readMsgBlock()
+	if err != nil {
+		return nil, false, err
 	}
-	return nil
+
+	block := appmessage.MsgBlockToDomainBlock(msgBlock)
+	blockHash := consensushashing.BlockHash(block)
+	if !blockHash.Equal(requestHash) {
+		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
+	}
+
+	return block, false, 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) {
-
+func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock, err error) {
 	for {
 		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 		if err != nil {
@@ -187,59 +199,91 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (
 	}
 }
 
-func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *util.Block) error {
-	blockHash := block.Hash()
-	isOrphan, isDelayed, err := flow.DAG().ProcessBlock(block, blockdag.BFNone)
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.BlockInsertionResult, error) {
+	blockHash := consensushashing.BlockHash(block)
+	blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
-		if !errors.As(err, &blockdag.RuleError{}) {
-			return errors.Wrapf(err, "failed to process block %s", blockHash)
-		}
-		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-
-		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
-	}
-
-	if isDelayed {
-		return nil
-	}
-
-	if isOrphan {
-		blueScore, err := block.BlueScore()
-		if err != nil {
-			return protocolerrors.Errorf(true, "received an orphan "+
-				"block %s with malformed blue score", blockHash)
+		if !errors.As(err, &ruleerrors.RuleError{}) {
+			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
-		const maxOrphanBlueScoreDiff = 10000
-		selectedTipBlueScore := flow.DAG().SelectedTipBlueScore()
-		if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
-			log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
-				"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
-				blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
-			return nil
+		missingParentsError := &ruleerrors.ErrMissingParents{}
+		if errors.As(err, missingParentsError) {
+			return missingParentsError.MissingParentHashes, nil, nil
 		}
-
-		// Request the parents for the orphan block from the peer that sent it.
-		missingAncestors := flow.DAG().GetOrphanMissingAncestorHashes(blockHash)
-		for _, missingAncestor := range missingAncestors {
-			requestQueue.enqueueIfNotExists(missingAncestor)
-		}
-		return nil
+		log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+		return nil, nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
-	err = blocklogger.LogBlock(block)
-	if err != nil {
-		return err
-	}
-	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
-	if err != nil {
-		return err
-	}
-
-	flow.StartIBDIfRequired()
-	err = flow.OnNewBlock(block)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return nil, blockInsertionResult, nil
+}
+
+func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
+	blockHash := consensushashing.BlockHash(block)
+	return flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
+}
+
+func (flow *handleRelayInvsFlow) processOrphan(block *externalapi.DomainBlock, missingParents []*externalapi.DomainHash) error {
+	blockHash := consensushashing.BlockHash(block)
+
+	// Return if the block has been orphaned from elsewhere already
+	if flow.IsOrphan(blockHash) {
+		log.Debugf("Skipping orphan processing for block %s because it is already an orphan", blockHash)
+		return nil
+	}
+
+	// Add the block to the orphan set if it's within orphan resolution range
+	isBlockInOrphanResolutionRange, err := flow.isBlockInOrphanResolutionRange(blockHash)
+	if err != nil {
+		return err
+	}
+	if isBlockInOrphanResolutionRange {
+		log.Debugf("Block %s is within orphan resolution range. "+
+			"Adding it to the orphan set and requesting its missing parents", blockHash)
+		flow.addToOrphanSetAndRequestMissingParents(block, missingParents)
+		return nil
+	}
+
+	// Start IBD unless we already are in IBD
+	log.Debugf("Block %s is out of orphan resolution range. "+
+		"Attempting to start IBD against it.", blockHash)
+	return flow.runIBDIfNotRunning(blockHash)
+}
+
+// isBlockInOrphanResolutionRange finds out whether the given blockHash should be
+// retrieved via the unorphaning mechanism or via IBD. This method sends a
+// getBlockLocator request to the peer with a limit of orphanResolutionRange.
+// In the response, if we know none of the hashes, we should retrieve the given
+// blockHash via IBD. Otherwise, via unorphaning.
+func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *externalapi.DomainHash) (bool, error) {
+	lowHash := flow.Config().ActiveNetParams.GenesisHash
+	err := flow.sendGetBlockLocator(lowHash, blockHash, orphanResolutionRange)
+	if err != nil {
+		return false, err
+	}
+
+	blockLocatorHashes, err := flow.receiveBlockLocator()
+	if err != nil {
+		return false, err
+	}
+	for _, blockLocatorHash := range blockLocatorHashes {
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockLocatorHash)
+		if err != nil {
+			return false, err
+		}
+		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func (flow *handleRelayInvsFlow) addToOrphanSetAndRequestMissingParents(
+	block *externalapi.DomainBlock, missingParents []*externalapi.DomainHash) {
+
+	flow.AddOrphan(block)
+	invMessages := make([]*appmessage.MsgInvRelayBlock, len(missingParents))
+	for i, missingParent := range missingParents {
+		invMessages[i] = appmessage.NewMsgInvBlock(missingParent)
+	}
+	flow.invsQueue = append(invMessages, flow.invsQueue...)
 }

app/protocol/flows/blockrelay/handle_request_block_locator.go

@@ -1,16 +1,16 @@
-package ibd
+package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // RequestBlockLocatorContext is the interface for the context needed for the HandleRequestBlockLocator flow.
 type RequestBlockLocatorContext interface {
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 }
 
 type handleRequestBlockLocatorFlow struct {
@@ -32,13 +32,18 @@ func HandleRequestBlockLocator(context RequestBlockLocatorContext, incomingRoute
 
 func (flow *handleRequestBlockLocatorFlow) start() error {
 	for {
-		lowHash, highHash, err := flow.receiveGetBlockLocator()
+		lowHash, highHash, limit, err := flow.receiveGetBlockLocator()
 		if err != nil {
 			return err
 		}
+		log.Debugf("Received getBlockLocator with lowHash: %s, highHash: %s, limit: %d",
+			lowHash, highHash, limit)
 
-		locator, err := flow.DAG().BlockLocatorFromHashes(highHash, lowHash)
+		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash, limit)
 		if err != nil || len(locator) == 0 {
+			if err != nil {
+				log.Debugf("Received error from CreateBlockLocator: %s", err)
+			}
 			return protocolerrors.Errorf(true, "couldn't build a block "+
 				"locator between blocks %s and %s", lowHash, highHash)
 		}
@@ -50,19 +55,19 @@ func (flow *handleRequestBlockLocatorFlow) start() error {
 	}
 }
 
-func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *daghash.Hash,
-	highHash *daghash.Hash, err error) {
+func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash, limit uint32, err error) {
 
 	message, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 	msgGetBlockLocator := message.(*appmessage.MsgRequestBlockLocator)
 
-	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, nil
+	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, msgGetBlockLocator.Limit, nil
 }
 
-func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator blockdag.BlockLocator) error {
+func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator externalapi.BlockLocator) error {
 	msgBlockLocator := appmessage.NewMsgBlockLocator(locator)
 	err := flow.outgoingRoute.Enqueue(msgBlockLocator)
 	if err != nil {

app/protocol/flows/blockrelay/handle_request_headers.go

@@ -0,0 +1,104 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+const ibdBatchSize = router.DefaultMaxMessages
+
+// RequestIBDBlocksContext is the interface for the context needed for the HandleRequestHeaders flow.
+type RequestIBDBlocksContext interface {
+	Domain() domain.Domain
+}
+
+type handleRequestBlocksFlow struct {
+	RequestIBDBlocksContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peer.Peer
+}
+
+// HandleRequestHeaders handles RequestHeaders messages
+func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peer.Peer) error {
+
+	flow := &handleRequestBlocksFlow{
+		RequestIBDBlocksContext: context,
+		incomingRoute:           incomingRoute,
+		outgoingRoute:           outgoingRoute,
+		peer:                    peer,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestBlocksFlow) start() error {
+	for {
+		lowHash, highHash, err := receiveRequestHeaders(flow.incomingRoute)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Recieved requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
+
+		for !lowHash.Equal(highHash) {
+			log.Debugf("Getting block headers between %s and %s to %s", lowHash, highHash, flow.peer)
+
+			// GetHashesBetween is a relatively heavy operation so we limit it
+			// in order to avoid locking the consensus for too long
+			const maxBlueScoreDifference = 1 << 10
+			blockHashes, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash, maxBlueScoreDifference)
+			if err != nil {
+				return err
+			}
+			log.Debugf("Got %d header hashes above lowHash %s", len(blockHashes), lowHash)
+
+			blockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
+			for i, blockHash := range blockHashes {
+				blockHeader, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
+				if err != nil {
+					return err
+				}
+				blockHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(blockHeader)
+			}
+
+			blockHeadersMessage := appmessage.NewBlockHeadersMessage(blockHeaders)
+			err = flow.outgoingRoute.Enqueue(blockHeadersMessage)
+			if err != nil {
+				return err
+			}
+
+			message, err := flow.incomingRoute.Dequeue()
+			if err != nil {
+				return err
+			}
+			if _, ok := message.(*appmessage.MsgRequestNextHeaders); !ok {
+				return protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s, got: %s", appmessage.CmdRequestNextHeaders, message.Command())
+			}
+
+			// The next lowHash is the last element in blockHashes
+			lowHash = blockHashes[len(blockHashes)-1]
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneHeaders())
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func receiveRequestHeaders(incomingRoute *router.Route) (lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash, err error) {
+
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return nil, nil, err
+	}
+	msgRequestIBDBlocks := message.(*appmessage.MsgRequestHeaders)
+
+	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
+}

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

@@ -0,0 +1,117 @@
+package blockrelay
+
+import (
+	"errors"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleRequestIBDRootUTXOSetAndBlockContext is the interface for the context needed for the HandleRequestIBDRootUTXOSetAndBlock flow.
+type HandleRequestIBDRootUTXOSetAndBlockContext interface {
+	Domain() domain.Domain
+}
+
+type handleRequestIBDRootUTXOSetAndBlockFlow struct {
+	HandleRequestIBDRootUTXOSetAndBlockContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestIBDRootUTXOSetAndBlock listens to appmessage.MsgRequestIBDRootUTXOSetAndBlock messages and sends
+// the IBD root UTXO set and block body.
+func HandleRequestIBDRootUTXOSetAndBlock(context HandleRequestIBDRootUTXOSetAndBlockContext, incomingRoute,
+	outgoingRoute *router.Route) error {
+	flow := &handleRequestIBDRootUTXOSetAndBlockFlow{
+		HandleRequestIBDRootUTXOSetAndBlockContext: context,
+		incomingRoute: incomingRoute,
+		outgoingRoute: outgoingRoute,
+	}
+
+	return flow.start()
+}
+
+func (flow *handleRequestIBDRootUTXOSetAndBlockFlow) start() error {
+	for {
+		message, err := flow.incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		msgRequestIBDRootUTXOSetAndBlock, ok := message.(*appmessage.MsgRequestIBDRootUTXOSetAndBlock)
+		if !ok {
+			return protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdRequestIBDRootUTXOSetAndBlock, message.Command())
+		}
+
+		finishMeasuring := logger.LogAndMeasureExecutionTime(log, "handleRequestIBDRootUTXOSetAndBlockFlow")
+		log.Debugf("Got request for IBDRoot UTXOSet and Block")
+
+		serializedUTXOSet, err := flow.Domain().Consensus().GetPruningPointUTXOSet(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+		if err != nil {
+			if errors.Is(err, ruleerrors.ErrWrongPruningPointHash) {
+				err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootNotFound())
+				if err != nil {
+					return err
+				}
+
+				continue
+			}
+		}
+		log.Debugf("Retrieved utxo set for pruning block %s", msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+
+		block, err := flow.Domain().Consensus().GetBlock(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Retrieved pruning block %s", msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDBlock(appmessage.DomainBlockToMsgBlock(block)))
+		if err != nil {
+			return err
+		}
+
+		// Send the UTXO set in `step`-sized chunks
+		const step = 1024 * 1024 // 1MB
+		offset := 0
+		chunksSent := 0
+		for offset < len(serializedUTXOSet) {
+			var chunk []byte
+			if offset+step < len(serializedUTXOSet) {
+				chunk = serializedUTXOSet[offset : offset+step]
+			} else {
+				chunk = serializedUTXOSet[offset:]
+			}
+
+			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootUTXOSetChunk(chunk))
+			if err != nil {
+				return err
+			}
+
+			offset += step
+			chunksSent++
+
+			// Wait for the peer to request more chunks every `ibdBatchSize` chunks
+			if chunksSent%ibdBatchSize == 0 {
+				message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+				if err != nil {
+					return err
+				}
+				_, ok := message.(*appmessage.MsgRequestNextIBDRootUTXOSetChunk)
+				if !ok {
+					return protocolerrors.Errorf(true, "received unexpected message type. "+
+						"expected: %s, got: %s", appmessage.CmdRequestNextIBDRootUTXOSetChunk, message.Command())
+				}
+			}
+		}
+
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneIBDRootUTXOSetChunks())
+		if err != nil {
+			return err
+		}
+
+		finishMeasuring()
+	}
+}

app/protocol/flows/blockrelay/hashes_queue_set.go

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

app/protocol/flows/blockrelay/ibd.go

@@ -0,0 +1,496 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"time"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/pkg/errors"
+)
+
+func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.DomainHash) error {
+	wasIBDNotRunning := flow.TrySetIBDRunning(flow.peer)
+	if !wasIBDNotRunning {
+		log.Debugf("IBD is already running")
+		return nil
+	}
+	defer flow.UnsetIBDRunning()
+
+	log.Debugf("IBD started with peer %s and highHash %s", flow.peer, highHash)
+
+	log.Debugf("Syncing headers up to %s", highHash)
+	err := flow.syncHeaders(highHash)
+	if err != nil {
+		return err
+	}
+	log.Debugf("Finished syncing headers up to %s", highHash)
+
+	log.Debugf("Syncing the current pruning point UTXO set")
+	syncedPruningPointUTXOSetSuccessfully, err := flow.syncPruningPointUTXOSet()
+	if err != nil {
+		return err
+	}
+	if !syncedPruningPointUTXOSetSuccessfully {
+		log.Debugf("Aborting IBD because the pruning point UTXO set failed to sync")
+		return nil
+	}
+	log.Debugf("Finished syncing the current pruning point UTXO set")
+
+	log.Debugf("Downloading block bodies up to %s", highHash)
+	err = flow.syncMissingBlockBodies(highHash)
+	if err != nil {
+		return err
+	}
+	log.Debugf("Finished downloading block bodies up to %s", highHash)
+
+	return nil
+}
+
+func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) error {
+	highHashReceived := false
+	for !highHashReceived {
+		log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
+		highestSharedBlockHash, err := flow.findHighestSharedBlockHash(highHash)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+
+		err = flow.downloadHeaders(highestSharedBlockHash, highHash)
+		if err != nil {
+			return err
+		}
+
+		// We're finished once highHash has been inserted into the DAG
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(highHash)
+		if err != nil {
+			return err
+		}
+		highHashReceived = blockInfo.Exists
+		log.Debugf("Headers downloaded from peer %s. Are further headers required: %t", flow.peer, !highHashReceived)
+	}
+	return nil
+}
+
+func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(targetHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
+	log.Debugf("Sending a blockLocator to %s between pruning point and headers selected tip", flow.peer)
+	blockLocator, err := flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+	if err != nil {
+		return nil, err
+	}
+
+	for {
+		highestHash, err := flow.fetchHighestHash(targetHash, blockLocator)
+		if err != nil {
+			return nil, err
+		}
+		highestHashIndex, err := flow.findHighestHashIndex(highestHash, blockLocator)
+		if err != nil {
+			return nil, err
+		}
+
+		if highestHashIndex == 0 ||
+			// If the block locator contains only two adjacent chain blocks, the
+			// syncer will always find the same highest chain block, so to avoid
+			// an endless loop, we explicitly stop the loop in such situation.
+			(len(blockLocator) == 2 && highestHashIndex == 1) {
+
+			return highestHash, nil
+		}
+
+		locatorHashAboveHighestHash := highestHash
+		if highestHashIndex > 0 {
+			locatorHashAboveHighestHash = blockLocator[highestHashIndex-1]
+		}
+
+		blockLocator, err = flow.nextBlockLocator(highestHash, locatorHashAboveHighestHash)
+		if err != nil {
+			return nil, err
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) nextBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+	log.Debugf("Sending a blockLocator to %s between %s and %s", flow.peer, lowHash, highHash)
+	blockLocator, err := flow.Domain().Consensus().CreateHeadersSelectedChainBlockLocator(lowHash, highHash)
+	if err != nil {
+		if errors.Is(model.ErrBlockNotInSelectedParentChain, err) {
+			return nil, err
+		}
+		log.Debugf("Headers selected parent chain moved since findHighestSharedBlockHash - " +
+			"restarting with full block locator")
+		blockLocator, err = flow.Domain().Consensus().CreateFullHeadersSelectedChainBlockLocator()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return blockLocator, nil
+}
+
+func (flow *handleRelayInvsFlow) findHighestHashIndex(
+	highestHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (int, error) {
+
+	highestHashIndex := 0
+	highestHashIndexFound := false
+	for i, blockLocatorHash := range blockLocator {
+		if highestHash.Equal(blockLocatorHash) {
+			highestHashIndex = i
+			highestHashIndexFound = true
+			break
+		}
+	}
+	if !highestHashIndexFound {
+		return 0, protocolerrors.Errorf(true, "highest hash %s "+
+			"returned from peer %s is not in the original blockLocator", highestHash, flow.peer)
+	}
+	log.Debugf("The index of the highest hash in the original "+
+		"blockLocator sent to %s is %d", flow.peer, highestHashIndex)
+
+	return highestHashIndex, nil
+}
+
+func (flow *handleRelayInvsFlow) fetchHighestHash(
+	targetHash *externalapi.DomainHash, blockLocator externalapi.BlockLocator) (*externalapi.DomainHash, error) {
+
+	ibdBlockLocatorMessage := appmessage.NewMsgIBDBlockLocator(targetHash, blockLocator)
+	err := flow.outgoingRoute.Enqueue(ibdBlockLocatorMessage)
+	if err != nil {
+		return nil, err
+	}
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	ibdBlockLocatorHighestHashMessage, ok := message.(*appmessage.MsgIBDBlockLocatorHighestHash)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDBlockLocatorHighestHash, message.Command())
+	}
+	highestHash := ibdBlockLocatorHighestHashMessage.HighestHash
+	log.Debugf("The highest hash the peer %s knows is %s", flow.peer, highestHash)
+
+	return highestHash, nil
+}
+
+func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash) error {
+
+	err := flow.sendRequestHeaders(highestSharedBlockHash, highHash)
+	if err != nil {
+		return err
+	}
+
+	// Keep a short queue of blockHeadersMessages so that there's
+	// never a moment when the node is not validating and inserting
+	// headers
+	blockHeadersMessageChan := make(chan *appmessage.BlockHeadersMessage, 2)
+	errChan := make(chan error)
+	doneChan := make(chan interface{})
+	spawn("handleRelayInvsFlow-downloadHeaders", func() {
+		for {
+			blockHeadersMessage, doneIBD, err := flow.receiveHeaders()
+			if err != nil {
+				errChan <- err
+				return
+			}
+			if doneIBD {
+				doneChan <- struct{}{}
+				return
+			}
+
+			blockHeadersMessageChan <- blockHeadersMessage
+
+			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextHeaders())
+			if err != nil {
+				errChan <- err
+				return
+			}
+		}
+	})
+
+	for {
+		select {
+		case blockHeadersMessage := <-blockHeadersMessageChan:
+			for _, header := range blockHeadersMessage.BlockHeaders {
+				err = flow.processHeader(header)
+				if err != nil {
+					return err
+				}
+			}
+		case err := <-errChan:
+			return err
+		case <-doneChan:
+			return nil
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
+
+	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
+}
+
+func (flow *handleRelayInvsFlow) receiveHeaders() (msgIBDBlock *appmessage.BlockHeadersMessage, doneIBD bool, err error) {
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, false, err
+	}
+	switch message := message.(type) {
+	case *appmessage.BlockHeadersMessage:
+		return message, false, nil
+	case *appmessage.MsgDoneHeaders:
+		return nil, true, nil
+	default:
+		return nil, false,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s or %s, got: %s", appmessage.CmdHeader, appmessage.CmdDoneHeaders, message.Command())
+	}
+}
+
+func (flow *handleRelayInvsFlow) processHeader(msgBlockHeader *appmessage.MsgBlockHeader) error {
+	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
+	block := &externalapi.DomainBlock{
+		Header:       header,
+		Transactions: nil,
+	}
+
+	blockHash := consensushashing.BlockHash(block)
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
+	if err != nil {
+		return err
+	}
+	if blockInfo.Exists {
+		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
+		return nil
+	}
+	_, err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
+	if err != nil {
+		if !errors.As(err, &ruleerrors.RuleError{}) {
+			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
+		}
+		log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
+
+		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
+	}
+
+	return nil
+}
+
+func (flow *handleRelayInvsFlow) syncPruningPointUTXOSet() (bool, error) {
+	log.Debugf("Checking if a new pruning point is available")
+	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootHashMessage())
+	if err != nil {
+		return false, err
+	}
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return false, err
+	}
+	msgIBDRootHash, ok := message.(*appmessage.MsgIBDRootHashMessage)
+	if !ok {
+		return false, protocolerrors.Errorf(true, "received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdIBDRootHash, message.Command())
+	}
+
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(msgIBDRootHash.Hash)
+	if err != nil {
+		return false, err
+	}
+
+	if blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
+		log.Debugf("Already has the block data of the new suggested pruning point %s", msgIBDRootHash.Hash)
+		return true, nil
+	}
+
+	log.Infof("Checking if the suggested pruning point %s is compatible to the node DAG", msgIBDRootHash.Hash)
+	isValid, err := flow.Domain().Consensus().IsValidPruningPoint(msgIBDRootHash.Hash)
+	if err != nil {
+		return false, err
+	}
+
+	if !isValid {
+		log.Infof("The suggested pruning point %s is incompatible to this node DAG, so stopping IBD with this"+
+			" peer", msgIBDRootHash.Hash)
+		return false, nil
+	}
+
+	log.Info("Fetching the pruning point UTXO set")
+	succeed, err := flow.fetchMissingUTXOSet(msgIBDRootHash.Hash)
+	if err != nil {
+		return false, err
+	}
+
+	if !succeed {
+		log.Infof("Couldn't successfully fetch the pruning point UTXO set. Stopping IBD.")
+		return false, nil
+	}
+
+	log.Info("Fetched the new pruning point UTXO set")
+	return true, nil
+}
+
+func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHash) (succeed bool, err error) {
+	err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootUTXOSetAndBlock(ibdRootHash))
+	if err != nil {
+		return false, err
+	}
+
+	utxoSet, block, found, err := flow.receiveIBDRootUTXOSetAndBlock()
+	if err != nil {
+		return false, err
+	}
+
+	if !found {
+		return false, nil
+	}
+
+	err = flow.Domain().Consensus().ValidateAndInsertPruningPoint(block, utxoSet)
+	if err != nil {
+		// TODO: Find a better way to deal with finality conflicts.
+		if errors.Is(err, ruleerrors.ErrSuggestedPruningViolatesFinality) {
+			return false, nil
+		}
+		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
+	}
+
+	return true, nil
+}
+
+func (flow *handleRelayInvsFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveIBDRootUTXOSetAndBlock")
+	defer onEnd()
+
+	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+	if err != nil {
+		return nil, nil, false, err
+	}
+
+	var block *externalapi.DomainBlock
+	switch message := message.(type) {
+	case *appmessage.MsgIBDBlock:
+		block = appmessage.MsgBlockToDomainBlock(message.MsgBlock)
+	case *appmessage.MsgIBDRootNotFound:
+		return nil, nil, false, nil
+	default:
+		return nil, nil, false,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s or %s, got: %s",
+				appmessage.CmdIBDBlock, appmessage.CmdIBDRootNotFound, message.Command(),
+			)
+	}
+	log.Debugf("Received IBD root block %s", consensushashing.BlockHash(block))
+
+	serializedUTXOSet := []byte{}
+	receivedAllChunks := false
+	receivedChunkCount := 0
+	for !receivedAllChunks {
+		message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+		if err != nil {
+			return nil, nil, false, err
+		}
+
+		switch message := message.(type) {
+		case *appmessage.MsgIBDRootUTXOSetChunk:
+			serializedUTXOSet = append(serializedUTXOSet, message.Chunk...)
+		case *appmessage.MsgDoneIBDRootUTXOSetChunks:
+			receivedAllChunks = true
+		default:
+			return nil, nil, false,
+				protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s or %s, got: %s",
+					appmessage.CmdIBDRootUTXOSetChunk, appmessage.CmdDoneIBDRootUTXOSetChunks, message.Command(),
+				)
+		}
+
+		receivedChunkCount++
+		if !receivedAllChunks && receivedChunkCount%ibdBatchSize == 0 {
+			log.Debugf("Received %d UTXO set chunks so far, totaling in %d bytes",
+				receivedChunkCount, len(serializedUTXOSet))
+
+			requestNextIBDRootUTXOSetChunkMessage := appmessage.NewMsgRequestNextIBDRootUTXOSetChunk()
+			err := flow.outgoingRoute.Enqueue(requestNextIBDRootUTXOSetChunkMessage)
+			if err != nil {
+				return nil, nil, false, err
+			}
+		}
+	}
+	log.Debugf("Finished receiving the UTXO set. Total bytes: %d", len(serializedUTXOSet))
+
+	return serializedUTXOSet, block, true, nil
+}
+
+func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.DomainHash) error {
+	hashes, err := flow.Domain().Consensus().GetMissingBlockBodyHashes(highHash)
+	if err != nil {
+		return err
+	}
+
+	for offset := 0; offset < len(hashes); offset += ibdBatchSize {
+		var hashesToRequest []*externalapi.DomainHash
+		if offset+ibdBatchSize < len(hashes) {
+			hashesToRequest = hashes[offset : offset+ibdBatchSize]
+		} else {
+			hashesToRequest = hashes[offset:]
+		}
+
+		err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDBlocks(hashesToRequest))
+		if err != nil {
+			return err
+		}
+
+		for _, expectedHash := range hashesToRequest {
+			message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
+			if err != nil {
+				return err
+			}
+
+			msgIBDBlock, ok := message.(*appmessage.MsgIBDBlock)
+			if !ok {
+				return protocolerrors.Errorf(true, "received unexpected message type. "+
+					"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
+			}
+
+			block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
+			blockHash := consensushashing.BlockHash(block)
+			if !expectedHash.Equal(blockHash) {
+				return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
+			}
+
+			blockInsertionResult, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
+			if err != nil {
+				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
+			}
+			err = flow.OnNewBlock(block, blockInsertionResult)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// dequeueIncomingMessageAndSkipInvs is a convenience method to be used during
+// IBD. Inv messages are expected to arrive at any given moment, but should be
+// ignored while we're in IBD
+func (flow *handleRelayInvsFlow) dequeueIncomingMessageAndSkipInvs(timeout time.Duration) (appmessage.Message, error) {
+	for {
+		message, err := flow.incomingRoute.DequeueWithTimeout(timeout)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := message.(*appmessage.MsgInvRelayBlock); !ok {
+			return message, nil
+		}
+	}
+}

app/protocol/flows/blockrelay/shared_requested_blocks.go

@@ -3,23 +3,23 @@ package blockrelay
 import (
 	"sync"
 
-	"github.com/kaspanet/kaspad/util/daghash"
+	"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[daghash.Hash]struct{}
+	blocks map[externalapi.DomainHash]struct{}
 	sync.Mutex
 }
 
-func (s *SharedRequestedBlocks) remove(hash *daghash.Hash) {
+func (s *SharedRequestedBlocks) remove(hash *externalapi.DomainHash) {
 	s.Lock()
 	defer s.Unlock()
 	delete(s.blocks, *hash)
 }
 
-func (s *SharedRequestedBlocks) removeSet(blockHashes map[daghash.Hash]struct{}) {
+func (s *SharedRequestedBlocks) removeSet(blockHashes map[externalapi.DomainHash]struct{}) {
 	s.Lock()
 	defer s.Unlock()
 	for hash := range blockHashes {
@@ -27,7 +27,7 @@ func (s *SharedRequestedBlocks) removeSet(blockHashes map[daghash.Hash]struct{})
 	}
 }
 
-func (s *SharedRequestedBlocks) addIfNotExists(hash *daghash.Hash) (exists bool) {
+func (s *SharedRequestedBlocks) addIfNotExists(hash *externalapi.DomainHash) (exists bool) {
 	s.Lock()
 	defer s.Unlock()
 	_, ok := s.blocks[*hash]
@@ -41,6 +41,6 @@ func (s *SharedRequestedBlocks) addIfNotExists(hash *daghash.Hash) (exists bool)
 // NewSharedRequestedBlocks returns a new instance of SharedRequestedBlocks.
 func NewSharedRequestedBlocks() *SharedRequestedBlocks {
 	return &SharedRequestedBlocks{
-		blocks: make(map[daghash.Hash]struct{}),
+		blocks: make(map[externalapi.DomainHash]struct{}),
 	}
 }

app/protocol/flows/handshake/handshake.go

@@ -1,21 +1,20 @@
 package handshake
 
 import (
-	"sync"
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/domain"
+
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 
-	"github.com/kaspanet/kaspad/domain/blockdag"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/locks"
 	"github.com/pkg/errors"
 )
 
@@ -23,9 +22,8 @@ import (
 type HandleHandshakeContext interface {
 	Config() *config.Config
 	NetAdapter() *netadapter.NetAdapter
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 	AddressManager() *addressmanager.AddressManager
-	StartIBDIfRequired()
 	AddToPeers(peer *peerpkg.Peer) error
 	HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error)
 }
@@ -37,10 +35,12 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 ) (*peerpkg.Peer, error) {
 
 	// For HandleHandshake to finish, we need to get from the other node
-	// a version and verack messages, so we increase the wait group by 2
-	// and block HandleHandshake with wg.Wait().
-	wg := sync.WaitGroup{}
-	wg.Add(2)
+	// a version and verack messages, so we set doneCount to 2, decrease it
+	// when sending and receiving the version, and close the doneChan when
+	// it's 0. Then we wait for on select for a tick from doneChan or from
+	// errChan.
+	doneCount := int32(2)
+	doneChan := make(chan struct{})
 
 	isStopping := uint32(0)
 	errChan := make(chan error)
@@ -55,7 +55,9 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			return
 		}
 		peerAddress = address
-		wg.Done()
+		if atomic.AddInt32(&doneCount, -1) == 0 {
+			close(doneChan)
+		}
 	})
 
 	spawn("HandleHandshake-SendVersion", func() {
@@ -64,7 +66,9 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			handleError(err, "SendVersion", &isStopping, errChan)
 			return
 		}
-		wg.Done()
+		if atomic.AddInt32(&doneCount, -1) == 0 {
+			close(doneChan)
+		}
 	})
 
 	select {
@@ -73,7 +77,7 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			return nil, err
 		}
 		return nil, nil
-	case <-locks.ReceiveFromChanWhenDone(func() { wg.Wait() }):
+	case <-doneChan:
 	}
 
 	err := context.AddToPeers(peer)
@@ -85,13 +89,8 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 	}
 
 	if peerAddress != nil {
-		subnetworkID := peer.SubnetworkID()
-		context.AddressManager().AddAddress(peerAddress, peerAddress, subnetworkID)
-		context.AddressManager().Good(peerAddress, subnetworkID)
+		context.AddressManager().AddAddresses(peerAddress)
 	}
-
-	context.StartIBDIfRequired()
-
 	return peer, nil
 }
 

app/protocol/flows/handshake/receiveversion.go

@@ -5,6 +5,7 @@ import (
 	"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/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -41,11 +42,18 @@ func ReceiveVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start")
+	defer onEnd()
+
+	log.Debugf("Starting receiveVersionFlow with %s", flow.peer.Address())
+
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err
 	}
 
+	log.Debugf("Got version message")
+
 	msgVersion, ok := message.(*appmessage.MsgVersion)
 	if !ok {
 		return nil, protocolerrors.New(true, "a version message must precede all others")
@@ -72,7 +80,7 @@ func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
 	}
 
 	// Disconnect from partial nodes in networks that don't allow them
-	if !flow.DAG().Params.EnableNonNativeSubnetworks && msgVersion.SubnetworkID != nil {
+	if !flow.Config().ActiveNetParams.EnableNonNativeSubnetworks && msgVersion.SubnetworkID != nil {
 		return nil, protocolerrors.New(true, "partial nodes are not allowed")
 	}
 
@@ -84,7 +92,7 @@ func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
 	isRemoteNodeFull := msgVersion.SubnetworkID == nil
 	isOutbound := flow.peer.Connection().IsOutbound()
 	if (isLocalNodeFull && !isRemoteNodeFull && isOutbound) ||
-		(!isLocalNodeFull && !isRemoteNodeFull && !msgVersion.SubnetworkID.IsEqual(localSubnetworkID)) {
+		(!isLocalNodeFull && !isRemoteNodeFull && !msgVersion.SubnetworkID.Equal(localSubnetworkID)) {
 
 		return nil, protocolerrors.New(false, "incompatible subnetworks")
 	}

app/protocol/flows/handshake/sendversion.go

@@ -4,6 +4,7 @@ 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/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/kaspanet/kaspad/version"
 )
@@ -28,6 +29,7 @@ var (
 
 type sendVersionFlow struct {
 	HandleHandshakeContext
+
 	incomingRoute, outgoingRoute *router.Route
 	peer                         *peerpkg.Peer
 }
@@ -46,13 +48,16 @@ func SendVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *sendVersionFlow) start() error {
-	selectedTipHash := flow.DAG().SelectedTipHash()
-	subnetworkID := flow.Config().SubnetworkID
+	onEnd := logger.LogAndMeasureExecutionTime(log, "sendVersionFlow.start")
+	defer onEnd()
+
+	log.Debugf("Starting sendVersionFlow with %s", flow.peer.Address())
 
 	// Version message.
-	localAddress := flow.AddressManager().GetBestLocalAddress(flow.peer.Connection().NetAddress())
+	localAddress := flow.AddressManager().BestLocalAddress(flow.peer.Connection().NetAddress())
+	subnetworkID := flow.Config().SubnetworkID
 	msg := appmessage.NewMsgVersion(localAddress, flow.NetAdapter().ID(),
-		flow.Config().ActiveNetParams.Name, selectedTipHash, subnetworkID)
+		flow.Config().ActiveNetParams.Name, subnetworkID)
 	msg.AddUserAgent(userAgentName, userAgentVersion, flow.Config().UserAgentComments...)
 
 	// Advertise the services flag
@@ -70,9 +75,11 @@ func (flow *sendVersionFlow) start() error {
 	}
 
 	// Wait for verack
+	log.Debugf("Waiting for verack")
 	_, err = flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return err
 	}
+	log.Debugf("Got verack")
 	return nil
 }