Stop using big.Int to compare hashes (#912)

* Add a benchmark for Hash.Cmp()

* Compare hashes directly without going through big.Int

* Add a more thorough test for Hash.Cmp()

app/app.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol"
+	"github.com/kaspanet/kaspad/app/rpc"
 	"github.com/kaspanet/kaspad/domain/blockdag"
 	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
 	"github.com/kaspanet/kaspad/domain/mempool"
@@ -20,8 +21,6 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc"
-	"github.com/kaspanet/kaspad/infrastructure/os/signal"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/panics"
 )
@@ -29,9 +28,9 @@ import (
 // App is a wrapper for all the kaspad services
 type App struct {
 	cfg               *config.Config
-	rpcServer         *rpc.Server
 	addressManager    *addressmanager.AddressManager
 	protocolManager   *protocol.Manager
+	rpcManager        *rpc.Manager
 	connectionManager *connmanager.ConnectionManager
 	netAdapter        *netadapter.NetAdapter
 
@@ -47,18 +46,14 @@ func (a *App) Start() {
 
 	log.Trace("Starting kaspad")
 
-	err := a.protocolManager.Start()
+	err := a.netAdapter.Start()
 	if err != nil {
-		panics.Exit(log, fmt.Sprintf("Error starting the p2p protocol: %+v", err))
+		panics.Exit(log, fmt.Sprintf("Error starting the net adapter: %+v", err))
 	}
 
 	a.maybeSeedFromDNS()
 
 	a.connectionManager.Start()
-
-	if !a.cfg.DisableRPC {
-		a.rpcServer.Start()
-	}
 }
 
 // Stop gracefully shuts down all the kaspad services.
@@ -73,17 +68,9 @@ func (a *App) Stop() {
 
 	a.connectionManager.Stop()
 
-	err := a.protocolManager.Stop()
+	err := a.netAdapter.Stop()
 	if err != nil {
-		log.Errorf("Error stopping the p2p protocol: %+v", err)
-	}
-
-	// Shutdown the RPC server if it's not disabled.
-	if !a.cfg.DisableRPC {
-		err := a.rpcServer.Stop()
-		if err != nil {
-			log.Errorf("Error stopping rpcServer: %+v", err)
-		}
+		log.Errorf("Error stopping the net adapter: %+v", err)
 	}
 
 	err = a.addressManager.Stop()
@@ -126,22 +113,56 @@ func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrup
 	if err != nil {
 		return nil, err
 	}
-	rpcServer, err := setupRPC(
-		cfg, dag, txMempool, sigCache, acceptanceIndex, connectionManager, addressManager, protocolManager)
-	if err != nil {
-		return nil, err
-	}
+	rpcManager := setupRPC(cfg, txMempool, dag, sigCache, netAdapter, protocolManager, connectionManager, addressManager, acceptanceIndex)
 
 	return &App{
 		cfg:               cfg,
-		rpcServer:         rpcServer,
 		protocolManager:   protocolManager,
+		rpcManager:        rpcManager,
 		connectionManager: connectionManager,
 		netAdapter:        netAdapter,
 		addressManager:    addressManager,
 	}, nil
 }
 
+func setupRPC(
+	cfg *config.Config,
+	txMempool *mempool.TxPool,
+	dag *blockdag.BlockDAG,
+	sigCache *txscript.SigCache,
+	netAdapter *netadapter.NetAdapter,
+	protocolManager *protocol.Manager,
+	connectionManager *connmanager.ConnectionManager,
+	addressManager *addressmanager.AddressManager,
+	acceptanceIndex *indexers.AcceptanceIndex) *rpc.Manager {
+
+	blockTemplateGenerator := mining.NewBlkTmplGenerator(&mining.Policy{BlockMaxMass: cfg.BlockMaxMass}, txMempool, dag, sigCache)
+	rpcManager := rpc.NewManager(cfg, netAdapter, dag, protocolManager, connectionManager, blockTemplateGenerator, txMempool, addressManager, acceptanceIndex)
+	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
+	protocolManager.SetOnTransactionAddedToMempoolHandler(rpcManager.NotifyTransactionAddedToMempool)
+	dag.Subscribe(func(notification *blockdag.Notification) {
+		err := handleBlockDAGNotifications(notification, acceptanceIndex, rpcManager)
+		if err != nil {
+			panic(err)
+		}
+	})
+	return rpcManager
+}
+
+func handleBlockDAGNotifications(notification *blockdag.Notification,
+	acceptanceIndex *indexers.AcceptanceIndex, rpcManager *rpc.Manager) error {
+
+	if notification.Type == blockdag.NTChainChanged && acceptanceIndex != nil {
+		chainChangedNotificationData := notification.Data.(*blockdag.ChainChangedNotificationData)
+		err := rpcManager.NotifyChainChanged(chainChangedNotificationData.RemovedChainBlockHashes,
+			chainChangedNotificationData.AddedChainBlockHashes)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (a *App) maybeSeedFromDNS() {
 	if !a.cfg.DisableDNSSeed {
 		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
@@ -152,6 +173,13 @@ func (a *App) maybeSeedFromDNS() {
 				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)
+			})
+	}
 }
 func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{},
 	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
@@ -205,38 +233,6 @@ func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript
 	return mempool.New(&mempoolConfig)
 }
 
-func setupRPC(cfg *config.Config,
-	dag *blockdag.BlockDAG,
-	txMempool *mempool.TxPool,
-	sigCache *txscript.SigCache,
-	acceptanceIndex *indexers.AcceptanceIndex,
-	connectionManager *connmanager.ConnectionManager,
-	addressManager *addressmanager.AddressManager,
-	protocolManager *protocol.Manager) (*rpc.Server, error) {
-
-	if !cfg.DisableRPC {
-		policy := mining.Policy{
-			BlockMaxMass: cfg.BlockMaxMass,
-		}
-		blockTemplateGenerator := mining.NewBlkTmplGenerator(&policy, txMempool, dag, sigCache)
-
-		rpcServer, err := rpc.NewRPCServer(cfg, dag, txMempool, acceptanceIndex, blockTemplateGenerator,
-			connectionManager, addressManager, protocolManager)
-		if err != nil {
-			return nil, err
-		}
-
-		// Signal process shutdown when the RPC server requests it.
-		spawn("setupRPC-handleShutdownRequest", func() {
-			<-rpcServer.RequestedProcessShutdown()
-			signal.ShutdownRequestChannel <- struct{}{}
-		})
-
-		return rpcServer, nil
-	}
-	return nil, nil
-}
-
 // P2PNodeID returns the network ID associated with this App
 func (a *App) P2PNodeID() *id.ID {
 	return a.netAdapter.ID()

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

@@ -17,7 +17,10 @@ const MaxMessagePayload = (1024 * 1024 * 32) // 32MB
 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,49 @@ 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
 )
 
-// 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 +119,47 @@ 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",
+}
+
 // 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/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,123 @@
+package appmessage
+
+// GetBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockRequestMessage struct {
+	baseMessage
+	Hash                          string
+	SubnetworkID                  string
+	IncludeBlockHex               bool
+	IncludeBlockVerboseData       bool
+	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, includeBlockHex bool,
+	includeBlockVerboseData bool, includeTransactionVerboseData bool) *GetBlockRequestMessage {
+	return &GetBlockRequestMessage{
+		Hash:                          hash,
+		SubnetworkID:                  subnetworkID,
+		IncludeBlockHex:               includeBlockHex,
+		IncludeBlockVerboseData:       includeBlockVerboseData,
+		IncludeTransactionVerboseData: includeTransactionVerboseData,
+	}
+}
+
+// GetBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockResponseMessage struct {
+	baseMessage
+	BlockHex         string
+	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
+	Confirmations          uint64
+	Size                   int32
+	BlueScore              uint64
+	IsChainBlock           bool
+	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
+	ChildHashes            []string
+	AcceptedBlockHashes    []string
+}
+
+// TransactionVerboseData holds verbose data about a transaction
+type TransactionVerboseData struct {
+	Hex                       string
+	TxID                      string
+	Hash                      string
+	Size                      int32
+	Version                   int32
+	LockTime                  uint64
+	SubnetworkID              string
+	Gas                       uint64
+	PayloadHash               string
+	Payload                   string
+	TransactionVerboseInputs  []*TransactionVerboseInput
+	TransactionVerboseOutputs []*TransactionVerboseOutput
+	BlockHash                 string
+	AcceptedBy                string
+	IsInMempool               bool
+	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,40 @@
+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
+	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,78 @@
+package appmessage
+
+// GetBlockTemplateRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateRequestMessage struct {
+	baseMessage
+	PayAddress string
+	LongPollID 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, longPollID string) *GetBlockTemplateRequestMessage {
+	return &GetBlockTemplateRequestMessage{
+		PayAddress: payAddress,
+		LongPollID: longPollID,
+	}
+}
+
+// GetBlockTemplateResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateResponseMessage struct {
+	baseMessage
+	Bits                 string
+	CurrentTime          int64
+	ParentHashes         []string
+	MassLimit            int
+	Transactions         []GetBlockTemplateTransactionMessage
+	HashMerkleRoot       string
+	AcceptedIDMerkleRoot string
+	UTXOCommitment       string
+	Version              int32
+	LongPollID           string
+	TargetDifficulty     string
+	MinTime              int64
+	MaxTime              int64
+	MutableFields        []string
+	NonceRange           string
+	IsSynced             bool
+	IsConnected          bool
+
+	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() *GetBlockTemplateResponseMessage {
+	return &GetBlockTemplateResponseMessage{}
+}
+
+// GetBlockTemplateTransactionMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateTransactionMessage struct {
+	baseMessage
+	Data    string
+	ID      string
+	Depends []int64
+	Mass    uint64
+	Fee     uint64
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockTemplateTransactionMessage) Command() MessageCommand {
+	return CmdGetBlockTemplateTransactionMessage
+}
+
+// NewGetBlockTemplateTransactionMessage returns a instance of the message
+func NewGetBlockTemplateTransactionMessage() *GetBlockTemplateTransactionMessage {
+	return &GetBlockTemplateTransactionMessage{}
+}

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

@@ -0,0 +1,35 @@
+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
+	Error *RPCError
+}
+
+// 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() *GetMempoolEntryResponseMessage {
+	return &GetMempoolEntryResponseMessage{}
+}

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

@@ -0,0 +1,37 @@
+package appmessage
+
+// SubmitBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type SubmitBlockRequestMessage struct {
+	baseMessage
+	BlockHex string
+}
+
+// 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(blockHex string) *SubmitBlockRequestMessage {
+	return &SubmitBlockRequestMessage{
+		BlockHex: blockHex,
+	}
+}
+
+// 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
+	TransactionHex string
+}
+
+// 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(transactionHex string) *SubmitTransactionRequestMessage {
+	return &SubmitTransactionRequestMessage{
+		TransactionHex: transactionHex,
+	}
+}
+
+// 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/protocol/flowcontext/blocks.go

@@ -18,6 +18,9 @@ func (f *FlowContext) OnNewBlock(block *util.Block) error {
 	if err != nil {
 		return err
 	}
+	if f.onBlockAddedToDAGHandler != nil {
+		f.onBlockAddedToDAGHandler(block)
+	}
 
 	return f.broadcastTransactionsAfterBlockAdded(block, transactionsAcceptedToMempool)
 }

app/protocol/flowcontext/errors.go

@@ -22,7 +22,7 @@ func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32,
 			panic(err)
 		}
 
-		log.Errorf("error from %s: %s", flowName, err)
+		log.Errorf("error from %s: %+v", flowName, err)
 	}
 
 	if atomic.AddUint32(isStopping, 1) == 1 {

app/protocol/flowcontext/flow_context.go

@@ -18,6 +18,14 @@ import (
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
+// OnBlockAddedToDAGHandler is a handler function that's triggered
+// when a block is added to the DAG
+type OnBlockAddedToDAGHandler func(block *util.Block)
+
+// 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 {
@@ -28,6 +36,9 @@ type FlowContext struct {
 	addressManager    *addressmanager.AddressManager
 	connectionManager *connmanager.ConnectionManager
 
+	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
+	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
+
 	transactionsToRebroadcastLock sync.Mutex
 	transactionsToRebroadcast     map[daghash.TxID]*util.Tx
 	lastRebroadcastTime           time.Time
@@ -61,3 +72,13 @@ func New(cfg *config.Config, dag *blockdag.BlockDAG, addressManager *addressmana
 		transactionsToRebroadcast:   make(map[daghash.TxID]*util.Tx),
 	}
 }
+
+// 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/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

@@ -26,7 +26,6 @@ func (f *FlowContext) AddTransaction(tx *util.Tx) error {
 
 	f.transactionsToRebroadcast[*tx.ID()] = tx
 	inv := appmessage.NewMsgInvTransaction([]*daghash.TxID{tx.ID()})
-	log.Criticalf("~~~~~ FlowContext.AddTransaction() broadcasting %s", tx.ID())
 	return f.Broadcast(inv)
 }
 
@@ -69,3 +68,11 @@ func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedReq
 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/relaytransactions/handle_relayed_transactions.go

@@ -21,6 +21,7 @@ type TransactionsRelayContext interface {
 	SharedRequestedTransactions() *SharedRequestedTransactions
 	TxPool() *mempool.TxPool
 	Broadcast(message appmessage.Message) error
+	OnTransactionAddedToMempool()
 }
 
 type handleRelayedTransactionsFlow struct {
@@ -48,10 +49,6 @@ func (flow *handleRelayedTransactionsFlow) start() error {
 			return err
 		}
 
-		for _, txID := range inv.TxIDs {
-			log.Criticalf("~~~~~ handleRelayedTransactionsFlow.start() got %s", txID)
-		}
-
 		requestedIDs, err := flow.requestInvTransactions(inv)
 		if err != nil {
 			return err
@@ -141,7 +138,6 @@ func (flow *handleRelayedTransactionsFlow) readInv() (*appmessage.MsgInvTransact
 func (flow *handleRelayedTransactionsFlow) broadcastAcceptedTransactions(acceptedTxs []*mempool.TxDesc) error {
 	idsToBroadcast := make([]*daghash.TxID, len(acceptedTxs))
 	for i, tx := range acceptedTxs {
-		log.Criticalf("~~~~~ broadcastAcceptedTransactions() broadcasting %s", tx.Tx.ID())
 		idsToBroadcast[i] = tx.Tx.ID()
 	}
 	inv := appmessage.NewMsgInvTransaction(idsToBroadcast)
@@ -192,7 +188,6 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 			continue
 		}
 		tx := util.NewTx(msgTx)
-		log.Criticalf("~~~~~ receiveTransactions() got %s", tx.ID())
 		if !tx.ID().IsEqual(expectedID) {
 			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
 				expectedID, tx.ID())
@@ -224,6 +219,7 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 		if err != nil {
 			return err
 		}
+		flow.OnTransactionAddedToMempool()
 	}
 	return nil
 }

app/protocol/flows/relaytransactions/handle_requested_transactions.go

@@ -30,7 +30,6 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 		}
 
 		for _, transactionID := range msgRequestTransactions.IDs {
-			log.Criticalf("~~~~~ handleRequestedTransactionsFlow.start() tx %s was requested", transactionID)
 			tx, ok := flow.TxPool().FetchTransaction(transactionID)
 
 			if !ok {

app/protocol/manager.go

@@ -27,20 +27,10 @@ func NewManager(cfg *config.Config, dag *blockdag.BlockDAG, netAdapter *netadapt
 	manager := Manager{
 		context: flowcontext.New(cfg, dag, addressManager, txPool, netAdapter, connectionManager),
 	}
-	netAdapter.SetRouterInitializer(manager.routerInitializer)
+	netAdapter.SetP2PRouterInitializer(manager.routerInitializer)
 	return &manager, nil
 }
 
-// Start starts the p2p protocol
-func (m *Manager) Start() error {
-	return m.context.NetAdapter().Start()
-}
-
-// Stop stops the p2p protocol
-func (m *Manager) Stop() error {
-	return m.context.NetAdapter().Stop()
-}
-
 // Peers returns the currently active peers
 func (m *Manager) Peers() []*peerpkg.Peer {
 	return m.context.Peers()
@@ -72,3 +62,13 @@ func (m *Manager) runFlows(flows []*flow, peer *peerpkg.Peer, errChan <-chan err
 
 	return <-errChan
 }
+
+// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
+func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowcontext.OnBlockAddedToDAGHandler) {
+	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
+}
+
+// SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
+func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler flowcontext.OnTransactionAddedToMempoolHandler) {
+	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)
+}

app/rpc/log.go

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

app/rpc/manager.go

@@ -0,0 +1,80 @@
+package rpc
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"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/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// Manager is an RPC manager
+type Manager struct {
+	context *rpccontext.Context
+}
+
+// NewManager creates a new RPC Manager
+func NewManager(
+	cfg *config.Config,
+	netAdapter *netadapter.NetAdapter,
+	dag *blockdag.BlockDAG,
+	protocolManager *protocol.Manager,
+	connectionManager *connmanager.ConnectionManager,
+	blockTemplateGenerator *mining.BlkTmplGenerator,
+	mempool *mempool.TxPool,
+	addressManager *addressmanager.AddressManager,
+	acceptanceIndex *indexers.AcceptanceIndex) *Manager {
+
+	manager := Manager{
+		context: rpccontext.NewContext(
+			cfg,
+			netAdapter,
+			dag,
+			protocolManager,
+			connectionManager,
+			blockTemplateGenerator,
+			mempool,
+			addressManager,
+			acceptanceIndex,
+		),
+	}
+	netAdapter.SetRPCRouterInitializer(manager.routerInitializer)
+
+	return &manager
+}
+
+// NotifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
+func (m *Manager) NotifyBlockAddedToDAG(block *util.Block) {
+	m.context.BlockTemplateState.NotifyBlockAdded(block)
+
+	notification := appmessage.NewBlockAddedNotificationMessage(block.MsgBlock())
+	m.context.NotificationManager.NotifyBlockAdded(notification)
+}
+
+// NotifyChainChanged notifies the manager that the DAG's selected parent chain has changed
+func (m *Manager) NotifyChainChanged(removedChainBlockHashes []*daghash.Hash, addedChainBlockHashes []*daghash.Hash) error {
+	addedChainBlocks, err := m.context.CollectChainBlocks(addedChainBlockHashes)
+	if err != nil {
+		return err
+	}
+	removedChainBlockHashStrings := make([]string, len(removedChainBlockHashes))
+	for i, removedChainBlockHash := range removedChainBlockHashes {
+		removedChainBlockHashStrings[i] = removedChainBlockHash.String()
+	}
+	notification := appmessage.NewChainChangedNotificationMessage(removedChainBlockHashStrings, addedChainBlocks)
+	m.context.NotificationManager.NotifyChainChanged(notification)
+	return nil
+}
+
+// NotifyTransactionAddedToMempool notifies the manager that a transaction has been added to the mempool
+func (m *Manager) NotifyTransactionAddedToMempool() {
+	m.context.BlockTemplateState.NotifyMempoolTx()
+}

app/rpc/rpc.go

@@ -0,0 +1,98 @@
+package rpc
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/app/rpc/rpchandlers"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+type handler func(context *rpccontext.Context, router *router.Router, request appmessage.Message) (appmessage.Message, error)
+
+var handlers = map[appmessage.MessageCommand]handler{
+	appmessage.CmdGetCurrentNetworkRequestMessage:    rpchandlers.HandleGetCurrentNetwork,
+	appmessage.CmdSubmitBlockRequestMessage:          rpchandlers.HandleSubmitBlock,
+	appmessage.CmdGetBlockTemplateRequestMessage:     rpchandlers.HandleGetBlockTemplate,
+	appmessage.CmdNotifyBlockAddedRequestMessage:     rpchandlers.HandleNotifyBlockAdded,
+	appmessage.CmdGetPeerAddressesRequestMessage:     rpchandlers.HandleGetPeerAddresses,
+	appmessage.CmdGetSelectedTipHashRequestMessage:   rpchandlers.HandleGetSelectedTipHash,
+	appmessage.CmdGetMempoolEntryRequestMessage:      rpchandlers.HandleGetMempoolEntry,
+	appmessage.CmdGetConnectedPeerInfoRequestMessage: rpchandlers.HandleGetConnectedPeerInfo,
+	appmessage.CmdAddPeerRequestMessage:              rpchandlers.HandleAddPeer,
+	appmessage.CmdSubmitTransactionRequestMessage:    rpchandlers.HandleSubmitTransaction,
+	appmessage.CmdNotifyChainChangedRequestMessage:   rpchandlers.HandleNotifyChainChanged,
+	appmessage.CmdGetBlockRequestMessage:             rpchandlers.HandleGetBlock,
+	appmessage.CmdGetSubnetworkRequestMessage:        rpchandlers.HandleGetSubnetwork,
+	appmessage.CmdGetChainFromBlockRequestMessage:    rpchandlers.HandleGetChainFromBlock,
+	appmessage.CmdGetBlocksRequestMessage:            rpchandlers.HandleGetBlocks,
+	appmessage.CmdGetBlockCountRequestMessage:        rpchandlers.HandleGetBlockCount,
+	appmessage.CmdGetBlockDAGInfoRequestMessage:      rpchandlers.HandleGetBlockDAGInfo,
+}
+
+func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {
+	messageTypes := make([]appmessage.MessageCommand, 0, len(handlers))
+	for messageType := range handlers {
+		messageTypes = append(messageTypes, messageType)
+	}
+	incomingRoute, err := router.AddIncomingRoute(messageTypes)
+	if err != nil {
+		panic(err)
+	}
+	spawn("routerInitializer-handleIncomingMessages", func() {
+		err := m.handleIncomingMessages(router, incomingRoute)
+		m.handleError(err, netConnection)
+	})
+
+	notificationListener := m.context.NotificationManager.AddListener(router)
+	spawn("routerInitializer-handleOutgoingNotifications", func() {
+		defer m.context.NotificationManager.RemoveListener(router)
+
+		err := m.handleOutgoingNotifications(notificationListener)
+		m.handleError(err, netConnection)
+	})
+}
+
+func (m *Manager) handleIncomingMessages(router *router.Router, incomingRoute *router.Route) error {
+	outgoingRoute := router.OutgoingRoute()
+	for {
+		request, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		handler, ok := handlers[request.Command()]
+		if !ok {
+			return err
+		}
+		response, err := handler(m.context, router, request)
+		if err != nil {
+			return err
+		}
+		err = outgoingRoute.Enqueue(response)
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (m *Manager) handleOutgoingNotifications(notificationListener *rpccontext.NotificationListener) error {
+	for {
+		err := notificationListener.ProcessNextNotification()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (m *Manager) handleError(err error, netConnection *netadapter.NetConnection) {
+	if errors.Is(err, router.ErrTimeout) {
+		log.Warnf("Got timeout from %s. Disconnecting...", netConnection)
+		netConnection.Disconnect()
+		return
+	}
+	if errors.Is(err, router.ErrRouteClosed) {
+		return
+	}
+	panic(err)
+}

app/rpc/rpccontext/blocktemplate.go

@@ -0,0 +1,476 @@
+package rpccontext
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain/mining"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/random"
+	"github.com/pkg/errors"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	// blockTemplateNonceRange is two 64-bit big-endian hexadecimal integers which
+	// represent the valid ranges of nonces returned by the getBlockTemplate
+	// RPC.
+	blockTemplateNonceRange = "000000000000ffffffffffff"
+
+	// blockTemplateRegenerateSeconds is the number of seconds that must pass before
+	// a new template is generated when the parent block hashes has not
+	// changed and there have been changes to the available transactions
+	// in the memory pool.
+	blockTemplateRegenerateSeconds = 60
+)
+
+var (
+	// blockTemplateMutableFields are the manipulations the server allows to be made
+	// to block templates generated by the getBlockTemplate RPC. It is
+	// declared here to avoid the overhead of creating the slice on every
+	// invocation for constant data.
+	blockTemplateMutableFields = []string{
+		"time", "transactions/add", "parentblock", "coinbase/append",
+	}
+)
+
+// BlockTemplateState houses state that is used in between multiple RPC invocations to
+// getBlockTemplate.
+type BlockTemplateState struct {
+	sync.Mutex
+
+	context *Context
+
+	lastTxUpdate  mstime.Time
+	lastGenerated mstime.Time
+	tipHashes     []*daghash.Hash
+	minTimestamp  mstime.Time
+	template      *mining.BlockTemplate
+	notifyMap     map[string]map[int64]chan struct{}
+	payAddress    util.Address
+}
+
+// NewBlockTemplateState returns a new instance of a BlockTemplateState with all internal
+// fields initialized and ready to use.
+func NewBlockTemplateState(context *Context) *BlockTemplateState {
+	return &BlockTemplateState{
+		context:   context,
+		notifyMap: make(map[string]map[int64]chan struct{}),
+	}
+}
+
+// Update updates the block template state
+func (bt *BlockTemplateState) Update(payAddress util.Address) error {
+	generator := bt.context.BlockTemplateGenerator
+	lastTxUpdate := generator.TxSource().LastUpdated()
+	if lastTxUpdate.IsZero() {
+		lastTxUpdate = mstime.Now()
+	}
+
+	// Generate a new block template when the current best block has
+	// changed or the transactions in the memory pool have been updated and
+	// it has been at least gbtRegenerateSecond since the last template was
+	// generated.
+	var msgBlock *appmessage.MsgBlock
+	var targetDifficulty string
+	tipHashes := bt.context.DAG.TipHashes()
+	template := bt.template
+	if template == nil || bt.tipHashes == nil ||
+		!daghash.AreEqual(bt.tipHashes, tipHashes) ||
+		bt.payAddress.String() != payAddress.String() ||
+		(bt.lastTxUpdate != lastTxUpdate &&
+			mstime.Now().After(bt.lastGenerated.Add(time.Second*
+				blockTemplateRegenerateSeconds))) {
+
+		// Reset the previous best hash the block template was generated
+		// against so any errors below cause the next invocation to try
+		// again.
+		bt.tipHashes = nil
+
+		// Create a new block template that has a coinbase which anyone
+		// can redeem. This is only acceptable because the returned
+		// block template doesn't include the coinbase, so the caller
+		// will ultimately create their own coinbase which pays to the
+		// appropriate address(es).
+
+		extraNonce, err := random.Uint64()
+		if err != nil {
+			return errors.Wrapf(err, "failed to randomize extra nonce")
+		}
+
+		blockTemplate, err := generator.NewBlockTemplate(payAddress, extraNonce)
+		if err != nil {
+			return errors.Wrapf(err, "failed to create new block template")
+		}
+		template = blockTemplate
+		msgBlock = template.Block
+		targetDifficulty = fmt.Sprintf("%064x", util.CompactToBig(msgBlock.Header.Bits))
+
+		// Get the minimum allowed timestamp for the block based on the
+		// median timestamp of the last several blocks per the DAG
+		// consensus rules.
+		minTimestamp := bt.context.DAG.NextBlockMinimumTime()
+
+		// Update work state to ensure another block template isn't
+		// generated until needed.
+		bt.template = template
+		bt.lastGenerated = mstime.Now()
+		bt.lastTxUpdate = lastTxUpdate
+		bt.tipHashes = tipHashes
+		bt.minTimestamp = minTimestamp
+		bt.payAddress = payAddress
+
+		log.Debugf("Generated block template (timestamp %s, "+
+			"target %s, merkle root %s)",
+			msgBlock.Header.Timestamp, targetDifficulty,
+			msgBlock.Header.HashMerkleRoot)
+
+		// Notify any clients that are long polling about the new
+		// template.
+		bt.notifyLongPollers(tipHashes, lastTxUpdate)
+	} else {
+		// At this point, there is a saved block template and another
+		// request for a template was made, but either the available
+		// transactions haven't change or it hasn't been long enough to
+		// trigger a new block template to be generated. So, update the
+		// existing block template.
+
+		// Set locals for convenience.
+		msgBlock = template.Block
+		targetDifficulty = fmt.Sprintf("%064x",
+			util.CompactToBig(msgBlock.Header.Bits))
+
+		// Update the time of the block template to the current time
+		// while accounting for the median time of the past several
+		// blocks per the DAG consensus rules.
+		err := generator.UpdateBlockTime(msgBlock)
+		if err != nil {
+			return errors.Wrapf(err, "failed to update block time")
+		}
+		msgBlock.Header.Nonce = 0
+
+		log.Debugf("Updated block template (timestamp %s, "+
+			"target %s)", msgBlock.Header.Timestamp,
+			targetDifficulty)
+	}
+
+	return nil
+}
+
+// Response builds a GetBlockTemplateResponseMessage from the current state
+func (bt *BlockTemplateState) Response() (*appmessage.GetBlockTemplateResponseMessage, error) {
+	dag := bt.context.DAG
+	// Ensure the timestamps are still in valid range for the template.
+	// This should really only ever happen if the local clock is changed
+	// after the template is generated, but it's important to avoid serving
+	// block templates that will be delayed on other nodes.
+	template := bt.template
+	msgBlock := template.Block
+	header := &msgBlock.Header
+	adjustedTime := dag.Now()
+	maxTime := adjustedTime.Add(time.Millisecond * time.Duration(dag.TimestampDeviationTolerance))
+	if header.Timestamp.After(maxTime) {
+		errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("The template time is after the "+
+			"maximum allowed time for a block - template "+
+			"time %s, maximum time %s", adjustedTime,
+			maxTime)
+		return errorMessage, nil
+	}
+
+	// Convert each transaction in the block template to a template result
+	// transaction. The result does not include the coinbase, so notice
+	// the adjustments to the various lengths and indices.
+	numTx := len(msgBlock.Transactions)
+	transactions := make([]appmessage.GetBlockTemplateTransactionMessage, 0, numTx-1)
+	txIndex := make(map[daghash.TxID]int64, numTx)
+	for i, tx := range msgBlock.Transactions {
+		txID := tx.TxID()
+		txIndex[*txID] = int64(i)
+
+		// Create an array of 1-based indices to transactions that come
+		// before this one in the transactions list which this one
+		// depends on. This is necessary since the created block must
+		// ensure proper ordering of the dependencies. A map is used
+		// before creating the final array to prevent duplicate entries
+		// when multiple inputs reference the same transaction.
+		dependsMap := make(map[int64]struct{})
+		for _, txIn := range tx.TxIn {
+			if idx, ok := txIndex[txIn.PreviousOutpoint.TxID]; ok {
+				dependsMap[idx] = struct{}{}
+			}
+		}
+		depends := make([]int64, 0, len(dependsMap))
+		for idx := range dependsMap {
+			depends = append(depends, idx)
+		}
+
+		// Serialize the transaction for later conversion to hex.
+		txBuf := bytes.NewBuffer(make([]byte, 0, tx.SerializeSize()))
+		if err := tx.Serialize(txBuf); err != nil {
+			errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Failed to serialize transaction: %s", err)
+			return errorMessage, nil
+		}
+
+		resultTx := appmessage.GetBlockTemplateTransactionMessage{
+			Data:    hex.EncodeToString(txBuf.Bytes()),
+			ID:      txID.String(),
+			Depends: depends,
+			Mass:    template.TxMasses[i],
+			Fee:     template.Fees[i],
+		}
+		transactions = append(transactions, resultTx)
+	}
+
+	// Generate the block template reply. Note that following mutations are
+	// implied by the included or omission of fields:
+	//  Including MinTime -> time/decrement
+	//  Omitting CoinbaseTxn -> coinbase, generation
+	targetDifficulty := fmt.Sprintf("%064x", util.CompactToBig(header.Bits))
+	longPollID := bt.encodeLongPollID(bt.tipHashes, bt.payAddress, bt.lastGenerated)
+
+	// Check whether this node is synced with the rest of of the
+	// network. There's almost never a good reason to mine on top
+	// of an unsynced DAG, and miners are generally expected not to
+	// mine when isSynced is false.
+	// This is not a straight-up error because the choice of whether
+	// to mine or not is the responsibility of the miner rather
+	// than the node's.
+	isSynced := bt.context.BlockTemplateGenerator.IsSynced()
+	isConnected := len(bt.context.ProtocolManager.Peers()) > 0
+
+	reply := appmessage.GetBlockTemplateResponseMessage{
+		Bits:                 strconv.FormatInt(int64(header.Bits), 16),
+		CurrentTime:          header.Timestamp.UnixMilliseconds(),
+		ParentHashes:         daghash.Strings(header.ParentHashes),
+		MassLimit:            appmessage.MaxMassPerBlock,
+		Transactions:         transactions,
+		HashMerkleRoot:       header.HashMerkleRoot.String(),
+		AcceptedIDMerkleRoot: header.AcceptedIDMerkleRoot.String(),
+		UTXOCommitment:       header.UTXOCommitment.String(),
+		Version:              header.Version,
+		LongPollID:           longPollID,
+		TargetDifficulty:     targetDifficulty,
+		MinTime:              bt.minTimestamp.UnixMilliseconds(),
+		MaxTime:              maxTime.UnixMilliseconds(),
+		MutableFields:        blockTemplateMutableFields,
+		NonceRange:           blockTemplateNonceRange,
+		IsSynced:             isSynced,
+		IsConnected:          isConnected,
+	}
+
+	return &reply, nil
+}
+
+// notifyLongPollers notifies any channels that have been registered to be
+// notified when block templates are stale.
+//
+// This function MUST be called with the state locked.
+func (bt *BlockTemplateState) notifyLongPollers(tipHashes []*daghash.Hash, lastGenerated mstime.Time) {
+	// Notify anything that is waiting for a block template update from
+	// hashes which are not the current tip hashes.
+	tipHashesStr := daghash.JoinHashesStrings(tipHashes, "")
+	for hashesStr, channels := range bt.notifyMap {
+		if hashesStr != tipHashesStr {
+			for _, c := range channels {
+				close(c)
+			}
+			delete(bt.notifyMap, hashesStr)
+		}
+	}
+
+	// Return now if the provided last generated timestamp has not been
+	// initialized.
+	if lastGenerated.IsZero() {
+		return
+	}
+
+	// Return now if there is nothing registered for updates to the current
+	// best block hash.
+	channels, ok := bt.notifyMap[tipHashesStr]
+	if !ok {
+		return
+	}
+
+	// Notify anything that is waiting for a block template update from a
+	// block template generated before the most recently generated block
+	// template.
+	lastGeneratedUnix := lastGenerated.UnixSeconds()
+	for lastGen, c := range channels {
+		if lastGen < lastGeneratedUnix {
+			close(c)
+			delete(channels, lastGen)
+		}
+	}
+
+	// Remove the entry altogether if there are no more registered
+	// channels.
+	if len(channels) == 0 {
+		delete(bt.notifyMap, tipHashesStr)
+	}
+}
+
+// NotifyBlockAdded uses the newly-added block to notify any long poll
+// clients with a new block template when their existing block template is
+// stale due to the newly added block.
+func (bt *BlockTemplateState) NotifyBlockAdded(block *util.Block) {
+	spawn("BlockTemplateState.NotifyBlockAdded", func() {
+		bt.Lock()
+		defer bt.Unlock()
+
+		bt.notifyLongPollers(block.MsgBlock().Header.ParentHashes, bt.lastTxUpdate)
+	})
+}
+
+// NotifyMempoolTx uses the new last updated time for the transaction memory
+// pool to notify any long poll clients with a new block template when their
+// existing block template is stale due to enough time passing and the contents
+// of the memory pool changing.
+func (bt *BlockTemplateState) NotifyMempoolTx() {
+	lastUpdated := bt.context.Mempool.LastUpdated()
+	spawn("BlockTemplateState", func() {
+		bt.Lock()
+		defer bt.Unlock()
+
+		// No need to notify anything if no block templates have been generated
+		// yet.
+		if bt.tipHashes == nil || bt.lastGenerated.IsZero() {
+			return
+		}
+
+		if mstime.Now().After(bt.lastGenerated.Add(time.Second *
+			blockTemplateRegenerateSeconds)) {
+
+			bt.notifyLongPollers(bt.tipHashes, lastUpdated)
+		}
+	})
+}
+
+// BlockTemplateOrLongPollChan returns a block template if the
+// template identified by the provided long poll ID is stale or
+// invalid. Otherwise, it returns a channel that will notify
+// when there's a more current template.
+func (bt *BlockTemplateState) BlockTemplateOrLongPollChan(longPollID string,
+	payAddress util.Address) (*appmessage.GetBlockTemplateResponseMessage, chan struct{}, error) {
+
+	bt.Lock()
+	defer bt.Unlock()
+
+	if err := bt.Update(payAddress); err != nil {
+		return nil, nil, err
+	}
+
+	// Just return the current block template if the long poll ID provided by
+	// the caller is invalid.
+	parentHashes, lastGenerated, err := bt.decodeLongPollID(longPollID)
+	if err != nil {
+		result, err := bt.Response()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		return result, nil, nil
+	}
+
+	// Return the block template now if the specific block template
+	// identified by the long poll ID no longer matches the current block
+	// template as this means the provided template is stale.
+	areHashesEqual := daghash.AreEqual(bt.template.Block.Header.ParentHashes, parentHashes)
+	if !areHashesEqual ||
+		lastGenerated != bt.lastGenerated.UnixSeconds() {
+
+		// Include whether or not it is valid to submit work against the
+		// old block template depending on whether or not a solution has
+		// already been found and added to the block DAG.
+		result, err := bt.Response()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		return result, nil, nil
+	}
+
+	// Register the parent hashes and last generated time for notifications
+	// Get a channel that will be notified when the template associated with
+	// the provided ID is stale and a new block template should be returned to
+	// the caller.
+	longPollChan := bt.templateUpdateChan(parentHashes, lastGenerated)
+	return nil, longPollChan, nil
+}
+
+// templateUpdateChan returns a channel that will be closed once the block
+// template associated with the passed parent hashes and last generated time
+// is stale. The function will return existing channels for duplicate
+// parameters which allows multiple clients to wait for the same block template
+// without requiring a different channel for each client.
+//
+// This function MUST be called with the state locked.
+func (bt *BlockTemplateState) templateUpdateChan(tipHashes []*daghash.Hash, lastGenerated int64) chan struct{} {
+	tipHashesStr := daghash.JoinHashesStrings(tipHashes, "")
+	// Either get the current list of channels waiting for updates about
+	// changes to block template for the parent hashes or create a new one.
+	channels, ok := bt.notifyMap[tipHashesStr]
+	if !ok {
+		m := make(map[int64]chan struct{})
+		bt.notifyMap[tipHashesStr] = m
+		channels = m
+	}
+
+	// Get the current channel associated with the time the block template
+	// was last generated or create a new one.
+	c, ok := channels[lastGenerated]
+	if !ok {
+		c = make(chan struct{})
+		channels[lastGenerated] = c
+	}
+
+	return c
+}
+
+// encodeLongPollID encodes the passed details into an ID that can be used to
+// uniquely identify a block template.
+func (bt *BlockTemplateState) encodeLongPollID(parentHashes []*daghash.Hash, miningAddress util.Address, lastGenerated mstime.Time) string {
+	return fmt.Sprintf("%s-%s-%d", daghash.JoinHashesStrings(parentHashes, ""), miningAddress, lastGenerated.UnixSeconds())
+}
+
+// decodeLongPollID decodes an ID that is used to uniquely identify a block
+// template. This is mainly used as a mechanism to track when to update clients
+// that are using long polling for block templates. The ID consists of the
+// parent blocks hashes for the associated template and the time the associated
+// template was generated.
+func (bt *BlockTemplateState) decodeLongPollID(longPollID string) ([]*daghash.Hash, int64, error) {
+	fields := strings.Split(longPollID, "-")
+	if len(fields) != 2 {
+		return nil, 0, errors.New("decodeLongPollID: invalid number of fields")
+	}
+
+	parentHashesStr := fields[0]
+	if len(parentHashesStr)%daghash.HashSize != 0 {
+		return nil, 0, errors.New("decodeLongPollID: invalid parent hashes format")
+	}
+	numberOfHashes := len(parentHashesStr) / daghash.HashSize
+
+	parentHashes := make([]*daghash.Hash, 0, numberOfHashes)
+
+	for i := 0; i < len(parentHashesStr); i += daghash.HashSize {
+		hash, err := daghash.NewHashFromStr(parentHashesStr[i : i+daghash.HashSize])
+		if err != nil {
+			return nil, 0, errors.Errorf("decodeLongPollID: NewHashFromStr: %s", err)
+		}
+		parentHashes = append(parentHashes, hash)
+	}
+
+	lastGenerated, err := strconv.ParseInt(fields[1], 10, 64)
+	if err != nil {
+		return nil, 0, errors.Errorf("decodeLongPollID: Cannot parse timestamp %s: %s", fields[1], err)
+	}
+
+	return parentHashes, lastGenerated, nil
+}

app/rpc/rpccontext/chainblocks.go

@@ -0,0 +1,40 @@
+package rpccontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+)
+
+// CollectChainBlocks creates a slice of chain blocks from the given hashes
+func (ctx *Context) CollectChainBlocks(hashes []*daghash.Hash) ([]*appmessage.ChainBlock, error) {
+	chainBlocks := make([]*appmessage.ChainBlock, 0, len(hashes))
+	for _, hash := range hashes {
+		acceptanceData, err := ctx.AcceptanceIndex.TxsAcceptanceData(hash)
+		if err != nil {
+			return nil, errors.Errorf("could not retrieve acceptance data for block %s", hash)
+		}
+
+		acceptedBlocks := make([]*appmessage.AcceptedBlock, 0, len(acceptanceData))
+		for _, blockAcceptanceData := range acceptanceData {
+			acceptedTxIds := make([]string, 0, len(blockAcceptanceData.TxAcceptanceData))
+			for _, txAcceptanceData := range blockAcceptanceData.TxAcceptanceData {
+				if txAcceptanceData.IsAccepted {
+					acceptedTxIds = append(acceptedTxIds, txAcceptanceData.Tx.ID().String())
+				}
+			}
+			acceptedBlock := &appmessage.AcceptedBlock{
+				Hash:          blockAcceptanceData.BlockHash.String(),
+				AcceptedTxIDs: acceptedTxIds,
+			}
+			acceptedBlocks = append(acceptedBlocks, acceptedBlock)
+		}
+
+		chainBlock := &appmessage.ChainBlock{
+			Hash:           hash.String(),
+			AcceptedBlocks: acceptedBlocks,
+		}
+		chainBlocks = append(chainBlocks, chainBlock)
+	}
+	return chainBlocks, nil
+}

app/rpc/rpccontext/context.go

@@ -0,0 +1,56 @@
+package rpccontext
+
+import (
+	"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/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+)
+
+// Context represents the RPC context
+type Context struct {
+	Config                 *config.Config
+	NetAdapter             *netadapter.NetAdapter
+	DAG                    *blockdag.BlockDAG
+	ProtocolManager        *protocol.Manager
+	ConnectionManager      *connmanager.ConnectionManager
+	BlockTemplateGenerator *mining.BlkTmplGenerator
+	Mempool                *mempool.TxPool
+	AddressManager         *addressmanager.AddressManager
+	AcceptanceIndex        *indexers.AcceptanceIndex
+
+	BlockTemplateState  *BlockTemplateState
+	NotificationManager *NotificationManager
+}
+
+// NewContext creates a new RPC context
+func NewContext(
+	cfg *config.Config,
+	netAdapter *netadapter.NetAdapter,
+	dag *blockdag.BlockDAG,
+	protocolManager *protocol.Manager,
+	connectionManager *connmanager.ConnectionManager,
+	blockTemplateGenerator *mining.BlkTmplGenerator,
+	mempool *mempool.TxPool,
+	addressManager *addressmanager.AddressManager,
+	acceptanceIndex *indexers.AcceptanceIndex) *Context {
+	context := &Context{
+		Config:                 cfg,
+		NetAdapter:             netAdapter,
+		DAG:                    dag,
+		ProtocolManager:        protocolManager,
+		ConnectionManager:      connectionManager,
+		BlockTemplateGenerator: blockTemplateGenerator,
+		Mempool:                mempool,
+		AddressManager:         addressManager,
+		AcceptanceIndex:        acceptanceIndex,
+	}
+	context.BlockTemplateState = NewBlockTemplateState(context)
+	context.NotificationManager = NewNotificationManager()
+	return context
+}

app/rpc/rpccontext/log.go

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

app/rpc/rpccontext/notificationmanager.go

@@ -0,0 +1,139 @@
+package rpccontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+	"sync"
+)
+
+// NotificationManager manages notifications for the RPC
+type NotificationManager struct {
+	sync.RWMutex
+	listeners map[*router.Router]*NotificationListener
+}
+
+// OnBlockAddedListener is a listener function for when a block is added to the DAG
+type OnBlockAddedListener func(notification *appmessage.BlockAddedNotificationMessage) error
+
+// OnChainChangedListener is a listener function for when the DAG's selected parent chain changes
+type OnChainChangedListener func(notification *appmessage.ChainChangedNotificationMessage) error
+
+// NotificationListener represents a registered RPC notification listener
+type NotificationListener struct {
+	onBlockAddedListener           OnBlockAddedListener
+	onBlockAddedNotificationChan   chan *appmessage.BlockAddedNotificationMessage
+	onChainChangedListener         OnChainChangedListener
+	onChainChangedNotificationChan chan *appmessage.ChainChangedNotificationMessage
+
+	closeChan chan struct{}
+}
+
+// NewNotificationManager creates a new NotificationManager
+func NewNotificationManager() *NotificationManager {
+	return &NotificationManager{
+		listeners: make(map[*router.Router]*NotificationListener),
+	}
+}
+
+// AddListener registers a listener with the given router
+func (nm *NotificationManager) AddListener(router *router.Router) *NotificationListener {
+	nm.Lock()
+	defer nm.Unlock()
+
+	listener := newNotificationListener()
+	nm.listeners[router] = listener
+	return listener
+}
+
+// RemoveListener unregisters the given router
+func (nm *NotificationManager) RemoveListener(router *router.Router) {
+	nm.Lock()
+	defer nm.Unlock()
+
+	listener, ok := nm.listeners[router]
+	if !ok {
+		return
+	}
+	listener.close()
+
+	delete(nm.listeners, router)
+}
+
+// Listener retrieves the listener registered with the given router
+func (nm *NotificationManager) Listener(router *router.Router) (*NotificationListener, error) {
+	nm.RLock()
+	defer nm.RUnlock()
+
+	listener, ok := nm.listeners[router]
+	if !ok {
+		return nil, errors.Errorf("listener not found")
+	}
+	return listener, nil
+}
+
+// NotifyBlockAdded notifies the notification manager that a block has been added to the DAG
+func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAddedNotificationMessage) {
+	nm.RLock()
+	defer nm.RUnlock()
+
+	for _, listener := range nm.listeners {
+		if listener.onBlockAddedListener != nil {
+			select {
+			case listener.onBlockAddedNotificationChan <- notification:
+			case <-listener.closeChan:
+				continue
+			}
+		}
+	}
+}
+
+// NotifyChainChanged notifies the notification manager that the DAG's selected parent chain has changed
+func (nm *NotificationManager) NotifyChainChanged(message *appmessage.ChainChangedNotificationMessage) {
+	nm.RLock()
+	defer nm.RUnlock()
+
+	for _, listener := range nm.listeners {
+		if listener.onChainChangedListener != nil {
+			select {
+			case listener.onChainChangedNotificationChan <- message:
+			case <-listener.closeChan:
+				continue
+			}
+		}
+	}
+}
+
+func newNotificationListener() *NotificationListener {
+	return &NotificationListener{
+		onBlockAddedNotificationChan:   make(chan *appmessage.BlockAddedNotificationMessage),
+		onChainChangedNotificationChan: make(chan *appmessage.ChainChangedNotificationMessage),
+		closeChan:                      make(chan struct{}, 1),
+	}
+}
+
+// SetOnBlockAddedListener sets the onBlockAddedListener handler for this listener
+func (nl *NotificationListener) SetOnBlockAddedListener(onBlockAddedListener OnBlockAddedListener) {
+	nl.onBlockAddedListener = onBlockAddedListener
+}
+
+// SetOnChainChangedListener sets the onChainChangedListener handler for this listener
+func (nl *NotificationListener) SetOnChainChangedListener(onChainChangedListener OnChainChangedListener) {
+	nl.onChainChangedListener = onChainChangedListener
+}
+
+// ProcessNextNotification waits until a notification arrives and processes it
+func (nl *NotificationListener) ProcessNextNotification() error {
+	select {
+	case block := <-nl.onBlockAddedNotificationChan:
+		return nl.onBlockAddedListener(block)
+	case notification := <-nl.onChainChangedNotificationChan:
+		return nl.onChainChangedListener(notification)
+	case <-nl.closeChan:
+		return nil
+	}
+}
+
+func (nl *NotificationListener) close() {
+	nl.closeChan <- struct{}{}
+}

app/rpc/rpccontext/verbosedata.go

@@ -0,0 +1,246 @@
+package rpccontext
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain/dagconfig"
+	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/pointers"
+	"math/big"
+	"strconv"
+)
+
+// BuildBlockVerboseData builds a BlockVerboseData from the given block.
+// This method must be called with the DAG lock held for reads
+func (ctx *Context) BuildBlockVerboseData(block *util.Block, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
+	hash := block.Hash()
+	params := ctx.DAG.Params
+	blockHeader := block.MsgBlock().Header
+
+	blockBlueScore, err := ctx.DAG.BlueScoreByBlockHash(hash)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the hashes for the next blocks unless there are none.
+	childHashes, err := ctx.DAG.ChildHashesByHash(hash)
+	if err != nil {
+		return nil, err
+	}
+
+	blockConfirmations, err := ctx.DAG.BlockConfirmationsByHashNoLock(hash)
+	if err != nil {
+		return nil, err
+	}
+
+	selectedParentHash, err := ctx.DAG.SelectedParentHash(hash)
+	if err != nil {
+		return nil, err
+	}
+	selectedParentHashStr := ""
+	if selectedParentHash != nil {
+		selectedParentHashStr = selectedParentHash.String()
+	}
+
+	isChainBlock, err := ctx.DAG.IsInSelectedParentChain(hash)
+	if err != nil {
+		return nil, err
+	}
+
+	acceptedBlockHashes, err := ctx.DAG.BluesByBlockHash(hash)
+	if err != nil {
+		return nil, err
+	}
+
+	result := &appmessage.BlockVerboseData{
+		Hash:                 hash.String(),
+		Version:              blockHeader.Version,
+		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version),
+		HashMerkleRoot:       blockHeader.HashMerkleRoot.String(),
+		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot.String(),
+		UTXOCommitment:       blockHeader.UTXOCommitment.String(),
+		ParentHashes:         daghash.Strings(blockHeader.ParentHashes),
+		SelectedParentHash:   selectedParentHashStr,
+		Nonce:                blockHeader.Nonce,
+		Time:                 blockHeader.Timestamp.UnixMilliseconds(),
+		Confirmations:        blockConfirmations,
+		BlueScore:            blockBlueScore,
+		IsChainBlock:         isChainBlock,
+		Size:                 int32(block.MsgBlock().SerializeSize()),
+		Bits:                 strconv.FormatInt(int64(blockHeader.Bits), 16),
+		Difficulty:           ctx.GetDifficultyRatio(blockHeader.Bits, params),
+		ChildHashes:          daghash.Strings(childHashes),
+		AcceptedBlockHashes:  daghash.Strings(acceptedBlockHashes),
+	}
+
+	transactions := block.Transactions()
+	txIDs := make([]string, len(transactions))
+	for i, tx := range transactions {
+		txIDs[i] = tx.ID().String()
+	}
+	result.TxIDs = txIDs
+
+	if includeTransactionVerboseData {
+		transactions := block.Transactions()
+		transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(transactions))
+		for i, tx := range transactions {
+			data, err := ctx.buildTransactionVerboseData(tx.MsgTx(), tx.ID().String(),
+				&blockHeader, hash.String(), nil, false)
+			if err != nil {
+				return nil, err
+			}
+			transactionVerboseData[i] = data
+		}
+		result.TransactionVerboseData = transactionVerboseData
+	}
+
+	return result, nil
+}
+
+// GetDifficultyRatio returns the proof-of-work difficulty as a multiple of the
+// minimum difficulty using the passed bits field from the header of a block.
+func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) float64 {
+	// The minimum difficulty is the max possible proof-of-work limit bits
+	// converted back to a number. Note this is not the same as the proof of
+	// work limit directly because the block difficulty is encoded in a block
+	// with the compact form which loses precision.
+	target := util.CompactToBig(bits)
+
+	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
+	outString := difficulty.FloatString(8)
+	diff, err := strconv.ParseFloat(outString, 64)
+	if err != nil {
+		log.Errorf("Cannot get difficulty: %s", err)
+		return 0
+	}
+	return diff
+}
+
+func (ctx *Context) buildTransactionVerboseData(mtx *appmessage.MsgTx,
+	txID string, blockHeader *appmessage.BlockHeader, blockHash string,
+	acceptingBlock *daghash.Hash, isInMempool bool) (*appmessage.TransactionVerboseData, error) {
+
+	mtxHex, err := msgTxToHex(mtx)
+	if err != nil {
+		return nil, err
+	}
+
+	var payloadHash string
+	if mtx.PayloadHash != nil {
+		payloadHash = mtx.PayloadHash.String()
+	}
+
+	txReply := &appmessage.TransactionVerboseData{
+		Hex:                       mtxHex,
+		TxID:                      txID,
+		Hash:                      mtx.TxHash().String(),
+		Size:                      int32(mtx.SerializeSize()),
+		TransactionVerboseInputs:  ctx.buildTransactionVerboseInputs(mtx),
+		TransactionVerboseOutputs: ctx.buildTransactionVerboseOutputs(mtx, nil),
+		Version:                   mtx.Version,
+		LockTime:                  mtx.LockTime,
+		SubnetworkID:              mtx.SubnetworkID.String(),
+		Gas:                       mtx.Gas,
+		PayloadHash:               payloadHash,
+		Payload:                   hex.EncodeToString(mtx.Payload),
+	}
+
+	if blockHeader != nil {
+		txReply.Time = uint64(blockHeader.Timestamp.UnixMilliseconds())
+		txReply.BlockTime = uint64(blockHeader.Timestamp.UnixMilliseconds())
+		txReply.BlockHash = blockHash
+	}
+
+	txReply.IsInMempool = isInMempool
+	if acceptingBlock != nil {
+		txReply.AcceptedBy = acceptingBlock.String()
+	}
+
+	return txReply, nil
+}
+
+// msgTxToHex serializes a transaction using the latest protocol version and
+// returns a hex-encoded string of the result.
+func msgTxToHex(msgTx *appmessage.MsgTx) (string, error) {
+	var buf bytes.Buffer
+	err := msgTx.KaspaEncode(&buf, 0)
+	if err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(buf.Bytes()), nil
+}
+
+func (ctx *Context) buildTransactionVerboseInputs(mtx *appmessage.MsgTx) []*appmessage.TransactionVerboseInput {
+	inputs := make([]*appmessage.TransactionVerboseInput, len(mtx.TxIn))
+	for i, txIn := range mtx.TxIn {
+		// The disassembled string will contain [error] inline
+		// if the script doesn't fully parse, so ignore the
+		// error here.
+		disbuf, _ := txscript.DisasmString(txIn.SignatureScript)
+
+		input := &appmessage.TransactionVerboseInput{}
+		input.TxID = txIn.PreviousOutpoint.TxID.String()
+		input.OutputIndex = txIn.PreviousOutpoint.Index
+		input.Sequence = txIn.Sequence
+		input.ScriptSig = &appmessage.ScriptSig{
+			Asm: disbuf,
+			Hex: hex.EncodeToString(txIn.SignatureScript),
+		}
+		inputs[i] = input
+	}
+
+	return inputs
+}
+
+// buildTransactionVerboseOutputs returns a slice of JSON objects for the outputs of the passed
+// transaction.
+func (ctx *Context) buildTransactionVerboseOutputs(mtx *appmessage.MsgTx, filterAddrMap map[string]struct{}) []*appmessage.TransactionVerboseOutput {
+	outputs := make([]*appmessage.TransactionVerboseOutput, len(mtx.TxOut))
+	for i, v := range mtx.TxOut {
+		// The disassembled string will contain [error] inline if the
+		// script doesn't fully parse, so ignore the error here.
+		disbuf, _ := txscript.DisasmString(v.ScriptPubKey)
+
+		// Ignore the error here since an error means the script
+		// couldn't parse and there is no additional information about
+		// it anyways.
+		scriptClass, addr, _ := txscript.ExtractScriptPubKeyAddress(
+			v.ScriptPubKey, ctx.DAG.Params)
+
+		// Encode the addresses while checking if the address passes the
+		// filter when needed.
+		passesFilter := len(filterAddrMap) == 0
+		var encodedAddr string
+		if addr != nil {
+			encodedAddr = *pointers.String(addr.EncodeAddress())
+
+			// If the filter doesn't already pass, make it pass if
+			// the address exists in the filter.
+			if _, exists := filterAddrMap[encodedAddr]; exists {
+				passesFilter = true
+			}
+		}
+
+		if !passesFilter {
+			continue
+		}
+
+		output := &appmessage.TransactionVerboseOutput{}
+		output.Index = uint32(i)
+		output.Value = v.Value
+		output.ScriptPubKey = &appmessage.ScriptPubKeyResult{
+			Address: encodedAddr,
+			Asm:     disbuf,
+			Hex:     hex.EncodeToString(v.ScriptPubKey),
+			Type:    scriptClass.String(),
+		}
+		outputs[i] = output
+	}
+
+	return outputs
+}

app/rpc/rpchandlers/add_peer.go

@@ -0,0 +1,24 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/network"
+)
+
+// HandleAddPeer handles the respectively named RPC command
+func HandleAddPeer(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	AddPeerRequest := request.(*appmessage.AddPeerRequestMessage)
+	address, err := network.NormalizeAddress(AddPeerRequest.Address, context.DAG.Params.DefaultPort)
+	if err != nil {
+		errorMessage := &appmessage.AddPeerResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not parse address: %s", err)
+		return errorMessage, nil
+	}
+
+	context.ConnectionManager.AddConnectionRequest(address, AddPeerRequest.IsPermanent)
+
+	response := appmessage.NewAddPeerResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/get_block.go

@@ -0,0 +1,98 @@
+package rpchandlers
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/hex"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// HandleGetBlock handles the respectively named RPC command
+func HandleGetBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getBlockRequest := request.(*appmessage.GetBlockRequestMessage)
+
+	// Load the raw block bytes from the database.
+	hash, err := daghash.NewHashFromStr(getBlockRequest.Hash)
+	if err != nil {
+		errorMessage := &appmessage.GetBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Hash could not be parsed: %s", err)
+		return errorMessage, nil
+	}
+
+	context.DAG.RLock()
+	defer context.DAG.RUnlock()
+
+	if context.DAG.IsKnownInvalid(hash) {
+		errorMessage := &appmessage.GetBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block %s is known to be invalid", hash)
+		return errorMessage, nil
+	}
+	if context.DAG.IsKnownOrphan(hash) {
+		errorMessage := &appmessage.GetBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block %s is an orphan", hash)
+		return errorMessage, nil
+	}
+	block, err := context.DAG.BlockByHash(hash)
+	if err != nil {
+		errorMessage := &appmessage.GetBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block %s not found", hash)
+		return errorMessage, nil
+	}
+
+	blockBytes, err := block.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	// Handle partial blocks
+	if getBlockRequest.SubnetworkID != "" {
+		requestSubnetworkID, err := subnetworkid.NewFromStr(getBlockRequest.SubnetworkID)
+		if err != nil {
+			errorMessage := &appmessage.GetBlockResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("SubnetworkID could not be parsed: %s", err)
+			return errorMessage, nil
+		}
+		nodeSubnetworkID := context.Config.SubnetworkID
+
+		if requestSubnetworkID != nil {
+			if nodeSubnetworkID != nil {
+				if !nodeSubnetworkID.IsEqual(requestSubnetworkID) {
+					errorMessage := &appmessage.GetBlockResponseMessage{}
+					errorMessage.Error = appmessage.RPCErrorf("subnetwork %s does not match this partial node",
+						getBlockRequest.SubnetworkID)
+					return errorMessage, nil
+				}
+				// nothing to do - partial node stores partial blocks
+			} else {
+				// Deserialize the block.
+				msgBlock := block.MsgBlock()
+				msgBlock.ConvertToPartial(requestSubnetworkID)
+				var b bytes.Buffer
+				err := msgBlock.Serialize(bufio.NewWriter(&b))
+				if err != nil {
+					return nil, err
+				}
+				blockBytes = b.Bytes()
+			}
+		}
+	}
+
+	response := appmessage.NewGetBlockResponseMessage()
+
+	if getBlockRequest.IncludeBlockHex {
+		response.BlockHex = hex.EncodeToString(blockBytes)
+	}
+	if getBlockRequest.IncludeBlockVerboseData {
+		blockVerboseData, err := context.BuildBlockVerboseData(block, getBlockRequest.IncludeTransactionVerboseData)
+		if err != nil {
+			return nil, err
+		}
+		response.BlockVerboseData = blockVerboseData
+	}
+
+	return response, nil
+}

app/rpc/rpchandlers/get_block_count.go

@@ -0,0 +1,13 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetBlockCount handles the respectively named RPC command
+func HandleGetBlockCount(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	response := appmessage.NewGetBlockCountResponseMessage(context.DAG.BlockCount())
+	return response, nil
+}

app/rpc/rpchandlers/get_block_dag_info.go

@@ -0,0 +1,22 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// HandleGetBlockDAGInfo handles the respectively named RPC command
+func HandleGetBlockDAGInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	dag := context.DAG
+	params := dag.Params
+
+	response := appmessage.NewGetBlockDAGInfoResponseMessage()
+	response.NetworkName = params.Name
+	response.BlockCount = dag.BlockCount()
+	response.TipHashes = daghash.Strings(dag.TipHashes())
+	response.Difficulty = context.GetDifficultyRatio(dag.CurrentBits(), params)
+	response.PastMedianTime = dag.CalcPastMedianTime().UnixMilliseconds()
+	return response, nil
+}

app/rpc/rpchandlers/get_block_template.go

@@ -0,0 +1,86 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+)
+
+// HandleGetBlockTemplate handles the respectively named RPC command
+func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getBlockTemplateRequest := request.(*appmessage.GetBlockTemplateRequestMessage)
+
+	payAddress, err := util.DecodeAddress(getBlockTemplateRequest.PayAddress, context.DAG.Params.Prefix)
+	if err != nil {
+		errorMessage := &appmessage.GetBlockTemplateResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not decode address: %s", err)
+		return errorMessage, nil
+	}
+
+	// When a long poll ID was provided, this is a long poll request by the
+	// client to be notified when block template referenced by the ID should
+	// be replaced with a new one.
+	if getBlockTemplateRequest.LongPollID != "" {
+		return handleGetBlockTemplateLongPoll(context, getBlockTemplateRequest.LongPollID, payAddress)
+	}
+
+	// Protect concurrent access when updating block templates.
+	context.BlockTemplateState.Lock()
+	defer context.BlockTemplateState.Unlock()
+
+	// Get and return a block template. A new block template will be
+	// generated when the current best block has changed or the transactions
+	// in the memory pool have been updated and it has been at least five
+	// seconds since the last template was generated. Otherwise, the
+	// timestamp for the existing block template is updated (and possibly
+	// the difficulty on testnet per the consesus rules).
+	err = context.BlockTemplateState.Update(payAddress)
+	if err != nil {
+		return nil, err
+	}
+	return context.BlockTemplateState.Response()
+}
+
+// handleGetBlockTemplateLongPoll is a helper for handleGetBlockTemplateRequest
+// which deals with handling long polling for block templates. When a caller
+// sends a request with a long poll ID that was previously returned, a response
+// is not sent until the caller should stop working on the previous block
+// template in favor of the new one. In particular, this is the case when the
+// old block template is no longer valid due to a solution already being found
+// and added to the block DAG, or new transactions have shown up and some time
+// has passed without finding a solution.
+func handleGetBlockTemplateLongPoll(context *rpccontext.Context, longPollID string,
+	payAddress util.Address) (*appmessage.GetBlockTemplateResponseMessage, error) {
+	state := context.BlockTemplateState
+
+	result, longPollChan, err := state.BlockTemplateOrLongPollChan(longPollID, payAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	if result != nil {
+		return result, nil
+	}
+
+	// Wait until signal received to send the reply.
+	<-longPollChan
+
+	// Get the lastest block template
+	state.Lock()
+	defer state.Unlock()
+
+	if err := state.Update(payAddress); err != nil {
+		return nil, err
+	}
+
+	// Include whether or not it is valid to submit work against the old
+	// block template depending on whether or not a solution has already
+	// been found and added to the block DAG.
+	result, err = state.Response()
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

app/rpc/rpchandlers/get_blocks.go

@@ -0,0 +1,118 @@
+package rpchandlers
+
+import (
+	"encoding/hex"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+const (
+	// maxBlocksInGetBlocksResponse is the max amount of blocks that are
+	// allowed in a GetBlocksResult.
+	maxBlocksInGetBlocksResponse = 1000
+)
+
+// HandleGetBlocks handles the respectively named RPC command
+func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getBlocksRequest := request.(*appmessage.GetBlocksRequestMessage)
+
+	var lowHash *daghash.Hash
+	if getBlocksRequest.LowHash != "" {
+		lowHash = &daghash.Hash{}
+		err := daghash.Decode(lowHash, getBlocksRequest.LowHash)
+		if err != nil {
+			errorMessage := &appmessage.GetBlocksResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Could not parse lowHash: %s", err)
+			return errorMessage, nil
+		}
+	}
+
+	context.DAG.RLock()
+	defer context.DAG.RUnlock()
+
+	// If lowHash is not in the DAG, there's nothing to do; return an error.
+	if lowHash != nil && !context.DAG.IsKnownBlock(lowHash) {
+		errorMessage := &appmessage.GetBlocksResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block %s not found in DAG", lowHash)
+		return errorMessage, nil
+	}
+
+	// Retrieve the block hashes.
+	blockHashes, err := context.DAG.BlockHashesFrom(lowHash, maxBlocksInGetBlocksResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	// Convert the hashes to strings
+	hashes := make([]string, len(blockHashes))
+	for i, blockHash := range blockHashes {
+		hashes[i] = blockHash.String()
+	}
+
+	// Include more data if requested
+	var blockHexes []string
+	var blockVerboseData []*appmessage.BlockVerboseData
+	if getBlocksRequest.IncludeBlockHexes || getBlocksRequest.IncludeBlockVerboseData {
+		blockBytesSlice, err := hashesToBlockBytes(context, blockHashes)
+		if err != nil {
+			return nil, err
+		}
+		if getBlocksRequest.IncludeBlockHexes {
+			blockHexes = blockBytesToStrings(blockBytesSlice)
+		}
+		if getBlocksRequest.IncludeBlockVerboseData {
+			data, err := blockBytesToBlockVerboseResults(context, blockBytesSlice, getBlocksRequest.IncludeBlockVerboseData)
+			if err != nil {
+				return nil, err
+			}
+			blockVerboseData = data
+		}
+	}
+
+	response := appmessage.NewGetBlocksResponseMessage(hashes, blockHexes, blockVerboseData)
+	return response, nil
+}
+
+func hashesToBlockBytes(context *rpccontext.Context, hashes []*daghash.Hash) ([][]byte, error) {
+	blocks := make([][]byte, len(hashes))
+	for i, hash := range hashes {
+		block, err := context.DAG.BlockByHash(hash)
+		if err != nil {
+			return nil, err
+		}
+		blockBytes, err := block.Bytes()
+		if err != nil {
+			return nil, err
+		}
+		blocks[i] = blockBytes
+	}
+	return blocks, nil
+}
+func blockBytesToStrings(blockBytesSlice [][]byte) []string {
+	rawBlocks := make([]string, len(blockBytesSlice))
+	for i, blockBytes := range blockBytesSlice {
+		rawBlocks[i] = hex.EncodeToString(blockBytes)
+	}
+	return rawBlocks
+}
+
+func blockBytesToBlockVerboseResults(context *rpccontext.Context, blockBytesSlice [][]byte,
+	includeTransactionVerboseData bool) ([]*appmessage.BlockVerboseData, error) {
+
+	verboseBlocks := make([]*appmessage.BlockVerboseData, len(blockBytesSlice))
+	for i, blockBytes := range blockBytesSlice {
+		block, err := util.NewBlockFromBytes(blockBytes)
+		if err != nil {
+			return nil, err
+		}
+		getBlockVerboseResult, err := context.BuildBlockVerboseData(block, includeTransactionVerboseData)
+		if err != nil {
+			return nil, err
+		}
+		verboseBlocks[i] = getBlockVerboseResult
+	}
+	return verboseBlocks, nil
+}

app/rpc/rpchandlers/get_chain_from_block.go

@@ -0,0 +1,106 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+)
+
+const (
+	// maxBlocksInGetChainFromBlockResponse is the max amount of blocks that
+	// are allowed in a GetChainFromBlockResponse.
+	maxBlocksInGetChainFromBlockResponse = 1000
+)
+
+// HandleGetChainFromBlock handles the respectively named RPC command
+func HandleGetChainFromBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getChainFromBlockRequest := request.(*appmessage.GetChainFromBlockRequestMessage)
+
+	if context.AcceptanceIndex == nil {
+		errorMessage := &appmessage.GetChainFromBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("The acceptance index must be " +
+			"enabled to get the selected parent chain " +
+			"(specify --acceptanceindex)")
+		return errorMessage, nil
+	}
+
+	var startHash *daghash.Hash
+	if getChainFromBlockRequest.StartHash != "" {
+		startHash = &daghash.Hash{}
+		err := daghash.Decode(startHash, getChainFromBlockRequest.StartHash)
+		if err != nil {
+			errorMessage := &appmessage.GetChainFromBlockResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Could not parse startHash: %s", err)
+			return errorMessage, nil
+		}
+	}
+
+	context.DAG.RLock()
+	defer context.DAG.RUnlock()
+
+	// If startHash is not in the selected parent chain, there's nothing
+	// to do; return an error.
+	if startHash != nil && !context.DAG.IsInDAG(startHash) {
+		errorMessage := &appmessage.GetChainFromBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block %s not found in the DAG", startHash)
+		return errorMessage, nil
+	}
+
+	// Retrieve the selected parent chain.
+	removedChainHashes, addedChainHashes, err := context.DAG.SelectedParentChain(startHash)
+	if err != nil {
+		return nil, err
+	}
+
+	// Limit the amount of blocks in the response
+	if len(addedChainHashes) > maxBlocksInGetChainFromBlockResponse {
+		addedChainHashes = addedChainHashes[:maxBlocksInGetChainFromBlockResponse]
+	}
+
+	// Collect addedChainBlocks.
+	addedChainBlocks, err := context.CollectChainBlocks(addedChainHashes)
+	if err != nil {
+		errorMessage := &appmessage.GetChainFromBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not collect chain blocks: %s", err)
+		return errorMessage, nil
+	}
+
+	// Collect removedHashes.
+	removedHashes := make([]string, len(removedChainHashes))
+	for i, hash := range removedChainHashes {
+		removedHashes[i] = hash.String()
+	}
+
+	// If the user specified to include the blocks, collect them as well.
+	var blockVerboseData []*appmessage.BlockVerboseData
+	if getChainFromBlockRequest.IncludeBlockVerboseData {
+		data, err := hashesToBlockVerboseData(context, addedChainHashes)
+		if err != nil {
+			return nil, err
+		}
+		blockVerboseData = data
+	}
+
+	response := appmessage.NewGetChainFromBlockResponseMessage(removedHashes, addedChainBlocks, blockVerboseData)
+	return response, nil
+}
+
+// hashesToBlockVerboseData takes block hashes and returns their
+// correspondent block verbose.
+func hashesToBlockVerboseData(context *rpccontext.Context, hashes []*daghash.Hash) ([]*appmessage.BlockVerboseData, error) {
+	getBlockVerboseResults := make([]*appmessage.BlockVerboseData, 0, len(hashes))
+	for _, blockHash := range hashes {
+		block, err := context.DAG.BlockByHash(blockHash)
+		if err != nil {
+			return nil, errors.Errorf("could not retrieve block %s.", blockHash)
+		}
+		getBlockVerboseResult, err := context.BuildBlockVerboseData(block, false)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not build getBlockVerboseResult for block %s", blockHash)
+		}
+		getBlockVerboseResults = append(getBlockVerboseResults, getBlockVerboseResult)
+	}
+	return getBlockVerboseResults, nil
+}

app/rpc/rpchandlers/get_connected_peer_info.go

@@ -0,0 +1,31 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetConnectedPeerInfo handles the respectively named RPC command
+func HandleGetConnectedPeerInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	peers := context.ProtocolManager.Peers()
+	ibdPeer := context.ProtocolManager.IBDPeer()
+	infos := make([]*appmessage.GetConnectedPeerInfoMessage, 0, len(peers))
+	for _, peer := range peers {
+		info := &appmessage.GetConnectedPeerInfoMessage{
+			ID:                        peer.ID().String(),
+			Address:                   peer.Address(),
+			LastPingDuration:          peer.LastPingDuration().Milliseconds(),
+			SelectedTipHash:           peer.SelectedTipHash().String(),
+			IsSyncNode:                peer == ibdPeer,
+			IsOutbound:                peer.IsOutbound(),
+			TimeOffset:                peer.TimeOffset().Milliseconds(),
+			UserAgent:                 peer.UserAgent(),
+			AdvertisedProtocolVersion: peer.AdvertisedProtocolVersion(),
+			TimeConnected:             peer.TimeConnected().Milliseconds(),
+		}
+		infos = append(infos, info)
+	}
+	response := appmessage.NewGetConnectedPeerInfoResponseMessage(infos)
+	return response, nil
+}

app/rpc/rpchandlers/get_current_network.go

@@ -0,0 +1,13 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetCurrentNetwork handles the respectively named RPC command
+func HandleGetCurrentNetwork(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	response := appmessage.NewGetCurrentNetworkResponseMessage(context.DAG.Params.Net.String())
+	return response, nil
+}

app/rpc/rpchandlers/get_mempool_entry.go

@@ -0,0 +1,29 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// HandleGetMempoolEntry handles the respectively named RPC command
+func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getMempoolEntryRequest := request.(*appmessage.GetMempoolEntryRequestMessage)
+	txID, err := daghash.NewTxIDFromStr(getMempoolEntryRequest.TxID)
+	if err != nil {
+		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not parse txId: %s", err)
+		return errorMessage, nil
+	}
+
+	_, ok := context.Mempool.FetchTxDesc(txID)
+	if !ok {
+		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("transaction is not in the pool")
+		return errorMessage, nil
+	}
+
+	response := appmessage.NewGetMempoolEntryResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/get_peer_addresses.go

@@ -0,0 +1,21 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetPeerAddresses handles the respectively named RPC command
+func HandleGetPeerAddresses(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	peersState, err := context.AddressManager.PeersStateForSerialization()
+	if err != nil {
+		return nil, err
+	}
+	addresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(peersState.Addresses))
+	for i, address := range peersState.Addresses {
+		addresses[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: string(address.Address)}
+	}
+	response := appmessage.NewGetPeerAddressesResponseMessage(addresses)
+	return response, nil
+}

app/rpc/rpchandlers/get_selected_tip_hash.go

@@ -0,0 +1,13 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetSelectedTipHash handles the respectively named RPC command
+func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	response := appmessage.NewGetSelectedTipHashResponseMessage(context.DAG.SelectedTipHash().String())
+	return response, nil
+}

app/rpc/rpchandlers/get_subnetwork.go

@@ -0,0 +1,34 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// HandleGetSubnetwork handles the respectively named RPC command
+func HandleGetSubnetwork(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getSubnetworkRequest := request.(*appmessage.GetSubnetworkRequestMessage)
+
+	subnetworkID, err := subnetworkid.NewFromStr(getSubnetworkRequest.SubnetworkID)
+	if err != nil {
+		errorMessage := &appmessage.GetSubnetworkResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Could not parse subnetworkID: %s", err)
+		return errorMessage, nil
+	}
+
+	var gasLimit uint64
+	if !subnetworkID.IsBuiltInOrNative() {
+		limit, err := context.DAG.GasLimit(subnetworkID)
+		if err != nil {
+			errorMessage := &appmessage.GetSubnetworkResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Subnetwork %s not found.", subnetworkID)
+			return errorMessage, nil
+		}
+		gasLimit = limit
+	}
+
+	response := appmessage.NewGetSubnetworkResponseMessage(gasLimit)
+	return response, nil
+}

app/rpc/rpchandlers/log.go

@@ -0,0 +1,7 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.RPCS)

app/rpc/rpchandlers/notify_block_added.go

@@ -0,0 +1,21 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleNotifyBlockAdded handles the respectively named RPC command
+func HandleNotifyBlockAdded(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	listener, err := context.NotificationManager.Listener(router)
+	if err != nil {
+		return nil, err
+	}
+	listener.SetOnBlockAddedListener(func(notification *appmessage.BlockAddedNotificationMessage) error {
+		return router.OutgoingRoute().Enqueue(notification)
+	})
+
+	response := appmessage.NewNotifyBlockAddedResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/notify_chain_changed.go

@@ -0,0 +1,27 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleNotifyChainChanged handles the respectively named RPC command
+func HandleNotifyChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	if context.AcceptanceIndex == nil {
+		errorMessage := appmessage.NewNotifyChainChangedResponseMessage()
+		errorMessage.Error = appmessage.RPCErrorf("Acceptance index is not available")
+		return errorMessage, nil
+	}
+
+	listener, err := context.NotificationManager.Listener(router)
+	if err != nil {
+		return nil, err
+	}
+	listener.SetOnChainChangedListener(func(message *appmessage.ChainChangedNotificationMessage) error {
+		return router.OutgoingRoute().Enqueue(message)
+	})
+
+	response := appmessage.NewNotifyChainChangedResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/submit_block.go

@@ -0,0 +1,41 @@
+package rpchandlers
+
+import (
+	"encoding/hex"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+)
+
+// HandleSubmitBlock handles the respectively named RPC command
+func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	submitBlockRequest := request.(*appmessage.SubmitBlockRequestMessage)
+
+	// Deserialize the submitted block.
+	serializedBlock, err := hex.DecodeString(submitBlockRequest.BlockHex)
+	if err != nil {
+		errorMessage := &appmessage.SubmitBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block hex could not be parsed: %s", err)
+		return errorMessage, nil
+	}
+	block, err := util.NewBlockFromBytes(serializedBlock)
+	if err != nil {
+		errorMessage := &appmessage.SubmitBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block decode failed: %s", err)
+		return errorMessage, nil
+	}
+
+	err = context.ProtocolManager.AddBlock(block, blockdag.BFDisallowDelay|blockdag.BFDisallowOrphans)
+	if err != nil {
+		errorMessage := &appmessage.SubmitBlockResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Block rejected. Reason: %s", err)
+		return errorMessage, nil
+	}
+
+	log.Infof("Accepted block %s via submitBlock", block.Hash())
+
+	response := appmessage.NewSubmitBlockResponseMessage()
+	return response, nil
+}

app/rpc/rpchandlers/submit_transaction.go

@@ -0,0 +1,47 @@
+package rpchandlers
+
+import (
+	"bytes"
+	"encoding/hex"
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/pkg/errors"
+)
+
+// HandleSubmitTransaction handles the respectively named RPC command
+func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	submitTransactionRequest := request.(*appmessage.SubmitTransactionRequestMessage)
+
+	serializedTx, err := hex.DecodeString(submitTransactionRequest.TransactionHex)
+	if err != nil {
+		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Transaction hex could not be parsed: %s", err)
+		return errorMessage, nil
+	}
+	var msgTx appmessage.MsgTx
+	err = msgTx.Deserialize(bytes.NewReader(serializedTx))
+	if err != nil {
+		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Transaction decode failed: %s", err)
+		return errorMessage, nil
+	}
+
+	tx := util.NewTx(&msgTx)
+	err = context.ProtocolManager.AddTransaction(tx)
+	if err != nil {
+		if !errors.As(err, &mempool.RuleError{}) {
+			return nil, err
+		}
+
+		log.Debugf("Rejected transaction %s: %s", tx.ID(), err)
+		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Rejected transaction %s: %s", tx.ID(), err)
+		return errorMessage, nil
+	}
+
+	response := appmessage.NewSubmitTransactionResponseMessage(tx.ID().String())
+	return response, nil
+}

cmd/kaspactl/config.go

@@ -1,298 +1,41 @@
-// Copyright (c) 2013-2015 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
 package main
 
 import (
-	"fmt"
 	"github.com/kaspanet/kaspad/infrastructure/config"
-	"github.com/kaspanet/kaspad/version"
 	"github.com/pkg/errors"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
 
 	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc/model"
-	"github.com/kaspanet/kaspad/util"
-)
-
-const (
-	// unusableFlags are the command usage flags which this utility are not
-	// able to use. In particular it doesn't support websockets and
-	// consequently notifications.
-	unusableFlags = model.UFWebsocketOnly | model.UFNotification
 )
 
 var (
-	kaspadHomeDir      = util.AppDataDir("kaspad", false)
-	kaspactlHomeDir    = util.AppDataDir("kaspactl", false)
-	defaultConfigFile  = filepath.Join(kaspactlHomeDir, "kaspactl.conf")
-	defaultRPCServer   = "localhost"
-	defaultRPCCertFile = filepath.Join(kaspadHomeDir, "rpc.cert")
-	activeConfig       *ConfigFlags
+	defaultRPCServer = "localhost"
 )
 
-// listCommands categorizes and lists all of the usable commands along with
-// their one-line usage.
-func listCommands() {
-	const (
-		categoryDAG uint8 = iota
-		numCategories
-	)
-
-	// Get a list of registered commands and categorize and filter them.
-	cmdMethods := model.RegisteredCmdMethods()
-	categorized := make([][]string, numCategories)
-	for _, method := range cmdMethods {
-		flags, err := model.MethodUsageFlags(method)
-		if err != nil {
-			// This should never happen since the method was just
-			// returned from the package, but be safe.
-			continue
-		}
-
-		// Skip the commands that aren't usable from this utility.
-		if flags&unusableFlags != 0 {
-			continue
-		}
-
-		usage, err := model.MethodUsageText(method)
-		if err != nil {
-			// This should never happen since the method was just
-			// returned from the package, but be safe.
-			continue
-		}
-
-		// Categorize the command based on the usage flags.
-		category := categoryDAG
-		categorized[category] = append(categorized[category], usage)
-	}
-
-	// Display the command according to their categories.
-	categoryTitles := make([]string, numCategories)
-	categoryTitles[categoryDAG] = "DAG Server Commands:"
-	for category := uint8(0); category < numCategories; category++ {
-		fmt.Println(categoryTitles[category])
-		for _, usage := range categorized[category] {
-			fmt.Println(usage)
-		}
-		fmt.Println()
-	}
-}
-
-// ConfigFlags defines the configuration options for kaspactl.
-//
-// See loadConfig for details on the configuration load process.
-type ConfigFlags struct {
-	ShowVersion   bool   `short:"V" long:"version" description:"Display version information and exit"`
-	ListCommands  bool   `short:"l" long:"listcommands" description:"List all of the supported commands and exit"`
-	ConfigFile    string `short:"C" long:"configfile" description:"Path to configuration file"`
-	RPCUser       string `short:"u" long:"rpcuser" description:"RPC username"`
-	RPCPassword   string `short:"P" long:"rpcpass" default-mask:"-" description:"RPC password"`
-	RPCServer     string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
-	RPCCert       string `short:"c" long:"rpccert" description:"RPC server certificate chain for validation"`
-	NoTLS         bool   `long:"notls" description:"Disable TLS"`
-	Proxy         string `long:"proxy" description:"Connect via SOCKS5 proxy (eg. 127.0.0.1:9050)"`
-	ProxyUser     string `long:"proxyuser" description:"Username for proxy server"`
-	ProxyPass     string `long:"proxypass" default-mask:"-" description:"Password for proxy server"`
-	TLSSkipVerify bool   `long:"skipverify" description:"Do not verify tls certificates (not recommended!)"`
+type configFlags struct {
+	RPCServer   string `short:"s" long:"rpcserver" description:"RPC server to connect to"`
+	RequestJSON string `description:"The request in JSON format"`
 	config.NetworkFlags
 }
 
-// cleanAndExpandPath expands environement variables and leading ~ in the
-// passed path, cleans the result, and returns it.
-func cleanAndExpandPath(path string) string {
-	// Expand initial ~ to OS specific home directory.
-	if strings.HasPrefix(path, "~") {
-		homeDir := filepath.Dir(kaspactlHomeDir)
-		path = strings.Replace(path, "~", homeDir, 1)
+func parseConfig() (*configFlags, error) {
+	cfg := &configFlags{
+		RPCServer: defaultRPCServer,
+	}
+	parser := flags.NewParser(cfg, flags.PrintErrors|flags.HelpFlag)
+	args, err := parser.Parse()
+	if err != nil {
+		return nil, err
 	}
 
-	// NOTE: The os.ExpandEnv doesn't work with Windows-style %VARIABLE%,
-	// but they variables can still be expanded via POSIX-style $VARIABLE.
-	return filepath.Clean(os.ExpandEnv(path))
-}
-
-// loadConfig initializes and parses the config using a config file and command
-// line options.
-//
-// The configuration proceeds as follows:
-// 	1) Start with a default config with sane settings
-// 	2) Pre-parse the command line to check for an alternative config file
-// 	3) Load configuration file overwriting defaults with any specified options
-// 	4) Parse CLI options and overwrite/add any specified options
-//
-// The above results in functioning properly without any config settings
-// while still allowing the user to override settings with config files and
-// command line options. Command line options always take precedence.
-func loadConfig() (*ConfigFlags, []string, error) {
-	// Default config.
-	activeConfig = &ConfigFlags{
-		ConfigFile: defaultConfigFile,
-		RPCServer:  defaultRPCServer,
-		RPCCert:    defaultRPCCertFile,
-	}
-
-	// Pre-parse the command line options to see if an alternative config
-	// file, the version flag, or the list commands flag was specified. Any
-	// errors aside from the help message error can be ignored here since
-	// they will be caught by the final parse below.
-	preCfg := activeConfig
-	preParser := flags.NewParser(preCfg, flags.HelpFlag)
-	_, err := preParser.Parse()
-	if err != nil {
-		var flagsErr *flags.Error
-		if ok := errors.As(err, &flagsErr); ok && flagsErr.Type == flags.ErrHelp {
-			fmt.Fprintln(os.Stderr, err)
-			fmt.Fprintln(os.Stderr, "")
-			fmt.Fprintln(os.Stderr, "The special parameter `-` "+
-				"indicates that a parameter should be read "+
-				"from the\nnext unread line from standard "+
-				"input.")
-			return nil, nil, err
-		}
-	}
-
-	// Show the version and exit if the version flag was specified.
-	appName := filepath.Base(os.Args[0])
-	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
-	usageMessage := fmt.Sprintf("Use %s -h to show options", appName)
-	if preCfg.ShowVersion {
-		fmt.Println(appName, "version", version.Version())
-		os.Exit(0)
-	}
-
-	// Show the available commands and exit if the associated flag was
-	// specified.
-	if preCfg.ListCommands {
-		listCommands()
-		os.Exit(0)
-	}
-
-	// If no rpc user and password were configured, create
-	// a kaspactl default config file based on the rpc login
-	// details written in the RPC server configuration file
-	if preCfg.RPCUser == "" && preCfg.RPCPassword == "" {
-		if _, err := os.Stat(preCfg.ConfigFile); os.IsNotExist(err) {
-			serverConfigPath := filepath.Join(kaspadHomeDir, "kaspad.conf")
-			err := createDefaultConfigFile(preCfg.ConfigFile, serverConfigPath)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error creating a default config file: %s\n", err)
-			}
-		}
-	}
-
-	// Load additional config from file.
-	parser := flags.NewParser(activeConfig, flags.Default)
-	err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile)
-	if err != nil {
-		if pErr := &(os.PathError{}); !errors.As(err, &pErr) {
-			fmt.Fprintf(os.Stderr, "Error parsing config file: %s\n",
-				err)
-			fmt.Fprintln(os.Stderr, usageMessage)
-			return nil, nil, err
-		}
-	}
-
-	// Parse command line options again to ensure they take precedence.
-	remainingArgs, err := parser.Parse()
-	if err != nil {
-		var flagsErr *flags.Error
-		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
-			fmt.Fprintln(os.Stderr, usageMessage)
-		}
-		return nil, nil, err
-	}
-
-	err = activeConfig.ResolveNetwork(parser)
-	if err != nil {
-		return nil, nil, err
-	}
-	// Handle environment variable expansion in the RPC certificate path.
-	activeConfig.RPCCert = cleanAndExpandPath(activeConfig.RPCCert)
-
-	// Add default port to RPC server based on --testnet and --simnet flags
-	// if needed.
-	activeConfig.RPCServer, err = activeConfig.NetParams().NormalizeRPCServerAddress(activeConfig.RPCServer)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return activeConfig, remainingArgs, nil
-}
-
-// createDefaultConfig creates a basic config file at the given destination path.
-// For this it tries to read the config file for the RPC server and extract the
-// RPC user and password from it.
-func createDefaultConfigFile(destinationPath, serverConfigPath string) error {
-	// Read the RPC server config
-	serverConfigFile, err := os.Open(serverConfigPath)
-	if os.IsNotExist(err) {
-		return errors.Errorf("the RPC server configuration file could not be found at %s", serverConfigPath)
-	}
-	if err != nil {
-		return err
-	}
-	defer serverConfigFile.Close()
-	content, err := ioutil.ReadAll(serverConfigFile)
-	if err != nil {
-		return err
-	}
-
-	// Extract the rpcuser
-	rpcUserRegexp, err := regexp.Compile(`(?m)^\s*rpcuser=([^\s]+)`)
-	if err != nil {
-		return err
-	}
-	userSubmatches := rpcUserRegexp.FindSubmatch(content)
-	if userSubmatches == nil {
-		// No user found, nothing to do
-		return nil
-	}
-
-	// Extract the rpcpass
-	rpcPassRegexp, err := regexp.Compile(`(?m)^\s*rpcpass=([^\s]+)`)
-	if err != nil {
-		return err
-	}
-	passSubmatches := rpcPassRegexp.FindSubmatch(content)
-	if passSubmatches == nil {
-		// No password found, nothing to do
-		return nil
-	}
-
-	// Extract the notls
-	noTLSRegexp, err := regexp.Compile(`(?m)^\s*notls=(0|1)(?:\s|$)`)
-	if err != nil {
-		return err
-	}
-	noTLSSubmatches := noTLSRegexp.FindSubmatch(content)
-
-	// Create the destination directory if it does not exists
-	err = os.MkdirAll(filepath.Dir(destinationPath), 0700)
-	if err != nil {
-		return err
-	}
-
-	// Create the destination file and write the rpcuser and rpcpass to it
-	dest, err := os.OpenFile(destinationPath,
-		os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		return err
-	}
-	defer dest.Close()
-
-	destString := fmt.Sprintf("rpcuser=%s\nrpcpass=%s\n",
-		string(userSubmatches[1]), string(passSubmatches[1]))
-	if noTLSSubmatches != nil {
-		destString += fmt.Sprintf("notls=%s\n", noTLSSubmatches[1])
-	}
-
-	dest.WriteString(destString)
-
-	return nil
+	err = cfg.ResolveNetwork(parser)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(args) != 1 {
+		return nil, errors.New("the last parameter must be the request in JSON format")
+	}
+	cfg.RequestJSON = args[0]
+
+	return cfg, nil
 }

cmd/kaspactl/docker/Dockerfile

@@ -0,0 +1,34 @@
+# -- multistage docker build: stage #1: build stage
+FROM golang:1.14-alpine AS build
+
+RUN mkdir -p /go/src/github.com/kaspanet/kaspad
+
+WORKDIR /go/src/github.com/kaspanet/kaspad
+
+RUN apk add --no-cache curl git openssh binutils gcc musl-dev
+RUN go get -u golang.org/x/lint/golint
+
+COPY go.mod .
+COPY go.sum .
+
+RUN go mod download
+
+COPY . .
+
+WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspactl
+
+RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
+RUN go vet ./...
+RUN golint -set_exit_status ./...
+RUN GOOS=linux go build -a -installsuffix cgo -o kaspactl .
+
+# --- multistage docker build: stage #2: runtime image
+FROM alpine
+WORKDIR /app
+
+RUN apk add --no-cache ca-certificates tini
+
+COPY --from=build /go/src/github.com/kaspanet/kaspad/cmd/kaspactl/kaspactl /app/
+
+USER nobody
+ENTRYPOINT [ "/sbin/tini", "--" ]

cmd/kaspactl/httpclient.go

@@ -1,129 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/json"
-	"github.com/pkg/errors"
-	"io/ioutil"
-	"net"
-	"net/http"
-
-	"github.com/btcsuite/go-socks/socks"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc/model"
-)
-
-// newHTTPClient returns a new HTTP client that is configured according to the
-// proxy and TLS settings in the associated connection configuration.
-func newHTTPClient(cfg *ConfigFlags) (*http.Client, error) {
-	// Configure proxy if needed.
-	var dial func(network, addr string) (net.Conn, error)
-	if cfg.Proxy != "" {
-		proxy := &socks.Proxy{
-			Addr:     cfg.Proxy,
-			Username: cfg.ProxyUser,
-			Password: cfg.ProxyPass,
-		}
-		dial = func(network, addr string) (net.Conn, error) {
-			c, err := proxy.Dial(network, addr)
-			if err != nil {
-				return nil, err
-			}
-			return c, nil
-		}
-	}
-
-	// Configure TLS if needed.
-	var tlsConfig *tls.Config
-	if !cfg.NoTLS && cfg.RPCCert != "" {
-		pem, err := ioutil.ReadFile(cfg.RPCCert)
-		if err != nil {
-			return nil, err
-		}
-
-		pool := x509.NewCertPool()
-		pool.AppendCertsFromPEM(pem)
-		tlsConfig = &tls.Config{
-			RootCAs:            pool,
-			InsecureSkipVerify: cfg.TLSSkipVerify,
-		}
-	}
-
-	// Create and return the new HTTP client potentially configured with a
-	// proxy and TLS.
-	client := http.Client{
-		Transport: &http.Transport{
-			Dial:            dial,
-			TLSClientConfig: tlsConfig,
-		},
-	}
-	return &client, nil
-}
-
-// sendPostRequest sends the marshalled JSON-RPC command using HTTP-POST mode
-// to the server described in the passed config struct. It also attempts to
-// unmarshal the response as a JSON-RPC response and returns either the result
-// field or the error field depending on whether or not there is an error.
-func sendPostRequest(marshalledJSON []byte, cfg *ConfigFlags) ([]byte, error) {
-	// Generate a request to the configured RPC server.
-	protocol := "http"
-	if !cfg.NoTLS {
-		protocol = "https"
-	}
-	url := protocol + "://" + cfg.RPCServer
-	bodyReader := bytes.NewReader(marshalledJSON)
-	httpRequest, err := http.NewRequest("POST", url, bodyReader)
-	if err != nil {
-		return nil, err
-	}
-	httpRequest.Close = true
-	httpRequest.Header.Set("Content-Type", "application/json")
-
-	// Configure basic access authorization.
-	httpRequest.SetBasicAuth(cfg.RPCUser, cfg.RPCPassword)
-
-	// Create the new HTTP client that is configured according to the user-
-	// specified options and submit the request.
-	httpClient, err := newHTTPClient(cfg)
-	if err != nil {
-		return nil, err
-	}
-	httpResponse, err := httpClient.Do(httpRequest)
-	if err != nil {
-		return nil, err
-	}
-
-	// Read the raw bytes and close the response.
-	respBytes, err := func() ([]byte, error) {
-		defer httpResponse.Body.Close()
-		return ioutil.ReadAll(httpResponse.Body)
-	}()
-	if err != nil {
-		return nil, errors.Wrap(err, "error reading json reply")
-	}
-
-	// Handle unsuccessful HTTP responses
-	if httpResponse.StatusCode < 200 || httpResponse.StatusCode >= 300 {
-		// Generate a standard error to return if the server body is
-		// empty. This should not happen very often, but it's better
-		// than showing nothing in case the target server has a poor
-		// implementation.
-		if len(respBytes) == 0 {
-			return nil, errors.Errorf("%d %s", httpResponse.StatusCode,
-				http.StatusText(httpResponse.StatusCode))
-		}
-		return nil, errors.Errorf("%s", respBytes)
-	}
-
-	// Unmarshal the response.
-	var resp model.Response
-	if err := json.Unmarshal(respBytes, &resp); err != nil {
-		return nil, err
-	}
-
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-	return resp.Result, nil
-}

cmd/kaspactl/kaspactl.go

@@ -1,169 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/pkg/errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/kaspanet/kaspad/infrastructure/network/rpc/model"
-)
-
-const (
-	showHelpMessage = "Specify -h to show available options"
-	listCmdMessage  = "Specify -l to list available commands"
-)
-
-// commandUsage display the usage for a specific command.
-func commandUsage(method string) {
-	usage, err := model.MethodUsageText(method)
-	if err != nil {
-		// This should never happen since the method was already checked
-		// before calling this function, but be safe.
-		fmt.Fprintln(os.Stderr, "Failed to obtain command usage:", err)
-		return
-	}
-
-	fmt.Fprintln(os.Stderr, "Usage:")
-	fmt.Fprintf(os.Stderr, "  %s\n", usage)
-}
-
-// usage displays the general usage when the help flag is not displayed and
-// and an invalid command was specified. The commandUsage function is used
-// instead when a valid command was specified.
-func usage(errorMessage string) {
-	appName := filepath.Base(os.Args[0])
-	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
-	fmt.Fprintln(os.Stderr, errorMessage)
-	fmt.Fprintln(os.Stderr, "Usage:")
-	fmt.Fprintf(os.Stderr, "  %s [OPTIONS] <command> <args...>\n\n",
-		appName)
-	fmt.Fprintln(os.Stderr, showHelpMessage)
-	fmt.Fprintln(os.Stderr, listCmdMessage)
-}
-
-func main() {
-	cfg, args, err := loadConfig()
-	if err != nil {
-		os.Exit(1)
-	}
-	if len(args) < 1 {
-		usage("No command specified")
-		os.Exit(1)
-	}
-
-	// Ensure the specified method identifies a valid registered command and
-	// is one of the usable types.
-	method := args[0]
-	usageFlags, err := model.MethodUsageFlags(method)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Unrecognized command '%s'\n", method)
-		fmt.Fprintln(os.Stderr, listCmdMessage)
-		os.Exit(1)
-	}
-	if usageFlags&unusableFlags != 0 {
-		fmt.Fprintf(os.Stderr, "The '%s' command can only be used via "+
-			"websockets\n", method)
-		fmt.Fprintln(os.Stderr, listCmdMessage)
-		os.Exit(1)
-	}
-
-	// Convert remaining command line args to a slice of interface values
-	// to be passed along as parameters to new command creation function.
-	//
-	// Since some commands, such as submitblock, can involve data which is
-	// too large for the Operating System to allow as a normal command line
-	// parameter, support using '-' as an argument to allow the argument
-	// to be read from a stdin pipe.
-	bio := bufio.NewReader(os.Stdin)
-	params := make([]interface{}, 0, len(args[1:]))
-	for _, arg := range args[1:] {
-		if arg == "-" {
-			param, err := bio.ReadString('\n')
-			if err != nil && err != io.EOF {
-				fmt.Fprintf(os.Stderr, "Failed to read data "+
-					"from stdin: %s\n", err)
-				os.Exit(1)
-			}
-			if err == io.EOF && len(param) == 0 {
-				fmt.Fprintln(os.Stderr, "Not enough lines "+
-					"provided on stdin")
-				os.Exit(1)
-			}
-			param = strings.TrimRight(param, "\r\n")
-			params = append(params, param)
-			continue
-		}
-
-		params = append(params, arg)
-	}
-
-	// Attempt to create the appropriate command using the arguments
-	// provided by the user.
-	cmd, err := model.NewCommand(method, params...)
-	if err != nil {
-		// Show the error along with its error code when it's a
-		// model.Error as it reallistcally will always be since the
-		// NewCommand function is only supposed to return errors of that
-		// type.
-		var rpcModelErr model.Error
-		if ok := errors.As(err, &rpcModelErr); ok {
-			fmt.Fprintf(os.Stderr, "%s error: %s (command code: %s)\n",
-				method, err, rpcModelErr.ErrorCode)
-			commandUsage(method)
-			os.Exit(1)
-		}
-
-		// The error is not a model.Error and this really should not
-		// happen. Nevertheless, fallback to just showing the error
-		// if it should happen due to a bug in the package.
-		fmt.Fprintf(os.Stderr, "%s error: %s\n", method, err)
-		commandUsage(method)
-		os.Exit(1)
-	}
-
-	// Marshal the command into a JSON-RPC byte slice in preparation for
-	// sending it to the RPC server.
-	marshalledJSON, err := model.MarshalCommand(1, cmd)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-
-	// Send the JSON-RPC request to the server using the user-specified
-	// connection configuration.
-	result, err := sendPostRequest(marshalledJSON, cfg)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-
-	// Choose how to display the result based on its type.
-	strResult := string(result)
-	if strings.HasPrefix(strResult, "{") || strings.HasPrefix(strResult, "[") {
-		var dst bytes.Buffer
-		if err := json.Indent(&dst, result, "", "  "); err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to format result: %s",
-				err)
-			os.Exit(1)
-		}
-		fmt.Println(dst.String())
-
-	} else if strings.HasPrefix(strResult, `"`) {
-		var str string
-		if err := json.Unmarshal(result, &str); err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to unmarshal result: %s",
-				err)
-			os.Exit(1)
-		}
-		fmt.Println(str)
-
-	} else if strResult != "null" {
-		fmt.Println(strResult)
-	}
-}