Fix version

* [NOD-1517] Properly initialize consensus with Genesis block

* [NOD-1517] Remove redundant AddHeaderTip

* [NOD-1517] Don't return nil from dbHash<->DomainHash converters

* [NOD-1517] Use pointer receivers

* [NOD-1517] Use domain block in dagParams

* [NOD-1517] Remove boolean from SelectedTip

* [NOD-1517] Rename hasHeader to isHeadersOnlyBlock

* [NOD-1517] Add comment

* [NOD-1517] Change genesis version

* [NOD-1517] Rename TestNewFactory->TestNewConsensus

app/app.go

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

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

@@ -1,190 +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"
-	"io"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/util/mstime"
-)
-
-// 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 {
-	return byte(len(h.ParentHashes))
-}
-
-// 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/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/common.go

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

app/appmessage/common_test.go

@@ -6,19 +6,20 @@ package appmessage
 
 import (
 	"bytes"
-	"github.com/pkg/errors"
 	"io"
 	"reflect"
 	"strings"
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/pkg/errors"
+
 	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainnetGenesisHash = &daghash.Hash{
+var mainnetGenesisHash = &externalapi.DomainHash{
 	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
 	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
 	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
@@ -27,30 +28,30 @@ var mainnetGenesisHash = &daghash.Hash{
 
 // simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simnetGenesisHash = &daghash.Hash{
-	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a,
-	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
-	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
-	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
+var simnetGenesisHash = &externalapi.DomainHash{
+	0x9d, 0x89, 0xb0, 0x6e, 0xb3, 0x47, 0xb5, 0x6e,
+	0xcd, 0x6c, 0x63, 0x99, 0x45, 0x91, 0xd5, 0xce,
+	0x9b, 0x43, 0x05, 0xc1, 0xa5, 0x5e, 0x2a, 0xda,
+	0x90, 0x4c, 0xf0, 0x6c, 0x4d, 0x5f, 0xd3, 0x62,
 }
 
 // mainnetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
-var mainnetGenesisMerkleRoot = &daghash.Hash{
+var mainnetGenesisMerkleRoot = &externalapi.DomainHash{
 	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 }
 
-var exampleAcceptedIDMerkleRoot = &daghash.Hash{
+var exampleAcceptedIDMerkleRoot = &externalapi.DomainHash{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 }
 
-var exampleUTXOCommitment = &daghash.Hash{
+var exampleUTXOCommitment = &externalapi.DomainHash{
 	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -104,7 +105,7 @@ func TestElementEncoding(t *testing.T) {
 			},
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
@@ -193,7 +194,7 @@ func TestElementEncodingErrors(t *testing.T) {
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{
+			(*externalapi.DomainHash)(&[externalapi.DomainHashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,

app/appmessage/domainconverters.go

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

app/appmessage/error.go

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

app/appmessage/fakemessage_test.go

@@ -1,56 +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 "io"
-
-// fakeMessage implements the Message interface and is used to force encode
-// errors in messages.
-type fakeMessage struct {
-	command        MessageCommand
-	payload        []byte
-	forceEncodeErr bool
-	forceLenErr    bool
-}
-
-// KaspaDecode doesn't do anything. It just satisfies the appmessage.Message
-// interface.
-func (msg *fakeMessage) KaspaDecode(r io.Reader, pver uint32) error {
-	return nil
-}
-
-// KaspaEncode writes the payload field of the fake message or forces an error
-// if the forceEncodeErr flag of the fake message is set. It also satisfies the
-// appmessage.Message interface.
-func (msg *fakeMessage) KaspaEncode(w io.Writer, pver uint32) error {
-	if msg.forceEncodeErr {
-		err := &MessageError{
-			Func:        "fakeMessage.KaspaEncode",
-			Description: "intentional error",
-		}
-		return err
-	}
-
-	_, err := w.Write(msg.payload)
-	return err
-}
-
-// Command returns the command field of the fake message and satisfies the
-// Message interface.
-func (msg *fakeMessage) Command() MessageCommand {
-	return msg.command
-}
-
-// MaxPayloadLength returns the length of the payload field of fake message
-// or a smaller value if the forceLenErr flag of the fake message is set. It
-// satisfies the Message interface.
-func (msg *fakeMessage) MaxPayloadLength(pver uint32) uint32 {
-	lenp := uint32(len(msg.payload))
-	if msg.forceLenErr {
-		return lenp - 1
-	}
-
-	return lenp
-}

app/appmessage/message.go

@@ -11,13 +11,16 @@ import (
 
 // MaxMessagePayload is the maximum bytes a message can be regardless of other
 // individual limits imposed by messages themselves.
-const MaxMessagePayload = (1024 * 1024 * 32) // 32MB
+const MaxMessagePayload = 1024 * 1024 * 32 // 32MB
 
 // MessageCommand is a number in the header of a message that represents its type.
 type MessageCommand uint32
 
 func (cmd MessageCommand) String() string {
-	cmdString, ok := MessageCommandToString[cmd]
+	cmdString, ok := ProtocolMessageCommandToString[cmd]
+	if !ok {
+		cmdString, ok = RPCMessageCommandToString[cmd]
+	}
 	if !ok {
 		cmdString = "unknown command"
 	}
@@ -26,6 +29,7 @@ func (cmd MessageCommand) String() string {
 
 // Commands used in kaspa message headers which describe the type of message.
 const (
+	// protocol
 	CmdVersion MessageCommand = iota
 	CmdVerAck
 	CmdRequestAddresses
@@ -48,10 +52,61 @@ const (
 	CmdDoneIBDBlocks
 	CmdTransactionNotFound
 	CmdReject
+
+	// rpc
+	CmdGetCurrentNetworkRequestMessage
+	CmdGetCurrentNetworkResponseMessage
+	CmdSubmitBlockRequestMessage
+	CmdSubmitBlockResponseMessage
+	CmdGetBlockTemplateRequestMessage
+	CmdGetBlockTemplateResponseMessage
+	CmdGetBlockTemplateTransactionMessage
+	CmdNotifyBlockAddedRequestMessage
+	CmdNotifyBlockAddedResponseMessage
+	CmdBlockAddedNotificationMessage
+	CmdGetPeerAddressesRequestMessage
+	CmdGetPeerAddressesResponseMessage
+	CmdGetSelectedTipHashRequestMessage
+	CmdGetSelectedTipHashResponseMessage
+	CmdGetMempoolEntryRequestMessage
+	CmdGetMempoolEntryResponseMessage
+	CmdGetConnectedPeerInfoRequestMessage
+	CmdGetConnectedPeerInfoResponseMessage
+	CmdAddPeerRequestMessage
+	CmdAddPeerResponseMessage
+	CmdSubmitTransactionRequestMessage
+	CmdSubmitTransactionResponseMessage
+	CmdNotifyChainChangedRequestMessage
+	CmdNotifyChainChangedResponseMessage
+	CmdChainChangedNotificationMessage
+	CmdGetBlockRequestMessage
+	CmdGetBlockResponseMessage
+	CmdGetSubnetworkRequestMessage
+	CmdGetSubnetworkResponseMessage
+	CmdGetChainFromBlockRequestMessage
+	CmdGetChainFromBlockResponseMessage
+	CmdGetBlocksRequestMessage
+	CmdGetBlocksResponseMessage
+	CmdGetBlockCountRequestMessage
+	CmdGetBlockCountResponseMessage
+	CmdGetBlockDAGInfoRequestMessage
+	CmdGetBlockDAGInfoResponseMessage
+	CmdResolveFinalityConflictRequestMessage
+	CmdResolveFinalityConflictResponseMessage
+	CmdNotifyFinalityConflictsRequestMessage
+	CmdNotifyFinalityConflictsResponseMessage
+	CmdFinalityConflictNotificationMessage
+	CmdFinalityConflictResolvedNotificationMessage
+	CmdGetMempoolEntriesRequestMessage
+	CmdGetMempoolEntriesResponseMessage
+	CmdShutDownRequestMessage
+	CmdShutDownResponseMessage
+	CmdGetHeadersRequestMessage
+	CmdGetHeadersResponseMessage
 )
 
-// MessageCommandToString maps all MessageCommands to their string representation
-var MessageCommandToString = map[MessageCommand]string{
+// ProtocolMessageCommandToString maps all MessageCommands to their string representation
+var ProtocolMessageCommandToString = map[MessageCommand]string{
 	CmdVersion:              "Version",
 	CmdVerAck:               "VerAck",
 	CmdRequestAddresses:     "RequestAddresses",
@@ -76,6 +131,57 @@ var MessageCommandToString = map[MessageCommand]string{
 	CmdReject:               "Reject",
 }
 
+// RPCMessageCommandToString maps all MessageCommands to their string representation
+var RPCMessageCommandToString = map[MessageCommand]string{
+	CmdGetCurrentNetworkRequestMessage:             "GetCurrentNetworkRequest",
+	CmdGetCurrentNetworkResponseMessage:            "GetCurrentNetworkResponse",
+	CmdSubmitBlockRequestMessage:                   "SubmitBlockRequest",
+	CmdSubmitBlockResponseMessage:                  "SubmitBlockResponse",
+	CmdGetBlockTemplateRequestMessage:              "GetBlockTemplateRequest",
+	CmdGetBlockTemplateResponseMessage:             "GetBlockTemplateResponse",
+	CmdGetBlockTemplateTransactionMessage:          "CmdGetBlockTemplateTransaction",
+	CmdNotifyBlockAddedRequestMessage:              "NotifyBlockAddedRequest",
+	CmdNotifyBlockAddedResponseMessage:             "NotifyBlockAddedResponse",
+	CmdBlockAddedNotificationMessage:               "BlockAddedNotification",
+	CmdGetPeerAddressesRequestMessage:              "GetPeerAddressesRequest",
+	CmdGetPeerAddressesResponseMessage:             "GetPeerAddressesResponse",
+	CmdGetSelectedTipHashRequestMessage:            "GetSelectedTipHashRequest",
+	CmdGetSelectedTipHashResponseMessage:           "GetSelectedTipHashResponse",
+	CmdGetMempoolEntryRequestMessage:               "GetMempoolEntryRequest",
+	CmdGetMempoolEntryResponseMessage:              "GetMempoolEntryResponse",
+	CmdGetConnectedPeerInfoRequestMessage:          "GetConnectedPeerInfoRequest",
+	CmdGetConnectedPeerInfoResponseMessage:         "GetConnectedPeerInfoResponse",
+	CmdAddPeerRequestMessage:                       "AddPeerRequest",
+	CmdAddPeerResponseMessage:                      "AddPeerResponse",
+	CmdSubmitTransactionRequestMessage:             "SubmitTransactionRequest",
+	CmdSubmitTransactionResponseMessage:            "SubmitTransactionResponse",
+	CmdNotifyChainChangedRequestMessage:            "NotifyChainChangedRequest",
+	CmdNotifyChainChangedResponseMessage:           "NotifyChainChangedResponse",
+	CmdChainChangedNotificationMessage:             "ChainChangedNotification",
+	CmdGetBlockRequestMessage:                      "GetBlockRequest",
+	CmdGetBlockResponseMessage:                     "GetBlockResponse",
+	CmdGetSubnetworkRequestMessage:                 "GetSubnetworkRequest",
+	CmdGetSubnetworkResponseMessage:                "GetSubnetworkResponse",
+	CmdGetChainFromBlockRequestMessage:             "GetChainFromBlockRequest",
+	CmdGetChainFromBlockResponseMessage:            "GetChainFromBlockResponse",
+	CmdGetBlocksRequestMessage:                     "GetBlocksRequest",
+	CmdGetBlocksResponseMessage:                    "GetBlocksResponse",
+	CmdGetBlockCountRequestMessage:                 "GetBlockCountRequest",
+	CmdGetBlockCountResponseMessage:                "GetBlockCountResponse",
+	CmdGetBlockDAGInfoRequestMessage:               "GetBlockDAGInfoRequest",
+	CmdGetBlockDAGInfoResponseMessage:              "GetBlockDAGInfoResponse",
+	CmdResolveFinalityConflictRequestMessage:       "ResolveFinalityConflictRequest",
+	CmdResolveFinalityConflictResponseMessage:      "ResolveFinalityConflictResponse",
+	CmdNotifyFinalityConflictsRequestMessage:       "NotifyFinalityConflictsRequest",
+	CmdNotifyFinalityConflictsResponseMessage:      "NotifyFinalityConflictsResponse",
+	CmdFinalityConflictNotificationMessage:         "FinalityConflictNotification",
+	CmdFinalityConflictResolvedNotificationMessage: "FinalityConflictResolvedNotification",
+	CmdGetMempoolEntriesRequestMessage:             "GetMempoolEntriesRequestMessage",
+	CmdGetMempoolEntriesResponseMessage:            "GetMempoolEntriesResponseMessage",
+	CmdGetHeadersRequestMessage:                    "GetHeadersRequest",
+	CmdGetHeadersResponseMessage:                   "GetHeadersResponse",
+}
+
 // Message is an interface that describes a kaspa message. A type that
 // implements Message has complete control over the representation of its data
 // and may therefore contain additional or fewer fields than those which

app/appmessage/msgblock.go

@@ -1,250 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// defaultTransactionAlloc is the default size used for the backing array
-// for transactions. The transaction array will dynamically grow as needed, but
-// this figure is intended to provide enough space for the number of
-// transactions in the vast majority of blocks without needing to grow the
-// backing array multiple times.
-const defaultTransactionAlloc = 2048
-
-// MaxMassPerBlock is the maximum total transaction mass a block may have.
-const MaxMassPerBlock = 10000000
-
-// MaxMassPerTx is the maximum total mass a transaction may have.
-const MaxMassPerTx = MaxMassPerBlock / 2
-
-// MaxTxPerBlock is the maximum number of transactions that could
-// possibly fit into a block.
-const MaxTxPerBlock = (MaxMassPerBlock / minTxPayload) + 1
-
-// TxLoc holds locator data for the offset and length of where a transaction is
-// located within a MsgBlock data buffer.
-type TxLoc struct {
-	TxStart int
-	TxLen   int
-}
-
-// MsgBlock implements the Message interface and represents a kaspa
-// block message. It is used to deliver block and transaction information in
-// response to a getdata message (MsgGetData) for a given block hash.
-type MsgBlock struct {
-	baseMessage
-	Header       BlockHeader
-	Transactions []*MsgTx
-}
-
-// AddTransaction adds a transaction to the message.
-func (msg *MsgBlock) AddTransaction(tx *MsgTx) {
-	msg.Transactions = append(msg.Transactions, tx)
-}
-
-// ClearTransactions removes all transactions from the message.
-func (msg *MsgBlock) ClearTransactions() {
-	msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
-}
-
-// 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 {
-	return CmdBlock
-}
-
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
-	return MaxMessagePayload
-}
-
-// 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) {
-	for _, tx := range msg.Transactions {
-		if !tx.SubnetworkID.IsEqual(subnetworkID) {
-			tx.Payload = []byte{}
-		}
-	}
-}
-
-// NewMsgBlock returns a new kaspa block message that conforms to the
-// Message interface. See MsgBlock for details.
-func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
-	return &MsgBlock{
-		Header:       *blockHeader,
-		Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),
-	}
-}

app/appmessage/msgblock_test.go

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

app/appmessage/msgtx_test.go

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

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

app/appmessage/p2p_blockheader_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 BlockHeader 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 := &BlockHeader{
+		Version:        1,
+		ParentHashes:   []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot: mainnetGenesisMerkleRoot,
+		Timestamp:      timestamp,
+		Bits:           bits,
+		Nonce:          nonce,
+	}
+	genesisBlockHdr := &BlockHeader{
+		Version:        1,
+		ParentHashes:   []*externalapi.DomainHash{},
+		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_msgaddresses.go

@@ -6,7 +6,8 @@ package appmessage
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MaxAddressesPerMsg is the maximum number of addresses that can be in a single
@@ -26,7 +27,7 @@ const MaxAddressesPerMsg = 1000
 type MsgAddresses struct {
 	baseMessage
 	IncludeAllSubnetworks bool
-	SubnetworkID          *subnetworkid.SubnetworkID
+	SubnetworkID          *externalapi.DomainSubnetworkID
 	AddrList              []*NetAddress
 }
 
@@ -66,7 +67,7 @@ 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(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) *MsgAddresses {
 	return &MsgAddresses{
 		IncludeAllSubnetworks: includeAllSubnetworks,
 		SubnetworkID:          subnetworkID,

app/appmessage/p2p_msgblock.go

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

app/appmessage/p2p_msgblock_test.go

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

app/appmessage/p2p_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,22 @@ package appmessage
 import (
 	"testing"
 
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // TestBlockLocator tests the MsgBlockLocator API.
 func TestBlockLocator(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	locatorHash, err := daghash.NewHashFromStr(hashStr)
+	locatorHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	msg := NewMsgBlockLocator([]*daghash.Hash{locatorHash})
+	msg := NewMsgBlockLocator([]*externalapi.DomainHash{locatorHash})
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(10)

app/appmessage/p2p_msgibdblock_test.go

@@ -5,7 +5,6 @@
 package appmessage
 
 import (
-	"bytes"
 	"reflect"
 	"testing"
 
@@ -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_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,7 +1,7 @@
 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
@@ -10,8 +10,8 @@ import (
 // The locator is returned via a locator message (MsgBlockLocator).
 type MsgRequestBlockLocator struct {
 	baseMessage
-	HighHash *daghash.Hash
-	LowHash  *daghash.Hash
+	HighHash *externalapi.DomainHash
+	LowHash  *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,7 +23,7 @@ func (msg *MsgRequestBlockLocator) Command() MessageCommand {
 // NewMsgRequestBlockLocator returns a new RequestBlockLocator message that conforms to the
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
-func NewMsgRequestBlockLocator(highHash, lowHash *daghash.Hash) *MsgRequestBlockLocator {
+func NewMsgRequestBlockLocator(highHash, lowHash *externalapi.DomainHash) *MsgRequestBlockLocator {
 	return &MsgRequestBlockLocator{
 		HighHash: highHash,
 		LowHash:  lowHash,

app/appmessage/p2p_msgrequestblocklocator_test.go

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

app/appmessage/p2p_msgrequestibdblocks.go

@@ -5,7 +5,7 @@
 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
@@ -13,8 +13,8 @@ import (
 // low hash and until the high hash.
 type MsgRequestIBDBlocks struct {
 	baseMessage
-	LowHash  *daghash.Hash
-	HighHash *daghash.Hash
+	LowHash  *externalapi.DomainHash
+	HighHash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -26,7 +26,7 @@ func (msg *MsgRequestIBDBlocks) Command() MessageCommand {
 // 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 {
+func NewMsgRequstIBDBlocks(lowHash, highHash *externalapi.DomainHash) *MsgRequestIBDBlocks {
 	return &MsgRequestIBDBlocks{
 		LowHash:  lowHash,
 		HighHash: highHash,

app/appmessage/p2p_msgrequestibdblocks_test.go

@@ -7,26 +7,26 @@ package appmessage
 import (
 	"testing"
 
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
 // TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
 func TestRequstIBDBlocks(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
-	lowHash, err := daghash.NewHashFromStr(hashStr)
+	lowHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
-	hashStr = "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
-	highHash, err := daghash.NewHashFromStr(hashStr)
+	hashStr = "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	highHash, err := hashes.FromString(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
 	}
 
 	// Ensure we get the same data back out.
 	msg := NewMsgRequstIBDBlocks(lowHash, highHash)
-	if !msg.HighHash.IsEqual(highHash) {
+	if *msg.HighHash != *highHash {
 		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
 			msg.HighHash, highHash)
 	}

app/appmessage/p2p_msgrequestrelayblocks.go

@@ -1,7 +1,7 @@
 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
@@ -13,7 +13,7 @@ const MsgRequestRelayBlocksHashes = MaxInvPerMsg
 // 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_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,7 +1,7 @@
 package appmessage
 
 import (
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
 // MsgSelectedTip implements the Message interface and represents a kaspa
@@ -10,7 +10,7 @@ import (
 type MsgSelectedTip struct {
 	baseMessage
 	// The selected tip hash of the generator of the message.
-	SelectedTipHash *daghash.Hash
+	SelectedTipHash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -21,7 +21,7 @@ func (msg *MsgSelectedTip) Command() MessageCommand {
 
 // NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
 // Message interface.
-func NewMsgSelectedTip(selectedTipHash *daghash.Hash) *MsgSelectedTip {
+func NewMsgSelectedTip(selectedTipHash *externalapi.DomainHash) *MsgSelectedTip {
 	return &MsgSelectedTip{
 		SelectedTipHash: selectedTipHash,
 	}

app/appmessage/p2p_msgselectedtip_test.go

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

app/appmessage/p2p_msgtransactionnotfound.go

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

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

app/appmessage/p2p_msgtx_test.go

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

app/appmessage/p2p_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
@@ -55,13 +54,13 @@ type MsgVersion struct {
 	UserAgent string
 
 	// The selected tip hash of the generator of the version message.
-	SelectedTipHash *daghash.Hash
+	SelectedTipHash *externalapi.DomainHash
 
 	// Don't announce transactions to peer.
 	DisableRelayTx bool
 
 	// The subnetwork of the generator of the version message. Should be nil in full nodes
-	SubnetworkID *subnetworkid.SubnetworkID
+	SubnetworkID *externalapi.DomainSubnetworkID
 }
 
 // HasService returns whether the specified service is supported by the peer
@@ -86,7 +85,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 {
+	selectedTipHash *externalapi.DomainHash, subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.

app/appmessage/p2p_msgversion_test.go

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

app/appmessage/rpc_add_peer.go

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

app/appmessage/rpc_get_block.go

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

app/appmessage/rpc_get_block_count.go

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

app/appmessage/rpc_get_block_dag_info.go

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

app/appmessage/rpc_get_block_template.go

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

app/appmessage/rpc_get_blocks.go

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

app/appmessage/rpc_get_chain_from_block.go

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

app/appmessage/rpc_get_connected_peer_info.go

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

app/appmessage/rpc_get_current_network.go

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

app/appmessage/rpc_get_headers.go

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

app/appmessage/rpc_get_mempool_entries.go

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

app/appmessage/rpc_get_mempool_entry.go

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

app/appmessage/rpc_get_peer_addresses.go

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

app/appmessage/rpc_get_selected_tip_hash.go

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

app/appmessage/rpc_get_subnetwork.go

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

app/appmessage/rpc_notify_block_added.go

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

app/appmessage/rpc_notify_chain_changed.go

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

app/appmessage/rpc_notify_finality_conflicts.go

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

app/appmessage/rpc_resolve_finality_conflict.go

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

app/appmessage/rpc_shut_down.go

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

app/appmessage/rpc_submit_block.go

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

app/appmessage/rpc_submit_transaction.go

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

app/component_manager.go

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

app/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,12 +22,12 @@ 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) error {
 	mtx.Lock()
 	defer mtx.Unlock()
 
 	receivedLogBlocks++
-	receivedLogTx += int64(len(block.MsgBlock().Transactions))
+	receivedLogTx += int64(len(block.Transactions))
 
 	now := mstime.Now()
 	duration := now.Sub(lastBlockLogTime)
@@ -48,14 +48,9 @@ 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

app/protocol/flowcontext/blocks.go

@@ -3,26 +3,32 @@ package flowcontext
 import (
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // OnNewBlock updates the mempool after a new block arrival, and
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *util.Block) error {
-	transactionsAcceptedToMempool, err := f.txPool.HandleNewBlock(block)
-	if err != nil {
-		return err
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
+	f.Domain().MiningManager().HandleNewBlockTransactions(block.Transactions)
+
+	if f.onBlockAddedToDAGHandler != nil {
+		err := f.onBlockAddedToDAGHandler(block)
+		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.
@@ -30,14 +36,14 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(block *util.Block, tr
 		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] = consensusserialization.TransactionID(tx)
 	}
 	offset := len(transactionsAcceptedToMempool)
 	for i, txID := range txIDsToRebroadcast {
@@ -61,8 +67,8 @@ 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 {
+	err := f.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		return err
 	}
@@ -70,5 +76,5 @@ func (f *FlowContext) AddBlock(block *util.Block, flags blockdag.BehaviorFlags)
 	if err != nil {
 		return err
 	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(block.Hash()))
+	return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
 }

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

@@ -4,32 +4,42 @@ import (
 	"sync"
 	"time"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
+	"github.com/kaspanet/kaspad/domain"
+
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
 	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/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 *externalapi.DomainBlock) error
+
+// OnTransactionAddedToMempoolHandler is a handler function that's triggered
+// when a transaction is added to the mempool
+type OnTransactionAddedToMempoolHandler func()
+
 // FlowContext holds state that is relevant to more than one flow or one peer, and allows communication between
 // different flows that can be associated to different peers.
 type FlowContext struct {
 	cfg               *config.Config
 	netAdapter        *netadapter.NetAdapter
-	txPool            *mempool.TxPool
-	dag               *blockdag.BlockDAG
+	domain            domain.Domain
 	addressManager    *addressmanager.AddressManager
 	connectionManager *connmanager.ConnectionManager
 
+	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
 
@@ -44,20 +54,28 @@ type FlowContext struct {
 }
 
 // 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(),
 		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
 		peers:                       make(map[id.ID]*peerpkg.Peer),
-		transactionsToRebroadcast:   make(map[daghash.TxID]*util.Tx),
+		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
 	}
 }
+
+// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
+func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
+	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
+}
+
+// SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
+func (f *FlowContext) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler) {
+	f.onTransactionAddedToMempoolHandler = onTransactionAddedToMempoolHandler
+}

app/protocol/flowcontext/ibd.go

@@ -4,29 +4,35 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/kaspanet/kaspad/util/mstime"
+
 	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() {
+func (f *FlowContext) StartIBDIfRequired() error {
 	f.startIBDMutex.Lock()
 	defer f.startIBDMutex.Unlock()
 
 	if f.IsInIBD() {
-		return
+		return nil
 	}
 
-	peer := f.selectPeerForIBD(f.dag)
+	peer, err := f.selectPeerForIBD()
+	if err != nil {
+		return err
+	}
 	if peer == nil {
 		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
-		return
+		return nil
 	}
 
 	atomic.StoreUint32(&f.isInIBD, 1)
 	f.ibdPeer = peer
 	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+
+	return nil
 }
 
 // IsInIBD is true if IBD is currently running
@@ -36,29 +42,42 @@ func (f *FlowContext) IsInIBD() bool {
 
 // selectPeerForIBD returns the first peer whose selected tip
 // hash is not in our DAG
-func (f *FlowContext) selectPeerForIBD(dag *blockdag.BlockDAG) *peerpkg.Peer {
+func (f *FlowContext) selectPeerForIBD() (*peerpkg.Peer, error) {
 	f.peersMutex.RLock()
 	defer f.peersMutex.RUnlock()
 
 	for _, peer := range f.peers {
 		peerSelectedTipHash := peer.SelectedTipHash()
-		if !dag.IsInDAG(peerSelectedTipHash) {
-			return peer
+		blockInfo, err := f.domain.Consensus().GetBlockInfo(peerSelectedTipHash)
+		if err != nil {
+			return nil, err
+		}
+		if !blockInfo.Exists {
+			return peer, nil
 		}
 	}
-	return nil
+	return nil, nil
 }
 
 func (f *FlowContext) requestSelectedTipsIfRequired() {
-	if f.isDAGTimeCurrent() {
+	dagTimeCurrent, err := f.shouldRequestSelectedTips()
+	if err != nil {
+		panic(err)
+	}
+	if dagTimeCurrent {
 		return
 	}
 	f.requestSelectedTips()
 }
 
-func (f *FlowContext) isDAGTimeCurrent() bool {
+func (f *FlowContext) shouldRequestSelectedTips() (bool, error) {
 	const minDurationToRequestSelectedTips = time.Minute
-	return f.dag.Now().Sub(f.dag.SelectedTipHeader().Timestamp) > minDurationToRequestSelectedTips
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+	virtualSelectedParentTime := mstime.UnixMilliseconds(virtualSelectedParent.Header.TimeInMilliseconds)
+	return mstime.Now().Sub(virtualSelectedParentTime) > minDurationToRequestSelectedTips, nil
 }
 
 func (f *FlowContext) requestSelectedTips() {
@@ -71,12 +90,12 @@ func (f *FlowContext) requestSelectedTips() {
 }
 
 // FinishIBD finishes the current IBD flow and starts a new one if required.
-func (f *FlowContext) FinishIBD() {
+func (f *FlowContext) FinishIBD() error {
 	f.ibdPeer = nil
 
 	atomic.StoreUint32(&f.isInIBD, 0)
 
-	f.StartIBDIfRequired()
+	return f.StartIBDIfRequired()
 }
 
 // IBDPeer returns the currently active IBD peer.

app/protocol/flowcontext/network.go

@@ -56,7 +56,7 @@ func (f *FlowContext) readyPeerConnections() []*netadapter.NetConnection {
 
 // Broadcast broadcast the given message to all the ready peers.
 func (f *FlowContext) Broadcast(message appmessage.Message) error {
-	return f.netAdapter.Broadcast(f.readyPeerConnections(), message)
+	return f.netAdapter.P2PBroadcast(f.readyPeerConnections(), message)
 }
 
 // Peers returns the currently active peers

app/protocol/flowcontext/transactions.go

@@ -1,42 +1,38 @@
 package flowcontext
 
 import (
+	"time"
+
 	"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/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 )
 
 // AddTransaction adds transaction to the mempool and propagates it.
-func (f *FlowContext) AddTransaction(tx *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 := consensusserialization.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, *consensusserialization.TransactionID(tx))
 	}
 }
 
@@ -45,14 +41,14 @@ 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] = consensusserialization.TransactionID(tx)
 		i++
 	}
 	return txIDs
@@ -64,7 +60,10 @@ func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedReq
 	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() {
+	if f.onTransactionAddedToMempoolHandler != nil {
+		f.onTransactionAddedToMempoolHandler()
+	}
 }

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -45,7 +45,7 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 		return protocolerrors.Errorf(true, "got unexpected "+
 			"IncludeAllSubnetworks=true in [%s] command", msgAddresses.Command())
 	}
-	if !msgAddresses.SubnetworkID.IsEqual(context.Config().SubnetworkID) && msgAddresses.SubnetworkID != nil {
+	if msgAddresses.SubnetworkID != nil && *msgAddresses.SubnetworkID != *context.Config().SubnetworkID {
 		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)

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -4,14 +4,14 @@ 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/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
@@ -27,26 +27,21 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
 		for _, hash := range getRelayBlocksMessage.Hashes {
 			// Fetch the block from the database.
-			block, err := context.DAG().BlockByHash(hash)
-			if blockdag.IsNotInDAGErr(err) {
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			if err != nil {
+				return err
+			}
+			if !blockInfo.Exists {
 				return protocolerrors.Errorf(true, "block %s not found", hash)
-			} else if err != nil {
+			}
+			block, err := context.Domain().Consensus().GetBlock(hash)
+			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()
+			// TODO (Partial nodes): Convert block to partial block if needed
 
-			isNodeFull := nodeSubnetworkID == nil
-			isPeerFull := peerSubnetworkID == nil
-			if isNodeFull && !isPeerFull {
-				msgBlock.ConvertToPartial(peerSubnetworkID)
-			}
-
-			err = outgoingRoute.Enqueue(msgBlock)
+			err = outgoingRoute.Enqueue(appmessage.DomainBlockToMsgBlock(block))
 			if err != nil {
 				return err
 			}

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -6,22 +6,24 @@ 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/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/blocks"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 	mathUtil "github.com/kaspanet/kaspad/util/math"
 	"github.com/pkg/errors"
 )
 
 // RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
 type RelayInvsContext interface {
+	Domain() domain.Domain
 	NetAdapter() *netadapter.NetAdapter
-	DAG() *blockdag.BlockDAG
-	OnNewBlock(block *util.Block) error
+	OnNewBlock(block *externalapi.DomainBlock) error
 	SharedRequestedBlocks() *SharedRequestedBlocks
-	StartIBDIfRequired()
+	StartIBDIfRequired() error
 	IsInIBD() bool
 	Broadcast(message appmessage.Message) error
 }
@@ -57,15 +59,22 @@ 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)
 			}
 			continue
 		}
 
-		flow.StartIBDIfRequired()
+		err = flow.StartIBDIfRequired()
+		if err != nil {
+			return err
+		}
 		if flow.IsInIBD() {
 			// Block relay is disabled during IBD
 			continue
@@ -108,8 +117,8 @@ func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) err
 	numHashesToRequest := mathUtil.MinInt(appmessage.MsgRequestRelayBlocksHashes, requestQueue.len())
 	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
 
-	pendingBlocks := map[daghash.Hash]struct{}{}
-	var filteredHashesToRequest []*daghash.Hash
+	pendingBlocks := map[externalapi.DomainHash]struct{}{}
+	var filteredHashesToRequest []*externalapi.DomainHash
 	for _, hash := range hashesToRequest {
 		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
 		if exists {
@@ -117,7 +126,11 @@ func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) err
 		}
 
 		// The block can become known from another peer in the process of orphan resolution
-		if flow.DAG().IsKnownBlock(hash) {
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(hash)
+		if err != nil {
+			return err
+		}
+		if blockInfo.Exists {
 			continue
 		}
 
@@ -146,11 +159,11 @@ func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) err
 			return err
 		}
 
-		block := util.NewBlock(msgBlock)
-		blockHash := block.Hash()
+		block := appmessage.MsgBlockToDomainBlock(msgBlock)
+		blockHash := consensusserialization.BlockHash(block)
 
 		if _, ok := pendingBlocks[*blockHash]; !ok {
-			return protocolerrors.Errorf(true, "got unrequested block %s", block.Hash())
+			return protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
 		}
 
 		err = flow.processAndRelayBlock(requestQueue, block)
@@ -187,45 +200,46 @@ 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) processAndRelayBlock(requestQueue *hashesQueueSet, block *externalapi.DomainBlock) error {
+	blockHash := consensusserialization.BlockHash(block)
+	err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
-		if !errors.As(err, &blockdag.RuleError{}) {
+		if !errors.As(err, &ruleerrors.RuleError{}) {
 			return errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
+
+		missingParentsError := &ruleerrors.ErrMissingParents{}
+		if errors.As(err, missingParentsError) {
+			blueScore, err := blocks.ExtractBlueScore(block)
+			if err != nil {
+				return protocolerrors.Errorf(true, "received an orphan "+
+					"block %s with malformed blue score", blockHash)
+			}
+
+			const maxOrphanBlueScoreDiff = 10000
+			virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+			if err != nil {
+				return err
+			}
+			selectedTipBlueScore, err := blocks.ExtractBlueScore(virtualSelectedParent)
+			if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
+				log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
+					"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
+					blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
+				return nil
+			}
+
+			// Request the parents for the orphan block from the peer that sent it.
+			for _, missingAncestor := range missingParentsError.MissingParentHashes {
+				requestQueue.enqueueIfNotExists(missingAncestor)
+			}
+			return nil
+		}
 		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
 
 		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
 
-	if isDelayed {
-		return nil
-	}
-
-	if isOrphan {
-		blueScore, err := block.BlueScore()
-		if err != nil {
-			return protocolerrors.Errorf(true, "received an orphan "+
-				"block %s with malformed blue score", blockHash)
-		}
-
-		const maxOrphanBlueScoreDiff = 10000
-		selectedTipBlueScore := flow.DAG().SelectedTipBlueScore()
-		if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
-			log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
-				"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
-				blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
-			return nil
-		}
-
-		// Request the parents for the orphan block from the peer that sent it.
-		missingAncestors := flow.DAG().GetOrphanMissingAncestorHashes(blockHash)
-		for _, missingAncestor := range missingAncestors {
-			requestQueue.enqueueIfNotExists(missingAncestor)
-		}
-		return nil
-	}
 	err = blocklogger.LogBlock(block)
 	if err != nil {
 		return err
@@ -235,7 +249,10 @@ func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueS
 		return err
 	}
 
-	flow.StartIBDIfRequired()
+	err = flow.StartIBDIfRequired()
+	if err != nil {
+		return err
+	}
 	err = flow.OnNewBlock(block)
 	if err != nil {
 		return err

app/protocol/flows/blockrelay/hashes_queue_set.go

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

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

@@ -4,11 +4,12 @@ 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"
 
@@ -23,9 +24,9 @@ import (
 type HandleHandshakeContext interface {
 	Config() *config.Config
 	NetAdapter() *netadapter.NetAdapter
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 	AddressManager() *addressmanager.AddressManager
-	StartIBDIfRequired()
+	StartIBDIfRequired() error
 	AddToPeers(peer *peerpkg.Peer) error
 	HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error)
 }
@@ -90,7 +91,10 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 		context.AddressManager().Good(peerAddress, subnetworkID)
 	}
 
-	context.StartIBDIfRequired()
+	err = context.StartIBDIfRequired()
+	if err != nil {
+		return nil, err
+	}
 
 	return peer, nil
 }

app/protocol/flows/handshake/receiveversion.go

@@ -72,7 +72,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 +84,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 != *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/domain/consensus/utils/consensusserialization"
 	"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,7 +48,11 @@ func SendVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *sendVersionFlow) start() error {
-	selectedTipHash := flow.DAG().SelectedTipHash()
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+	selectedTipHash := consensusserialization.BlockHash(virtualSelectedParent)
 	subnetworkID := flow.Config().SubnetworkID
 
 	// Version message.
@@ -64,7 +70,7 @@ func (flow *sendVersionFlow) start() error {
 	// Advertise if inv messages for transactions are desired.
 	msg.DisableRelayTx = flow.Config().BlocksOnly
 
-	err := flow.outgoingRoute.Enqueue(msg)
+	err = flow.outgoingRoute.Enqueue(msg)
 	if err != nil {
 		return err
 	}

app/protocol/flows/ibd/handle_request_block_locator.go

@@ -3,14 +3,14 @@ package ibd
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/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 {
@@ -37,7 +37,7 @@ func (flow *handleRequestBlockLocatorFlow) start() error {
 			return err
 		}
 
-		locator, err := flow.DAG().BlockLocatorFromHashes(highHash, lowHash)
+		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash)
 		if err != nil || len(locator) == 0 {
 			return protocolerrors.Errorf(true, "couldn't build a block "+
 				"locator between blocks %s and %s", lowHash, highHash)
@@ -50,8 +50,8 @@ 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, err error) {
 
 	message, err := flow.incomingRoute.Dequeue()
 	if err != nil {
@@ -62,7 +62,7 @@ func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *da
 	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, 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/ibd/handle_request_ibd_blocks.go

@@ -1,19 +1,19 @@
 package ibd
 
 import (
-	"errors"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"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/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 const ibdBatchSize = router.DefaultMaxMessages
 
 // RequestIBDBlocksContext is the interface for the context needed for the HandleRequestIBDBlocks flow.
 type RequestIBDBlocksContext interface {
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 }
 
 type handleRequestBlocksFlow struct {
@@ -78,8 +78,8 @@ func (flow *handleRequestBlocksFlow) start() error {
 	}
 }
 
-func receiveRequestIBDBlocks(incomingRoute *router.Route) (lowHash *daghash.Hash,
-	highHash *daghash.Hash, err error) {
+func receiveRequestIBDBlocks(incomingRoute *router.Route) (lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash, err error) {
 
 	message, err := incomingRoute.Dequeue()
 	if err != nil {
@@ -90,26 +90,25 @@ func receiveRequestIBDBlocks(incomingRoute *router.Route) (lowHash *daghash.Hash
 	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
 }
 
-func (flow *handleRequestBlocksFlow) buildMsgIBDBlocks(lowHash *daghash.Hash,
-	highHash *daghash.Hash) ([]*appmessage.MsgIBDBlock, error) {
+func (flow *handleRequestBlocksFlow) buildMsgIBDBlocks(lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash) ([]*appmessage.MsgIBDBlock, error) {
 
-	const maxHashesInMsgIBDBlocks = appmessage.MaxInvPerMsg
-	blockHashes, err := flow.DAG().AntiPastHashesBetween(lowHash, highHash, maxHashesInMsgIBDBlocks)
+	blockHashes, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash)
 	if err != nil {
-		if errors.Is(err, blockdag.ErrInvalidParameter) {
-			return nil, protocolerrors.Wrapf(true, err, "could not get antiPast between "+
-				"%s and %s", lowHash, highHash)
-		}
 		return nil, err
 	}
+	const maxHashesInMsgIBDBlocks = appmessage.MaxInvPerMsg
+	if len(blockHashes) > maxHashesInMsgIBDBlocks {
+		blockHashes = blockHashes[:maxHashesInMsgIBDBlocks]
+	}
 
 	msgIBDBlocks := make([]*appmessage.MsgIBDBlock, len(blockHashes))
 	for i, blockHash := range blockHashes {
-		block, err := flow.DAG().BlockByHash(blockHash)
+		block, err := flow.Domain().Consensus().GetBlock(blockHash)
 		if err != nil {
 			return nil, err
 		}
-		msgIBDBlocks[i] = appmessage.NewMsgIBDBlock(block.MsgBlock())
+		msgIBDBlocks[i] = appmessage.NewMsgIBDBlock(appmessage.DomainBlockToMsgBlock(block))
 	}
 
 	return msgIBDBlocks, nil

app/protocol/flows/ibd/ibd.go

@@ -6,19 +6,21 @@ 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/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/consensusserialization"
+	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/pkg/errors"
 )
 
 // HandleIBDContext is the interface for the context needed for the HandleIBD flow.
 type HandleIBDContext interface {
-	DAG() *blockdag.BlockDAG
-	OnNewBlock(block *util.Block) error
-	StartIBDIfRequired()
-	FinishIBD()
+	Domain() domain.Domain
+	Config() *config.Config
+	OnNewBlock(block *externalapi.DomainBlock) error
+	FinishIBD() error
 }
 
 type handleIBDFlow struct {
@@ -61,19 +63,14 @@ func (flow *handleIBDFlow) runIBD() error {
 	}
 
 	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-	if flow.DAG().IsKnownFinalizedBlock(highestSharedBlockHash) {
-		return protocolerrors.Errorf(false, "cannot initiate "+
-			"IBD with peer %s because the highest shared chain block (%s) is "+
-			"below the finality point", flow.peer, highestSharedBlockHash)
-	}
 
 	return flow.downloadBlocks(highestSharedBlockHash, peerSelectedTipHash)
 }
 
-func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *daghash.Hash) (lowHash *daghash.Hash,
+func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *externalapi.DomainHash) (lowHash *externalapi.DomainHash,
 	err error) {
 
-	lowHash = flow.DAG().Params.GenesisHash
+	lowHash = flow.Config().ActiveNetParams.GenesisHash
 	highHash := peerSelectedTipHash
 
 	for {
@@ -91,21 +88,28 @@ func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *dagha
 		// If it is, return it. If it isn't, we need to narrow our
 		// getBlockLocator request and try again.
 		locatorHighHash := blockLocatorHashes[0]
-		if flow.DAG().IsInDAG(locatorHighHash) {
+		locatorHighHashInfo, err := flow.Domain().Consensus().GetBlockInfo(locatorHighHash)
+		if err != nil {
+			return nil, err
+		}
+		if locatorHighHashInfo.Exists {
 			return locatorHighHash, nil
 		}
 
-		highHash, lowHash = flow.DAG().FindNextLocatorBoundaries(blockLocatorHashes)
+		highHash, lowHash, err = flow.Domain().Consensus().FindNextBlockLocatorBoundaries(blockLocatorHashes)
+		if err != nil {
+			return nil, err
+		}
 	}
 }
 
-func (flow *handleIBDFlow) sendGetBlockLocator(lowHash *daghash.Hash, highHash *daghash.Hash) error {
+func (flow *handleIBDFlow) sendGetBlockLocator(lowHash *externalapi.DomainHash, highHash *externalapi.DomainHash) error {
 
 	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, lowHash)
 	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
 }
 
-func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*daghash.Hash, err error) {
+func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err
@@ -119,8 +123,8 @@ func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*daghash.
 	return msgBlockLocator.BlockLocatorHashes, nil
 }
 
-func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *daghash.Hash,
-	peerSelectedTipHash *daghash.Hash) error {
+func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
 
 	err := flow.sendGetBlocks(highestSharedBlockHash, peerSelectedTipHash)
 	if err != nil {
@@ -153,8 +157,8 @@ func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *daghash.Hash,
 	}
 }
 
-func (flow *handleIBDFlow) sendGetBlocks(highestSharedBlockHash *daghash.Hash,
-	peerSelectedTipHash *daghash.Hash) error {
+func (flow *handleIBDFlow) sendGetBlocks(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
 
 	msgGetBlockInvs := appmessage.NewMsgRequstIBDBlocks(highestSharedBlockHash, peerSelectedTipHash)
 	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
@@ -178,27 +182,24 @@ func (flow *handleIBDFlow) receiveIBDBlock() (msgIBDBlock *appmessage.MsgIBDBloc
 }
 
 func (flow *handleIBDFlow) processIBDBlock(msgIBDBlock *appmessage.MsgIBDBlock) error {
-	block := util.NewBlock(msgIBDBlock.MsgBlock)
-	if flow.DAG().IsInDAG(block.Hash()) {
-		log.Debugf("IBD block %s is already in the DAG. Skipping...", block.Hash())
+	block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
+	blockHash := consensusserialization.BlockHash(block)
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
+	if err != nil {
+		return err
+	}
+	if blockInfo.Exists {
+		log.Debugf("IBD block %s is already in the DAG. Skipping...", blockHash)
 		return nil
 	}
-	isOrphan, isDelayed, err := flow.DAG().ProcessBlock(block, blockdag.BFNone)
+	err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
-		if !errors.As(err, &blockdag.RuleError{}) {
-			return errors.Wrapf(err, "failed to process block %s during IBD", block.Hash())
+		if !errors.As(err, &ruleerrors.RuleError{}) {
+			return errors.Wrapf(err, "failed to process block %s during IBD", blockHash)
 		}
-		log.Infof("Rejected block %s from %s during IBD: %s", block.Hash(), flow.peer, err)
+		log.Infof("Rejected block %s from %s during IBD: %s", blockHash, flow.peer, err)
 
-		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", block.Hash())
-	}
-	if isOrphan {
-		return protocolerrors.Errorf(true, "received orphan block %s "+
-			"during IBD", block.Hash())
-	}
-	if isDelayed {
-		return protocolerrors.Errorf(false, "received delayed block %s "+
-			"during IBD", block.Hash())
+		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
 	}
 	err = flow.OnNewBlock(block)
 	if err != nil {

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

@@ -2,14 +2,15 @@ package selectedtip
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
 
 // HandleRequestSelectedTipContext is the interface for the context needed for the HandleRequestSelectedTip flow.
 type HandleRequestSelectedTipContext interface {
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 }
 
 type handleRequestSelectedTipFlow struct {
@@ -56,6 +57,10 @@ func (flow *handleRequestSelectedTipFlow) receiveGetSelectedTip() error {
 }
 
 func (flow *handleRequestSelectedTipFlow) sendSelectedTipHash() error {
-	msgSelectedTip := appmessage.NewMsgSelectedTip(flow.DAG().SelectedTipHash())
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+	msgSelectedTip := appmessage.NewMsgSelectedTip(consensusserialization.BlockHash(virtualSelectedParent))
 	return flow.outgoingRoute.Enqueue(msgSelectedTip)
 }

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

@@ -4,15 +4,15 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util/daghash"
 )
 
 // RequestSelectedTipContext is the interface for the context needed for the RequestSelectedTip flow.
 type RequestSelectedTipContext interface {
-	DAG() *blockdag.BlockDAG
-	StartIBDIfRequired()
+	Domain() domain.Domain
+	StartIBDIfRequired() error
 }
 
 type requestSelectedTipFlow struct {
@@ -59,8 +59,7 @@ func (flow *requestSelectedTipFlow) runSelectedTipRequest() error {
 	}
 
 	flow.peer.SetSelectedTipHash(peerSelectedTipHash)
-	flow.StartIBDIfRequired()
-	return nil
+	return flow.StartIBDIfRequired()
 }
 
 func (flow *requestSelectedTipFlow) requestSelectedTip() error {
@@ -68,7 +67,7 @@ func (flow *requestSelectedTipFlow) requestSelectedTip() error {
 	return flow.outgoingRoute.Enqueue(msgGetSelectedTip)
 }
 
-func (flow *requestSelectedTipFlow) receiveSelectedTip() (selectedTipHash *daghash.Hash, err error) {
+func (flow *requestSelectedTipFlow) receiveSelectedTip() (selectedTipHash *externalapi.DomainHash, err error) {
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err

app/protocol/flows/relaytransactions/handle_relayed_transactions.go

@@ -4,12 +4,12 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/blockdag"
-	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/pkg/errors"
 )
 
@@ -17,10 +17,10 @@ import (
 // HandleRelayedTransactions and HandleRequestedTransactions flows.
 type TransactionsRelayContext interface {
 	NetAdapter() *netadapter.NetAdapter
-	DAG() *blockdag.BlockDAG
+	Domain() domain.Domain
 	SharedRequestedTransactions() *SharedRequestedTransactions
-	TxPool() *mempool.TxPool
 	Broadcast(message appmessage.Message) error
+	OnTransactionAddedToMempool()
 }
 
 type handleRelayedTransactionsFlow struct {
@@ -61,9 +61,9 @@ func (flow *handleRelayedTransactionsFlow) start() error {
 }
 
 func (flow *handleRelayedTransactionsFlow) requestInvTransactions(
-	inv *appmessage.MsgInvTransaction) (requestedIDs []*daghash.TxID, err error) {
+	inv *appmessage.MsgInvTransaction) (requestedIDs []*externalapi.DomainTransactionID, err error) {
 
-	idsToRequest := make([]*daghash.TxID, 0, len(inv.TxIDs))
+	idsToRequest := make([]*externalapi.DomainTransactionID, 0, len(inv.TxIDs))
 	for _, txID := range inv.TxIDs {
 		if flow.isKnownTransaction(txID) {
 			continue
@@ -88,29 +88,13 @@ func (flow *handleRelayedTransactionsFlow) requestInvTransactions(
 	return idsToRequest, nil
 }
 
-func (flow *handleRelayedTransactionsFlow) isKnownTransaction(txID *daghash.TxID) bool {
+func (flow *handleRelayedTransactionsFlow) isKnownTransaction(txID *externalapi.DomainTransactionID) bool {
 	// Ask the transaction memory pool if the transaction is known
 	// to it in any form (main pool or orphan).
-	if flow.TxPool().HaveTransaction(txID) {
+	if _, ok := flow.Domain().MiningManager().GetTransaction(txID); ok {
 		return true
 	}
 
-	// Check if the transaction exists from the point of view of the
-	// DAG's virtual block. Note that this is only a best effort
-	// since it is expensive to check existence of every output and
-	// the only purpose of this check is to avoid downloading
-	// already known transactions. Only the first two outputs are
-	// checked because the vast majority of transactions consist of
-	// two outputs where one is some form of "pay-to-somebody-else"
-	// and the other is a change output.
-	prevOut := appmessage.Outpoint{TxID: *txID}
-	for i := uint32(0); i < 2; i++ {
-		prevOut.Index = i
-		_, ok := flow.DAG().GetUTXOEntry(prevOut)
-		if ok {
-			return true
-		}
-	}
 	return false
 }
 
@@ -134,12 +118,8 @@ func (flow *handleRelayedTransactionsFlow) readInv() (*appmessage.MsgInvTransact
 	return inv, nil
 }
 
-func (flow *handleRelayedTransactionsFlow) broadcastAcceptedTransactions(acceptedTxs []*mempool.TxDesc) error {
-	idsToBroadcast := make([]*daghash.TxID, len(acceptedTxs))
-	for i, tx := range acceptedTxs {
-		idsToBroadcast[i] = tx.Tx.ID()
-	}
-	inv := appmessage.NewMsgInvTransaction(idsToBroadcast)
+func (flow *handleRelayedTransactionsFlow) broadcastAcceptedTransactions(acceptedTxIDs []*externalapi.DomainTransactionID) error {
+	inv := appmessage.NewMsgInvTransaction(acceptedTxIDs)
 	return flow.Broadcast(inv)
 }
 
@@ -169,7 +149,7 @@ func (flow *handleRelayedTransactionsFlow) readMsgTxOrNotFound() (
 	}
 }
 
-func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransactions []*daghash.TxID) error {
+func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransactions []*externalapi.DomainTransactionID) error {
 	// In case the function returns earlier than expected, we want to make sure sharedRequestedTransactions is
 	// clean from any pending transactions.
 	defer flow.SharedRequestedTransactions().removeMany(requestedTransactions)
@@ -179,45 +159,45 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 			return err
 		}
 		if msgTxNotFound != nil {
-			if !msgTxNotFound.ID.IsEqual(expectedID) {
+			if msgTxNotFound.ID != expectedID {
 				return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
 					expectedID, msgTxNotFound.ID)
 			}
 
 			continue
 		}
-		tx := util.NewTx(msgTx)
-		if !tx.ID().IsEqual(expectedID) {
+		tx := appmessage.MsgTxToDomainTransaction(msgTx)
+		txID := consensusserialization.TransactionID(tx)
+		if txID != expectedID {
 			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
-				expectedID, tx.ID())
+				expectedID, txID)
 		}
 
-		acceptedTxs, err := flow.TxPool().ProcessTransaction(tx, true)
+		err = flow.Domain().MiningManager().ValidateAndInsertTransaction(tx, true)
 		if err != nil {
 			ruleErr := &mempool.RuleError{}
 			if !errors.As(err, ruleErr) {
-				return errors.Wrapf(err, "failed to process transaction %s", tx.ID())
+				return errors.Wrapf(err, "failed to process transaction %s", txID)
 			}
 
-			shouldBan := false
+			shouldBan := true
 			if txRuleErr := (&mempool.TxRuleError{}); errors.As(ruleErr.Err, txRuleErr) {
-				if txRuleErr.RejectCode == mempool.RejectInvalid {
-					shouldBan = true
+				if txRuleErr.RejectCode != mempool.RejectInvalid {
+					shouldBan = false
 				}
-			} else if dagRuleErr := (&blockdag.RuleError{}); errors.As(ruleErr.Err, dagRuleErr) {
-				shouldBan = true
 			}
 
 			if !shouldBan {
 				continue
 			}
 
-			return protocolerrors.Errorf(true, "rejected transaction %s", tx.ID())
+			return protocolerrors.Errorf(true, "rejected transaction %s", txID)
 		}
-		err = flow.broadcastAcceptedTransactions(acceptedTxs)
+		err = flow.broadcastAcceptedTransactions([]*externalapi.DomainTransactionID{txID})
 		if err != nil {
 			return err
 		}
+		flow.OnTransactionAddedToMempool()
 	}
 	return nil
 }

app/protocol/flows/relaytransactions/handle_requested_transactions.go

@@ -30,7 +30,7 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 		}
 
 		for _, transactionID := range msgRequestTransactions.IDs {
-			tx, ok := flow.TxPool().FetchTransaction(transactionID)
+			tx, ok := flow.Domain().MiningManager().GetTransaction(transactionID)
 
 			if !ok {
 				msgTransactionNotFound := appmessage.NewMsgTransactionNotFound(transactionID)
@@ -41,7 +41,7 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 				continue
 			}
 
-			err := flow.outgoingRoute.Enqueue(tx.MsgTx())
+			err := flow.outgoingRoute.Enqueue(appmessage.DomainTransactionToMsgTx(tx))
 			if err != nil {
 				return err
 			}