downsize up rpc commands

app/appmessage/message.go

@@ -163,30 +163,20 @@ const (
 	CmdGetMempoolEntriesByAddressesResponseMessage
 	CmdGetCoinSupplyRequestMessage
 	CmdGetCoinSupplyResponseMessage
-	CmdGetAcceptingBlockHashOfTxRequestMessage
-	CmdGetAcceptingBlockHashOfTxResponseMessage
 	CmdGetAcceptingBlockHashesOfTxsRequestMessage
 	CmdGetAcceptingBlockHashesOfTxsResponseMessage
-	CmdGetAcceptingBlockOfTxRequestMessage
-	CmdGetAcceptingBlockOfTxResponseMessage
-	CmdGetAcceptingBlocksOfTxsRequestMessage
-	CmdGetAcceptingBlocksOfTxsResponseMessage
-	CmdGetIncludingBlockHashOfTxRequestMessage
-	CmdGetIncludingBlockHashOfTxResponseMessage
-	CmdGetIncludingBlockHashesOfTxsRequestMessage
-	CmdGetIncludingBlockHashesOfTxsResponseMessage
-	CmdGetIncludingBlockOfTxRequestMessage
-	CmdGetIncludingBlockOfTxResponseMessage
-	CmdGetIncludingBlocksOfTxsRequestMessage
-	CmdGetIncludingBlocksOfTxsResponseMessage
-	CmdGetTxRequestMessage
-	CmdGetTxResponseMessage
 	CmdGetTxsRequestMessage
 	CmdGetTxsResponseMessage
-	CmdGetTxConfirmationsRequestMessage
-	CmdGetTxConfirmationsResponseMessage
 	CmdGetTxsConfirmationsRequestMessage
 	CmdGetTxsConfirmationsResponseMessage
+	CmdNotifyTxsConfirmationChangedRequestMessage
+	CmdNotifyTxsConfirmationChangedResponseMessage
+	CmdStartNotifyingTxsConfirmationChangedRequestMessage
+	CmdStartNotifyingTxsConfirmationChangedResponseMessage
+	CmdStopNotifyingTxsConfirmationChangedRequestMessage
+	CmdStopNotifyingTxsConfirmationChangedResponseMessage
+	CmdModifyNotifyTxsConfirmationChangedParamsRequestMessage
+	CmdModifyNotifyTxsConfirmationChangedParamsResponseMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -324,28 +314,10 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdGetMempoolEntriesByAddressesResponseMessage:                "GetMempoolEntriesByAddressesResponse",
 	CmdGetCoinSupplyRequestMessage:                                "GetCoinSupplyRequest",
 	CmdGetCoinSupplyResponseMessage:                               "GetCoinSupplyResponse",
-	CmdGetAcceptingBlockHashOfTxRequestMessage:                    "GetAcceptingBlockHashOfTxRequest",
-	CmdGetAcceptingBlockHashOfTxResponseMessage:                   "GetAcceptingBlockHashOfTxResponse",
 	CmdGetAcceptingBlockHashesOfTxsRequestMessage:                 "GetAcceptingBlockHashesOfTxsRequest",
 	CmdGetAcceptingBlockHashesOfTxsResponseMessage:                "GetAcceptingBlockHashesOfTxsResponse",
-	CmdGetAcceptingBlockOfTxRequestMessage:                        "GetAcceptingBlockOfTxRequest",
-	CmdGetAcceptingBlockOfTxResponseMessage:                       "GetAcceptingBlockOfTxResponse",
-	CmdGetAcceptingBlocksOfTxsRequestMessage:                      "GetAcceptingBlocksOfTxsRequest",
-	CmdGetAcceptingBlocksOfTxsResponseMessage:                     "GetAcceptingBlocksOfTxsResponse",
-	CmdGetIncludingBlockHashOfTxRequestMessage:                    "GetIncludingBlockHashOfTxRequest",
-	CmdGetIncludingBlockHashOfTxResponseMessage:                   "GetIncludingBlockHashOfTxResponse",
-	CmdGetIncludingBlockHashesOfTxsRequestMessage:                 "GetIncludingBlockHashesOfTxsRequest",
-	CmdGetIncludingBlockHashesOfTxsResponseMessage:                "GetIncludingBlockHashesOfTxsResponse",
-	CmdGetIncludingBlockOfTxRequestMessage:                        "GetIncludingBlockOfTxRequest",
-	CmdGetIncludingBlockOfTxResponseMessage:                       "GetIncludingBlockOfTxResponse",
-	CmdGetIncludingBlocksOfTxsRequestMessage:                      "GetIncludingBlocksOfTxsRequest",
-	CmdGetIncludingBlocksOfTxsResponseMessage:                     "GetIncludingBlocksOfTxsResponse",
-	CmdGetTxRequestMessage:                                        "GetTxRequest",
-	CmdGetTxResponseMessage:                                       "GetTxResponse",
 	CmdGetTxsRequestMessage:                                       "GetTxsRequest",
 	CmdGetTxsResponseMessage:                                      "GetTxsResponse",
-	CmdGetTxConfirmationsRequestMessage:                           "GetTxConfirmationsRequest",
-	CmdGetTxConfirmationsResponseMessage:                          "GetTxConfirmationsResponse",
 	CmdGetTxsConfirmationsRequestMessage:                          "GetTxsConfirmationsRequest",
 	CmdGetTxsConfirmationsResponseMessage:                         "GetTxsConfirmationsResponse",
 }

app/appmessage/rpc_notify_addresses_txs.go

@@ -0,0 +1 @@
+

app/appmessage/rpc_notify_txs_confirmation_changed.go

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

app/rpc/rpc.go

@@ -51,17 +51,8 @@ var handlers = map[appmessage.MessageCommand]handler{
 	appmessage.CmdNotifyNewBlockTemplateRequestMessage:                      rpchandlers.HandleNotifyNewBlockTemplate,
 	appmessage.CmdGetCoinSupplyRequestMessage:                               rpchandlers.HandleGetCoinSupply,
 	appmessage.CmdGetMempoolEntriesByAddressesRequestMessage:                rpchandlers.HandleGetMempoolEntriesByAddresses,
-	appmessage.CmdGetAcceptingBlockHashOfTxRequestMessage:                   rpchandlers.HandleGetAcceptingBlockHashOfTx,
 	appmessage.CmdGetAcceptingBlockHashesOfTxsRequestMessage:                rpchandlers.HandleGetAcceptingBlockHashesOfTxs,
-	appmessage.CmdGetAcceptingBlockOfTxRequestMessage:                       rpchandlers.HandleGetAcceptingBlockOfTx,
-	appmessage.CmdGetAcceptingBlocksOfTxsRequestMessage:                     rpchandlers.HandleGetAcceptingBlocksOfTxs,
-	appmessage.CmdGetIncludingBlockHashOfTxRequestMessage:                   rpchandlers.HandleGetIncludingBlockHashOfTx,
-	appmessage.CmdGetIncludingBlockHashesOfTxsRequestMessage:                rpchandlers.HandleGetIncludingBlockHashesOfTxs,
-	appmessage.CmdGetIncludingBlockOfTxRequestMessage:                       rpchandlers.HandleGetIncludingBlockOfTx,
-	appmessage.CmdGetIncludingBlocksOfTxsRequestMessage:                     rpchandlers.HandleGetIncludingBlocksOfTxs,
-	appmessage.CmdGetTxRequestMessage:                                       rpchandlers.HandleGetTx,
 	appmessage.CmdGetTxsRequestMessage:                                      rpchandlers.HandleGetTxs,
-	appmessage.CmdGetTxConfirmationsRequestMessage:                          rpchandlers.HandleGetTxConfirmations,
 	appmessage.CmdGetTxsConfirmationsRequestMessage:                         rpchandlers.HandleGetTxsConfirmations,
 }
 

app/rpc/rpchandlers/get_accepting_block_of_tx.go

@@ -1,64 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetAcceptingBlockOfTx handles the respectively named RPC command
-func HandleGetAcceptingBlockOfTx(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetAcceptingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getAcceptingBlockOfTxRequest := request.(*appmessage.GetAcceptingBlockOfTxRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getAcceptingBlockOfTxRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetAcceptingBlockOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	acceptingBlock, found, err := context.TXIndex.TXAcceptingBlock(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetAcceptingBlockOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetAcceptingBlockOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find accepting block in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	rpcAcceptingBlock := appmessage.DomainBlockToRPCBlock(acceptingBlock)
-	err = context.PopulateBlockWithVerboseData(rpcAcceptingBlock, acceptingBlock.Header, acceptingBlock, getAcceptingBlockOfTxRequest.IncludeTransactions)
-	if err != nil {
-		if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
-			errorMessage := &appmessage.GetAcceptingBlockOfTxResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(acceptingBlock).String())
-			return errorMessage, nil
-		}
-		return nil, err
-	}
-
-	response := appmessage.NewGetAcceptingBlockOfTxResponse(rpcAcceptingBlock)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_accepting_blockhash_of_tx.go

@@ -1,52 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetAcceptingBlockHashOfTx handles the respectively named RPC command
-func HandleGetAcceptingBlockHashOfTx(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetAcceptingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getAcceptingBlockHashOfTxRequest := request.(*appmessage.GetAcceptingBlockHashOfTxRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getAcceptingBlockHashOfTxRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetAcceptingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	acceptingBlockHash, found, err := context.TXIndex.TXAcceptingBlockHash(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetAcceptingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetAcceptingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find accepting block hash in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	response := appmessage.NewGetAcceptingBlockHashOfTxResponse(acceptingBlockHash.String())
-
-	return response, nil
-}

app/rpc/rpchandlers/get_accepting_blockhashes_of_txs copy.go

@@ -1,58 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetIncludingBlockHashesOfTxs handles the respectively named RPC command
-func HandleGetIncludingBlockHashesOfTxs(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	var err error
-
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetIncludingBlockHashesOfTxsResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getIncludingBlockHashesOfTxsRequest := request.(*appmessage.GetIncludingBlockHashesOfTxsRequestMessage)
-
-	domainTxIDs := make([]*externalapi.DomainTransactionID, len(getIncludingBlockHashesOfTxsRequest.TxIDs))
-	for i := range domainTxIDs {
-		domainTxIDs[i], err = externalapi.NewDomainTransactionIDFromString(getIncludingBlockHashesOfTxsRequest.TxIDs[i])
-		if err != nil {
-			errorMessage := &appmessage.GetIncludingBlockHashesOfTxsResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("error parsing txID: %s", getIncludingBlockHashesOfTxsRequest.TxIDs[i])
-			return errorMessage, nil
-		}
-	}
-
-	includingBlockHashes, _, err := context.TXIndex.TXIncludingBlockHashes(domainTxIDs)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlockHashesOfTxsResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	txIDBlockHashpairs := make([]*appmessage.TxIDBlockHashPair, len(includingBlockHashes))
-	i := 0
-	for txID, blockHash := range includingBlockHashes {
-		txIDBlockHashpairs[i] = &appmessage.TxIDBlockHashPair{
-			TxID: txID.String(),
-			Hash: blockHash.String(),
-		}
-		i++
-	}
-
-	response := appmessage.NewGetIncludingBlockHashesOfTxsResponse(txIDBlockHashpairs)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_accepting_blocks_of_txs.go

@@ -1,68 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetAcceptingBlocksOfTxs handles the respectively named RPC command
-func HandleGetAcceptingBlocksOfTxs(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	var err error
-
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetAcceptingBlocksOfTxsResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getAcceptingBlocksOfTxsRequest := request.(*appmessage.GetAcceptingBlocksOfTxsRequestMessage)
-
-	domainTxIDs := make([]*externalapi.DomainTransactionID, len(getAcceptingBlocksOfTxsRequest.TxIDs))
-	for i := range domainTxIDs {
-		domainTxIDs[i], err = externalapi.NewDomainTransactionIDFromString(getAcceptingBlocksOfTxsRequest.TxIDs[i])
-		if err != nil {
-			errorMessage := &appmessage.GetAcceptingBlocksOfTxsResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("error parsing txID: %s, %s", getAcceptingBlocksOfTxsRequest.TxIDs[i], err.Error())
-			return errorMessage, nil
-		}
-	}
-	acceptingBlockHashes, _, err := context.TXIndex.TXAcceptingBlocks(domainTxIDs)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetAcceptingBlocksOfTxsResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	txIDBlockPairs := make([]*appmessage.TxIDBlockPair, len(acceptingBlockHashes))
-	i := 0
-	for txID, acceptingBlock := range acceptingBlockHashes {
-		rpcAcceptingBlock := appmessage.DomainBlockToRPCBlock(acceptingBlock)
-		err = context.PopulateBlockWithVerboseData(rpcAcceptingBlock, acceptingBlock.Header, acceptingBlock, getAcceptingBlocksOfTxsRequest.IncludeTransactions)
-		if err != nil {
-			if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
-				errorMessage := &appmessage.GetAcceptingBlockOfTxResponseMessage{}
-				errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(acceptingBlock).String())
-				return errorMessage, nil
-			}
-			return nil, err
-		}
-		txIDBlockPairs[i] = &appmessage.TxIDBlockPair{
-			TxID:  txID.String(),
-			Block: rpcAcceptingBlock,
-		}
-		i++
-	}
-
-	response := appmessage.NewGetAcceptingBlocksOfTxsResponse(txIDBlockPairs)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_including_block_of_tx.go

@@ -1,64 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetIncludingBlockOfTx handles the respectively named RPC command
-func HandleGetIncludingBlockOfTx(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetIncludingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getIncludingBlockOfTxRequest := request.(*appmessage.GetIncludingBlockOfTxRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getIncludingBlockOfTxRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlockOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	includingBlock, found, err := context.TXIndex.TXIncludingBlock(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlockOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetIncludingBlockOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find including block in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	rpcIncludingBlock := appmessage.DomainBlockToRPCBlock(includingBlock)
-	err = context.PopulateBlockWithVerboseData(rpcIncludingBlock, includingBlock.Header, includingBlock, getIncludingBlockOfTxRequest.IncludeTransactions)
-	if err != nil {
-		if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
-			errorMessage := &appmessage.GetIncludingBlockOfTxResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(includingBlock).String())
-			return errorMessage, nil
-		}
-		return nil, err
-	}
-
-	response := appmessage.NewGetIncludingBlockOfTxResponse(rpcIncludingBlock)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_including_blockhash_of_tx.go

@@ -1,52 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetIncludingBlockHashOfTx handles the respectively named RPC command
-func HandleGetIncludingBlockHashOfTx(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetIncludingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getIncludingBlockHashOfTxRequest := request.(*appmessage.GetIncludingBlockHashOfTxRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getIncludingBlockHashOfTxRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	includingBlockHash, found, err := context.TXIndex.TXIncludingBlockHash(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetIncludingBlockHashOfTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find including block hash in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	response := appmessage.NewGetIncludingBlockHashOfTxResponse(includingBlockHash.String())
-
-	return response, nil
-}

app/rpc/rpchandlers/get_including_blocks_of_txs.go

@@ -1,69 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetIncludingBlocksOfTxs handles the respectively named RPC command
-func HandleGetIncludingBlocksOfTxs(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	var err error
-
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetIncludingBlocksOfTxsResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getIncludingBlocksOfTxsRequest := request.(*appmessage.GetIncludingBlocksOfTxsRequestMessage)
-
-	domainTxIDs := make([]*externalapi.DomainTransactionID, len(getIncludingBlocksOfTxsRequest.TxIDs))
-	for i := range domainTxIDs {
-		domainTxIDs[i], err = externalapi.NewDomainTransactionIDFromString(getIncludingBlocksOfTxsRequest.TxIDs[i])
-		if err != nil {
-			errorMessage := &appmessage.GetIncludingBlocksOfTxsResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("error parsing txID: %s, %s", getIncludingBlocksOfTxsRequest.TxIDs[i], err.Error())
-			return errorMessage, nil
-		}
-	}
-
-	includingBlockHashes, _, err := context.TXIndex.TXIncludingBlocks(domainTxIDs)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetIncludingBlocksOfTxsResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	txIDBlockPairs := make([]*appmessage.TxIDBlockPair, len(includingBlockHashes))
-	i := 0
-	for txID, includingBlock := range includingBlockHashes {
-		rpcIncludingBlock := appmessage.DomainBlockToRPCBlock(includingBlock)
-		err = context.PopulateBlockWithVerboseData(rpcIncludingBlock, includingBlock.Header, includingBlock, getIncludingBlocksOfTxsRequest.IncludeTransactions)
-		if err != nil {
-			if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
-				errorMessage := &appmessage.GetIncludingBlockOfTxResponseMessage{}
-				errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(includingBlock).String())
-				return errorMessage, nil
-			}
-			return nil, err
-		}
-		txIDBlockPairs[i] = &appmessage.TxIDBlockPair{
-			TxID:  txID.String(),
-			Block: rpcIncludingBlock,
-		}
-		i++
-	}
-
-	response := appmessage.NewGetIncludingBlocksOfTxsResponse(txIDBlockPairs)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_tx.go

@@ -1,80 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetTx handles the respectively named RPC command
-func HandleGetTx(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getTxRequest := request.(*appmessage.GetTxRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getTxRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	transaction, found, err := context.TXIndex.GetTX(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find tx in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	blockForVerboseData, found, err := context.TXIndex.TXAcceptingBlock(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-	if !found {
-		errorMessage := &appmessage.GetTxResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Could not find accepting block in the txindex database for txID: %s", domainTxID.String())
-		return errorMessage, nil
-	}
-
-	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-	err = context.PopulateTransactionWithVerboseData(rpcTransaction, blockForVerboseData.Header)
-	if err != nil {
-		if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
-			errorMessage := &appmessage.GetTxResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(blockForVerboseData).String())
-			return errorMessage, nil
-		}
-		return nil, err
-	}
-
-	response := appmessage.NewGetTxResponse(rpcTransaction)
-
-	return response, nil
-}

app/rpc/rpchandlers/get_tx_confirmations.go

@@ -1,47 +0,0 @@
-package rpchandlers
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-
-	"github.com/pkg/errors"
-)
-
-// HandleGetTxConfirmations handles the respectively named RPC command
-func HandleGetTxConfirmations(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	if !context.Config.TXIndex {
-		errorMessage := &appmessage.GetTxConfirmationsResponseMessage{}
-		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
-		return errorMessage, nil
-	}
-
-	getTxConfirmationsRequest := request.(*appmessage.GetTxConfirmationsRequestMessage)
-
-	domainTxID, err := externalapi.NewDomainTransactionIDFromString(getTxConfirmationsRequest.TxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetTxConfirmationsResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	confirmations, _, err := context.TXIndex.GetTXConfirmations(domainTxID)
-	if err != nil {
-		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, &rpcError) {
-			return nil, err
-		}
-		errorMessage := &appmessage.GetTxConfirmationsResponseMessage{}
-		errorMessage.Error = rpcError
-		return errorMessage, nil
-	}
-
-	response := appmessage.NewGetTxConfirmationsResponse(confirmations)
-
-	return response, nil
-}

cmd/kaspactl/commands.go

@@ -15,19 +15,8 @@ var commandTypes = []reflect.Type{
 	reflect.TypeOf(protowire.KaspadMessage_GetCurrentNetworkRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetInfoRequest{}),
 
-	reflect.TypeOf(protowire.KaspadMessage_GetAcceptingBlockHashOfTxRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetAcceptingBlockHashesOfTxsRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetAcceptingBlockOfTxRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetAcceptingBlocksOfTxsRequest{}),
-
-	reflect.TypeOf(protowire.KaspadMessage_GetIncludingBlockHashOfTxRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetIncludingBlockHashesOfTxsRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetIncludingBlockOfTxRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetIncludingBlocksOfTxsRequest{}),
-
-	reflect.TypeOf(protowire.KaspadMessage_GetTxRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetTxsRequest{}),
-	reflect.TypeOf(protowire.KaspadMessage_GetTxConfirmationsRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetTxsConfirmationsRequest{}),
 
 	reflect.TypeOf(protowire.KaspadMessage_GetBlockRequest{}),

infrastructure/network/netadapter/server/grpcserver/protowire/messages.proto

@@ -140,48 +140,22 @@ message KaspadMessage {
     GetCoinSupplyRequestMessage getCoinSupplyRequest = 1086;
     GetCoinSupplyResponseMessage getCoinSupplyResponse= 1087;
 
-    GetAcceptingBlockHashOfTxRequestMessage  getAcceptingBlockHashOfTxRequest = 1088;
+    GetAcceptingBlockHashesOfTxsRequestMessage  getAcceptingBlockHashesOfTxsRequest = 1088;
-    GetAcceptingBlockHashOfTxResponseMessage getAcceptingBlockHashOfTxResponse = 1089;
+    GetAcceptingBlockHashesOfTxsResponseMessage getAcceptingBlockHashesOfTxsResponse = 1089;
-    GetAcceptingBlockHashesOfTxsRequestMessage  getAcceptingBlockHashesOfTxsRequest = 1090;
+    GetTxsRequestMessage  getTxsRequest = 1090;
-    GetAcceptingBlockHashesOfTxsResponseMessage getAcceptingBlockHashesOfTxsResponse = 1091;
+    GetTxsResponseMessage getTxsResponse = 1091;
-    GetAcceptingBlockOfTxRequestMessage  getAcceptingBlockOfTxRequest = 1092;
+    GetTxsConfirmationsRequestMessage  getTxsConfirmationsRequest = 1092;
-    GetAcceptingBlockOfTxResponseMessage getAcceptingBlockOfTxResponse = 1093;
+    GetTxsConfirmationsResponseMessage getTxsConfirmationsResponse = 1093;
-    GetAcceptingBlocksOfTxsRequestMessage  getAcceptingBlocksOfTxsRequest = 1094;
+    NotifyTxsConfirmationChangedRequestMessage  notifyTxsConfirmationChangedRequst = 1094;
-    GetAcceptingBlocksOfTxsResponseMessage getAcceptingBlocksOfTxsResponse = 1095;
+    NotifyTxsConfirmationChangedResponseMessage notifyTxsConfirmationChangedResponse = 1095;
-    GetIncludingBlockHashOfTxRequestMessage  getIncludingBlockHashOfTxRequest = 1096;
+    ModifyNotifyingTxsConfirmationChangedRequestMessage modifyNotifyingTxsConfirmationChangedRequest = 1096;
-    GetIncludingBlockHashOfTxResponseMessage getIncludingBlockHashOfTxResponse = 1097;
+    ModifyNotifyingTxsConfirmationChangedResponseMessage modifyNotifyingTxsConfirmationChangedResponse = 1097;
-    GetIncludingBlockHashesOfTxsRequestMessage  getIncludingBlockHashesOfTxsRequest = 1098;
+    TxsConfirmationChangedNotificationMessage txsConfirmationChangedNotification = 1098;
-    GetIncludingBlockHashesOfTxsResponseMessage getIncludingBlockHashesOfTxsResponse = 1099;
+    NotifyAddressesTxsRequestMessage notifyAddressesTxsRequest = 1099;
-    GetIncludingBlockOfTxRequestMessage  getIncludingBlockOfTxRequest = 1100;
+    NotifyAddressesTxsResponseMessage notifyAddressesTxsResponse = 1100;
-    GetIncludingBlockOfTxResponseMessage getIncludingBlockOfTxResponse = 1101;
+    ModifyNotifyingAddressesTxsRequestMessage modifyNotifyingAddressesTxsRequest = 1101;
-    GetIncludingBlocksOfTxsRequestMessage  getIncludingBlocksOfTxsRequest = 1102;
+    ModifyNotifyingAddressesTxsResponseMessage modifyNotifyingAddressesTxsResponse = 1102;
-    GetIncludingBlocksOfTxsResponseMessage getIncludingBlocksOfTxsResponse = 1103;
+    AddressesTxsNotificationMessage AddressesTxsNotification = 1103;
-    GetTxRequestMessage  getTxRequest = 1104;
-    GetTxResponseMessage getTxResponse = 1105;
-    GetTxsRequestMessage  getTxsRequest = 1106;
-    GetTxsResponseMessage getTxsResponse = 1107;
-    GetTxConfirmationsRequestMessage  getTxConfirmationsRequest = 1108;
-    GetTxConfirmationsResponseMessage getTxConfirmationsResponse = 1109;
-    GetTxsConfirmationsRequestMessage  getTxsConfirmationsRequest = 1110;
-    GetTxsConfirmationsResponseMessage getTxsConfirmationsResponse = 1111;
-    NotifyTxsConfirmationChangedRequestMessage  notifyTxsConfirmationChangedRequst = 1112;
-    NotifyTxsConfirmationChangedResponseMessage notifyTxsConfirmationChangedResponse = 1113;
-    StopNotifyTxsConfirmationChangedRequestMessage stopNotifyTxsConfirmationChangedRequest = 1114;
-    StopNotifyTxsConfirmationChangedResponseMessage stopNotifyTxsConfirmationChangedResponse = 1115;
-    StartNotifyTxsConfirmationChangedRequestMessage startNotifyTxsConfirmationChangedRequest = 1116;
-    StartNotifyTxsConfirmationChangedResponseMessage startNotifyTxsConfirmationChangedResponse = 1117;
-    ModifyNotifyTxsConfirmationChangedParamsRequestMessage modifyNotifyTxsConfirmationChangedParamsRequest = 1118;
-    ModifyNotifyTxsConfirmationChangedParamsResponseMessage modifyNotifyTxsConfirmationChangedParamsResponse = 1119;
-    TxsConfirmationChangedNotificationMessage txsConfirmationChangedNotification = 1120;
-    NotifyAddressesTxsRequestMessage notifyAddressesTxsRequest = 1121;
-    NotifyAddressesTxsResponseMessage notifyAddressesTxsResponse = 1122;
-    StopNotifyAddressesTxsRequestMessage stopNotifyAddressesTxsRequest = 1123;
-    StopNotifyAddressesTxsResponseMessage stopNotifyAddressesTxsResponse = 1124;
-    StartNotifyAddressesTxsRequestMessage startNotifyAddressesTxsRequest = 1125;
-    StartNotifyAddressesTxsResponseMessage startNotifyAddressesTxsResponse = 1126;
-    ModifyNotifyAddressesTxsParamsRequestMessage modifyNotifyAddressesTxsParamsRequest = 1127;
-    ModifyNotifyAddressesTxsParamsResponseMessage modifyNotifyAddressesTxsParamsResponse = 1128;
-    AddressesTxsNotificationMessage AddressesTxsNotification = 1129;
   }
 }
 

infrastructure/network/netadapter/server/grpcserver/protowire/rpc.md

@@ -119,45 +119,21 @@
     - [RpcTxIDBlockPair](#protowire.RpcTxIDBlockPair)
     - [GetAcceptingBlockHashesOfTxsRequestMessage](#protowire.GetAcceptingBlockHashesOfTxsRequestMessage)
     - [GetAcceptingBlockHashesOfTxsResponseMessage](#protowire.GetAcceptingBlockHashesOfTxsResponseMessage)
-    - [GetAcceptingBlockOfTxRequestMessage](#protowire.GetAcceptingBlockOfTxRequestMessage)
-    - [GetAcceptingBlockOfTxResponseMessage](#protowire.GetAcceptingBlockOfTxResponseMessage)
-    - [GetAcceptingBlocksOfTxsRequestMessage](#protowire.GetAcceptingBlocksOfTxsRequestMessage)
-    - [GetAcceptingBlocksOfTxsResponseMessage](#protowire.GetAcceptingBlocksOfTxsResponseMessage)
-    - [GetIncludingBlockHashOfTxRequestMessage](#protowire.GetIncludingBlockHashOfTxRequestMessage)
-    - [GetIncludingBlockHashOfTxResponseMessage](#protowire.GetIncludingBlockHashOfTxResponseMessage)
-    - [GetIncludingBlockHashesOfTxsRequestMessage](#protowire.GetIncludingBlockHashesOfTxsRequestMessage)
-    - [GetIncludingBlockHashesOfTxsResponseMessage](#protowire.GetIncludingBlockHashesOfTxsResponseMessage)
-    - [GetIncludingBlockOfTxRequestMessage](#protowire.GetIncludingBlockOfTxRequestMessage)
-    - [GetIncludingBlockOfTxResponseMessage](#protowire.GetIncludingBlockOfTxResponseMessage)
-    - [GetIncludingBlocksOfTxsRequestMessage](#protowire.GetIncludingBlocksOfTxsRequestMessage)
-    - [GetIncludingBlocksOfTxsResponseMessage](#protowire.GetIncludingBlocksOfTxsResponseMessage)
-    - [GetTxRequestMessage](#protowire.GetTxRequestMessage)
-    - [GetTxResponseMessage](#protowire.GetTxResponseMessage)
     - [GetTxsRequestMessage](#protowire.GetTxsRequestMessage)
     - [GetTxsResponseMessage](#protowire.GetTxsResponseMessage)
-    - [GetTxConfirmationsRequestMessage](#protowire.GetTxConfirmationsRequestMessage)
-    - [GetTxConfirmationsResponseMessage](#protowire.GetTxConfirmationsResponseMessage)
     - [GetTxsConfirmationsRequestMessage](#protowire.GetTxsConfirmationsRequestMessage)
     - [GetTxsConfirmationsResponseMessage](#protowire.GetTxsConfirmationsResponseMessage)
     - [NotifyTxsConfirmationChangedRequestMessage](#protowire.NotifyTxsConfirmationChangedRequestMessage)
     - [NotifyTxsConfirmationChangedResponseMessage](#protowire.NotifyTxsConfirmationChangedResponseMessage)
     - [TxsConfirmationChangedNotificationMessage](#protowire.TxsConfirmationChangedNotificationMessage)
-    - [StopNotifyTxsConfirmationChangedRequestMessage](#protowire.StopNotifyTxsConfirmationChangedRequestMessage)
+    - [ModifyNotifyingTxsConfirmationChangedRequestMessage](#protowire.ModifyNotifyingTxsConfirmationChangedRequestMessage)
-    - [StopNotifyTxsConfirmationChangedResponseMessage](#protowire.StopNotifyTxsConfirmationChangedResponseMessage)
+    - [ModifyNotifyingTxsConfirmationChangedResponseMessage](#protowire.ModifyNotifyingTxsConfirmationChangedResponseMessage)
-    - [StartNotifyTxsConfirmationChangedRequestMessage](#protowire.StartNotifyTxsConfirmationChangedRequestMessage)
-    - [StartNotifyTxsConfirmationChangedResponseMessage](#protowire.StartNotifyTxsConfirmationChangedResponseMessage)
-    - [ModifyNotifyTxsConfirmationChangedParamsRequestMessage](#protowire.ModifyNotifyTxsConfirmationChangedParamsRequestMessage)
-    - [ModifyNotifyTxsConfirmationChangedParamsResponseMessage](#protowire.ModifyNotifyTxsConfirmationChangedParamsResponseMessage)
     - [TxEntryByAddress](#protowire.TxEntryByAddress)
     - [TxEntriesByAddresses](#protowire.TxEntriesByAddresses)
     - [NotifyAddressesTxsRequestMessage](#protowire.NotifyAddressesTxsRequestMessage)
     - [NotifyAddressesTxsResponseMessage](#protowire.NotifyAddressesTxsResponseMessage)
-    - [StopNotifyAddressesTxsRequestMessage](#protowire.StopNotifyAddressesTxsRequestMessage)
+    - [ModifyNotifyingAddressesTxsRequestMessage](#protowire.ModifyNotifyingAddressesTxsRequestMessage)
-    - [StopNotifyAddressesTxsResponseMessage](#protowire.StopNotifyAddressesTxsResponseMessage)
+    - [ModifyNotifyingAddressesTxsResponseMessage](#protowire.ModifyNotifyingAddressesTxsResponseMessage)
-    - [StartNotifyAddressesTxsRequestMessage](#protowire.StartNotifyAddressesTxsRequestMessage)
-    - [StartNotifyAddressesTxsResponseMessage](#protowire.StartNotifyAddressesTxsResponseMessage)
-    - [ModifyNotifyAddressesTxsParamsRequestMessage](#protowire.ModifyNotifyAddressesTxsParamsRequestMessage)
-    - [ModifyNotifyAddressesTxsParamsResponseMessage](#protowire.ModifyNotifyAddressesTxsParamsResponseMessage)
     - [AddressesTxsNotificationMessage](#protowire.AddressesTxsNotificationMessage)
   
     - [SubmitBlockResponseMessage.RejectReason](#protowire.SubmitBlockResponseMessage.RejectReason)
@@ -2015,227 +1991,6 @@ Kaspad most be started with the `--txindex` flag for this Request to work.
 
 
 
-<a name="protowire.GetAcceptingBlockOfTxRequestMessage"></a>
-
-### GetAcceptingBlockOfTxRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txID | [string](#string) |  |  |
-| includeTransactions | [bool](#bool) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetAcceptingBlockOfTxResponseMessage"></a>
-
-### GetAcceptingBlockOfTxResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| block | [RpcBlock](#protowire.RpcBlock) |  |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetAcceptingBlocksOfTxsRequestMessage"></a>
-
-### GetAcceptingBlocksOfTxsRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDs | [string](#string) | repeated |  |
-| includeTransactions | [bool](#bool) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetAcceptingBlocksOfTxsResponseMessage"></a>
-
-### GetAcceptingBlocksOfTxsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDBlockPairs | [RpcTxIDBlockPair](#protowire.RpcTxIDBlockPair) | repeated |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockHashOfTxRequestMessage"></a>
-
-### GetIncludingBlockHashOfTxRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txID | [string](#string) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockHashOfTxResponseMessage"></a>
-
-### GetIncludingBlockHashOfTxResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| hash | [string](#string) |  |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockHashesOfTxsRequestMessage"></a>
-
-### GetIncludingBlockHashesOfTxsRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDs | [string](#string) | repeated |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockHashesOfTxsResponseMessage"></a>
-
-### GetIncludingBlockHashesOfTxsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDBlockHashPairs | [RpcTxIDBlockHashPair](#protowire.RpcTxIDBlockHashPair) | repeated |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockOfTxRequestMessage"></a>
-
-### GetIncludingBlockOfTxRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txID | [string](#string) |  |  |
-| includeTransactions | [bool](#bool) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlockOfTxResponseMessage"></a>
-
-### GetIncludingBlockOfTxResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| block | [RpcBlock](#protowire.RpcBlock) |  |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlocksOfTxsRequestMessage"></a>
-
-### GetIncludingBlocksOfTxsRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDs | [string](#string) | repeated |  |
-| includeTransactions | [bool](#bool) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetIncludingBlocksOfTxsResponseMessage"></a>
-
-### GetIncludingBlocksOfTxsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txIDBlockPairs | [RpcTxIDBlockPair](#protowire.RpcTxIDBlockPair) | repeated |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetTxRequestMessage"></a>
-
-### GetTxRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txID | [string](#string) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetTxResponseMessage"></a>
-
-### GetTxResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| transaction | [RpcTransaction](#protowire.RpcTransaction) |  |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
 <a name="protowire.GetTxsRequestMessage"></a>
 
 ### GetTxsRequestMessage
@@ -2267,37 +2022,6 @@ Kaspad most be started with the `--txindex` flag for this Request to work.
 
 
 
-<a name="protowire.GetTxConfirmationsRequestMessage"></a>
-
-### GetTxConfirmationsRequestMessage
-Kaspad most be started with the `--txindex` flag for this Request to work.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| txID | [string](#string) |  |  |
-
-
-
-
-
-
-<a name="protowire.GetTxConfirmationsResponseMessage"></a>
-
-### GetTxConfirmationsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| confirmations | [int64](#int64) |  |  |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
 <a name="protowire.GetTxsConfirmationsRequestMessage"></a>
 
 ### GetTxsConfirmationsRequestMessage
@@ -2381,76 +2105,17 @@ TxsConfirmationChangedNotificationMessage is the notification about txs pertaini
 
 
 
-<a name="protowire.StopNotifyTxsConfirmationChangedRequestMessage"></a>
+<a name="protowire.ModifyNotifyingTxsConfirmationChangedRequestMessage"></a>
 
-### StopNotifyTxsConfirmationChangedRequestMessage
+### ModifyNotifyingTxsConfirmationChangedRequestMessage
-most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
+ModifyNotifyingTxsConfirmationChangedRequestMessage modfies the params of a registered `NotifyTxsConfirmationChangedRequstMessage`
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| TxIDs | [string](#string) | repeated |  |
-
-
-
-
-
-
-<a name="protowire.StopNotifyTxsConfirmationChangedResponseMessage"></a>
-
-### StopNotifyTxsConfirmationChangedResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.StartNotifyTxsConfirmationChangedRequestMessage"></a>
-
-### StartNotifyTxsConfirmationChangedRequestMessage
-StartNotifyTxsConfirmationChangedRequestMessage starts listening for Transaction confirmations with the specified TxIDs 
-Most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| TxIDs | [string](#string) | repeated |  |
-
-
-
-
-
-
-<a name="protowire.StartNotifyTxsConfirmationChangedResponseMessage"></a>
-
-### StartNotifyTxsConfirmationChangedResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.ModifyNotifyTxsConfirmationChangedParamsRequestMessage"></a>
-
-### ModifyNotifyTxsConfirmationChangedParamsRequestMessage
-ModifyNotifyTxsConfirmationChangedParamsRequestMessage modfies the params of a registered `NotifyTxsConfirmationChangedRequstMessage`
 most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
 
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
+| addTxIDs | [string](#string) | repeated |  |
+| removeTxIDs | [string](#string) | repeated |  |
 | requiredConfirmations | [uint32](#uint32) |  |  |
 | includePending | [bool](#bool) |  |  |
 
@@ -2459,9 +2124,9 @@ most be registered to NotifyTxsConfirmationChangedRequstMessage for this command
 
 
 
-<a name="protowire.ModifyNotifyTxsConfirmationChangedParamsResponseMessage"></a>
+<a name="protowire.ModifyNotifyingTxsConfirmationChangedResponseMessage"></a>
 
-### ModifyNotifyTxsConfirmationChangedParamsResponseMessage
+### ModifyNotifyingTxsConfirmationChangedResponseMessage
 
 
 
@@ -2541,77 +2206,17 @@ NotifyAddressesTxsChangedRequestMessage Listens for Txs pertaining to specified
 
 
 
-<a name="protowire.StopNotifyAddressesTxsRequestMessage"></a>
+<a name="protowire.ModifyNotifyingAddressesTxsRequestMessage"></a>
 
-### StopNotifyAddressesTxsRequestMessage
+### ModifyNotifyingAddressesTxsRequestMessage
-StopNotifyAddressesTxsRequestMessage stops listening for Txs pertaining to specified addresses
-Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| addresses | [string](#string) | repeated |  |
-
-
-
-
-
-
-<a name="protowire.StopNotifyAddressesTxsResponseMessage"></a>
-
-### StopNotifyAddressesTxsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.StartNotifyAddressesTxsRequestMessage"></a>
-
-### StartNotifyAddressesTxsRequestMessage
-StartNotifyAddressesTxsRequestMessage starts listening for Txs pertaining to specified addresses 
-Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| addresses | [string](#string) | repeated |  |
-
-
-
-
-
-
-<a name="protowire.StartNotifyAddressesTxsResponseMessage"></a>
-
-### StartNotifyAddressesTxsResponseMessage
-
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| error | [RPCError](#protowire.RPCError) |  |  |
-
-
-
-
-
-
-<a name="protowire.ModifyNotifyAddressesTxsParamsRequestMessage"></a>
-
-### ModifyNotifyAddressesTxsParamsRequestMessage
 ModifyNotifyAddressesTxsParamsRequestMessage modifies the params used for a regesitered `NotifyAddressesTxsRequest`
 Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
 
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
+| AddAddresses | [string](#string) | repeated |  |
+| RemoveAddresses | [string](#string) | repeated |  |
 | requiredConfirmations | [uint32](#uint32) |  |  |
 | includePending | [bool](#bool) |  |  |
 | includeSending | [bool](#bool) |  |  |
@@ -2622,9 +2227,9 @@ Most be registered to NotifyAddressTxChangedRequestMessage for this command to w
 
 
 
-<a name="protowire.ModifyNotifyAddressesTxsParamsResponseMessage"></a>
+<a name="protowire.ModifyNotifyingAddressesTxsResponseMessage"></a>
 
-### ModifyNotifyAddressesTxsParamsResponseMessage
+### ModifyNotifyingAddressesTxsResponseMessage
 
 
 

infrastructure/network/netadapter/server/grpcserver/protowire/rpc.proto

@@ -749,7 +749,7 @@ message RpcTxIDBlockPair {
         RpcBlock block = 2;   
 }
 
-//Kaspad most be started with the `--txindex` flag for this Request to work.
+// Kaspad most be started with the `--txindex` flag for this Request to work.
 message GetAcceptingBlockHashesOfTxsRequestMessage{
         repeated string txIDs = 1;
 }
@@ -759,92 +759,7 @@ message GetAcceptingBlockHashesOfTxsResponseMessage{
         RPCError error = 1000;
 }
 
-//Kaspad most be started with the `--txindex` flag for this Request to work.
+// Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetAcceptingBlockOfTxRequestMessage{
-        string txID = 1;
-        bool includeTransactions = 2;
-}
-
-message GetAcceptingBlockOfTxResponseMessage{
-        RpcBlock block = 1;
-
-        RPCError error = 1000;
-}
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetAcceptingBlocksOfTxsRequestMessage{
-        repeated string txIDs = 1;
-        bool includeTransactions = 2;
-}
-
-message GetAcceptingBlocksOfTxsResponseMessage{
-        repeated RpcTxIDBlockPair txIDBlockPairs = 1;
-
-        RPCError error = 1000;
-}
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetIncludingBlockHashOfTxRequestMessage{
-        string txID = 1;
-}
-
-message GetIncludingBlockHashOfTxResponseMessage{
-        string hash = 1;
-
-        RPCError error = 1000;
-}
-
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetIncludingBlockHashesOfTxsRequestMessage{
-        repeated string txIDs = 1;
-}
-
-message GetIncludingBlockHashesOfTxsResponseMessage{
-        repeated RpcTxIDBlockHashPair txIDBlockHashPairs = 1;
-        
-        RPCError error = 1000;
-}
-
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetIncludingBlockOfTxRequestMessage{
-        string txID = 1;
-        bool includeTransactions = 2;
-}
-
-message GetIncludingBlockOfTxResponseMessage{
-        RpcBlock block = 1;
-
-        RPCError error = 1000;
-}
-
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetIncludingBlocksOfTxsRequestMessage{
-        repeated string txIDs = 1;
-        bool includeTransactions = 2;
-}
-
-message GetIncludingBlocksOfTxsResponseMessage{
-        repeated RpcTxIDBlockPair txIDBlockPairs = 1;
-
-        RPCError error = 1000;
-}
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetTxRequestMessage{
-        string txID = 1;
-}
-
-message GetTxResponseMessage{
-        RpcTransaction transaction = 1;
-
-
-        RPCError error = 1000;
-}
-
-//Kaspad most be started with the `--txindex` flag for this Request to work.
 message GetTxsRequestMessage{
         repeated string txIDs = 1;
 }
@@ -856,16 +771,6 @@ message GetTxsResponseMessage{
         RPCError error = 1000;
 }
 
-//Kaspad most be started with the `--txindex` flag for this Request to work.
-message GetTxConfirmationsRequestMessage{
-        string txID = 1;
-}
-
-message GetTxConfirmationsResponseMessage{
-        int64 confirmations = 1;
-
-        RPCError error = 1000;
-}
 
 //Kaspad most be started with the `--txindex` flag for this Request to work.
 message GetTxsConfirmationsRequestMessage{
@@ -903,35 +808,16 @@ message TxsConfirmationChangedNotificationMessage{
         RPCError error = 1000;
 }
 
+// ModifyNotifyingTxsConfirmationChangedRequestMessage modfies the params of a registered `NotifyTxsConfirmationChangedRequstMessage`
 // most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
-message StopNotifyTxsConfirmationChangedRequestMessage{
+message ModifyNotifyingTxsConfirmationChangedRequestMessage{
-        repeated string TxIDs = 1;
+        repeated string addTxIDs = 1;
+        repeated string removeTxIDs = 2;
+        uint32 requiredConfirmations = 3;
+        bool includePending = 4;
 }
 
-message StopNotifyTxsConfirmationChangedResponseMessage{
+message ModifyNotifyingTxsConfirmationChangedResponseMessage{
-
-        RPCError error = 1000;
-}
-
-// StartNotifyTxsConfirmationChangedRequestMessage starts listening for Transaction confirmations with the specified TxIDs 
-// Most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
-message StartNotifyTxsConfirmationChangedRequestMessage{
-        repeated string TxIDs = 1;
-}
-
-message StartNotifyTxsConfirmationChangedResponseMessage{
-        
-        RPCError error = 1000;
-}
-
-// ModifyNotifyTxsConfirmationChangedParamsRequestMessage modfies the params of a registered `NotifyTxsConfirmationChangedRequstMessage`
-// most be registered to NotifyTxsConfirmationChangedRequstMessage for this command to work
-message ModifyNotifyTxsConfirmationChangedParamsRequestMessage{
-        uint32 requiredConfirmations = 1;
-        bool includePending = 2;
-}
-
-message ModifyNotifyTxsConfirmationChangedParamsResponseMessage{
         RPCError error = 1000;
 }
 
@@ -960,38 +846,18 @@ message NotifyAddressesTxsResponseMessage{
         RPCError error = 1000;
 }
 
-// StopNotifyAddressesTxsRequestMessage stops listening for Txs pertaining to specified addresses
-// Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
-message StopNotifyAddressesTxsRequestMessage{
-        repeated string addresses = 1;
-}
-
-message StopNotifyAddressesTxsResponseMessage{
-        
-        RPCError error = 1000;
-}
-
-// StartNotifyAddressesTxsRequestMessage starts listening for Txs pertaining to specified addresses 
-// Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
-message StartNotifyAddressesTxsRequestMessage{
-        repeated string addresses = 1;
-}
-
-message StartNotifyAddressesTxsResponseMessage{
-        
-        RPCError error = 1000;
-}
-
 // ModifyNotifyAddressesTxsParamsRequestMessage modifies the params used for a regesitered `NotifyAddressesTxsRequest`
 // Most be registered to NotifyAddressTxChangedRequestMessage for this command to work
-message ModifyNotifyAddressesTxsParamsRequestMessage{
+message ModifyNotifyingAddressesTxsRequestMessage{
-        uint32 requiredConfirmations = 1;
+        repeated string AddAddresses = 1;
-        bool includePending = 3;
+        repeated string RemoveAddresses = 2;
-        bool includeSending = 4;
+        uint32 requiredConfirmations = 3;
-        bool includeReceiving = 5;
+        bool includePending = 4;
+        bool includeSending = 5;
+        bool includeReceiving = 6;
 }
 
-message ModifyNotifyAddressesTxsParamsResponseMessage{
+message ModifyNotifyingAddressesTxsResponseMessage{
 
         RPCError error = 1000;
 }

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_accepting_block_of_tx.go

@@ -1,83 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetAcceptingBlockOfTxRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlockOfTxRequest")
-	}
-	return x.GetAcceptingBlockOfTxRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlockOfTxRequest) fromAppMessage(message *appmessage.GetAcceptingBlockOfTxRequestMessage) error {
-	x.GetAcceptingBlockOfTxRequest = &GetAcceptingBlockOfTxRequestMessage{
-		TxID:                message.TxID,
-		IncludeTransactions: message.IncludeTransactions,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlockOfTxRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlockOfTxRequestMessage is nil")
-	}
-	return &appmessage.GetAcceptingBlockOfTxRequestMessage{
-		TxID:                x.TxID,
-		IncludeTransactions: x.IncludeTransactions,
-	}, nil
-}
-
-func (x *KaspadMessage_GetAcceptingBlockOfTxResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlockOfTxResponse is nil")
-	}
-	return x.GetAcceptingBlockOfTxResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlockOfTxResponse) fromAppMessage(message *appmessage.GetAcceptingBlockOfTxResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-	rpcBlock := &RpcBlock{}
-
-	err := rpcBlock.fromAppMessage(message.Block)
-	if err != nil {
-		return err
-	}
-	x.GetAcceptingBlockOfTxResponse = &GetAcceptingBlockOfTxResponseMessage{
-		Block: rpcBlock,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlockOfTxResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlockOfTxResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.Block != nil {
-		return nil, errors.New("GetAcceptingBlockOfTxResponseMessage contains both an error and a response")
-	}
-
-	appBlock, err := x.Block.toAppMessage()
-	if err != nil {
-		return nil, err
-	}
-
-	return &appmessage.GetAcceptingBlockOfTxResponseMessage{
-		Block: appBlock,
-		Error: rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_accepting_blockhash_of_tx.go

@@ -1,70 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetAcceptingBlockHashOfTxRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlockHashOfTxRequest")
-	}
-	return x.GetAcceptingBlockHashOfTxRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlockHashOfTxRequest) fromAppMessage(message *appmessage.GetAcceptingBlockHashOfTxRequestMessage) error {
-	x.GetAcceptingBlockHashOfTxRequest = &GetAcceptingBlockHashOfTxRequestMessage{
-		TxID: message.TxID,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlockHashOfTxRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlockHashOfTxRequestMessage is nil")
-	}
-	return &appmessage.GetAcceptingBlockHashOfTxRequestMessage{
-		TxID: x.TxID,
-	}, nil
-}
-
-func (x *KaspadMessage_GetAcceptingBlockHashOfTxResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlockHashOfTxResponse is nil")
-	}
-	return x.GetAcceptingBlockHashOfTxResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlockHashOfTxResponse) fromAppMessage(message *appmessage.GetAcceptingBlockHashOfTxResponseMessage) error {
-	var err *RPCError
-	if message.Error != nil {
-		err = &RPCError{Message: message.Error.Message}
-	}
-	x.GetAcceptingBlockHashOfTxResponse = &GetAcceptingBlockHashOfTxResponseMessage{
-		Hash: message.Hash,
-
-		Error: err,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlockHashOfTxResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlockHashOfTxResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.Hash != "" {
-		return nil, errors.New("GetAcceptingBlockHashOfTxResponseMessage contains both an error and a response")
-	}
-
-	return &appmessage.GetAcceptingBlockHashOfTxResponseMessage{
-		Hash:  x.Hash,
-		Error: rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_accepting_blocks_of_txs.go

@@ -1,121 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetAcceptingBlocksOfTxsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlocksOfTxsRequest")
-	}
-	return x.GetAcceptingBlocksOfTxsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlocksOfTxsRequest) fromAppMessage(message *appmessage.GetAcceptingBlocksOfTxsRequestMessage) error {
-	x.GetAcceptingBlocksOfTxsRequest = &GetAcceptingBlocksOfTxsRequestMessage{
-		TxIDs:               message.TxIDs,
-		IncludeTransactions: message.IncludeTransactions,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlocksOfTxsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlocksOfTxsRequestMessage is nil")
-	}
-	return &appmessage.GetAcceptingBlocksOfTxsRequestMessage{
-		TxIDs:               x.TxIDs,
-		IncludeTransactions: x.IncludeTransactions,
-	}, nil
-}
-
-func (x *KaspadMessage_GetAcceptingBlocksOfTxsResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetAcceptingBlocksOfTxsResponse is nil")
-	}
-	return x.GetAcceptingBlocksOfTxsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetAcceptingBlocksOfTxsResponse) fromAppMessage(message *appmessage.GetAcceptingBlocksOfTxsResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-
-	rpcTxIDBlockPairs := make([]*RpcTxIDBlockPair, len(message.TxIDBlockPairs))
-	for i := range rpcTxIDBlockPairs {
-		rpcTxIDBlockPairs[i] = &RpcTxIDBlockPair{}
-		err := rpcTxIDBlockPairs[i].fromAppMessage(message.TxIDBlockPairs[i])
-		if err != nil {
-			return err
-		}
-	}
-
-	x.GetAcceptingBlocksOfTxsResponse = &GetAcceptingBlocksOfTxsResponseMessage{
-		TxIDBlockPairs: rpcTxIDBlockPairs,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetAcceptingBlocksOfTxsResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetAcceptingBlocksOfTxsResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.TxIDBlockPairs != nil {
-		return nil, errors.New("GetAcceptingBlocksOfTxsResponseMessage contains both an error and a response")
-	}
-
-	appTxIDBlockPairs := make([]*appmessage.TxIDBlockPair, len(x.TxIDBlockPairs))
-	for i := range appTxIDBlockPairs {
-		appTxIDBlockPairs[i], err = x.TxIDBlockPairs[i].toAppMessage()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return &appmessage.GetAcceptingBlocksOfTxsResponseMessage{
-		TxIDBlockPairs: appTxIDBlockPairs,
-		Error:          rpcErr,
-	}, nil
-}
-
-func (x *RpcTxIDBlockPair) toAppMessage() (*appmessage.TxIDBlockPair, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "TxIDBlockPair is nil")
-	}
-
-	appBlock, err := x.Block.toAppMessage()
-	if err != nil {
-		return nil, err
-	}
-
-	return &appmessage.TxIDBlockPair{
-		TxID:  x.TxID,
-		Block: appBlock,
-	}, nil
-}
-
-func (x *RpcTxIDBlockPair) fromAppMessage(message *appmessage.TxIDBlockPair) error {
-
-	rpcBlock := &RpcBlock{}
-
-	err := rpcBlock.fromAppMessage(message.Block)
-	if err != nil {
-		return err
-	}
-	*x = RpcTxIDBlockPair{
-		TxID:  message.TxID,
-		Block: rpcBlock,
-	}
-	return nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_including_block_of_tx.go

@@ -1,83 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetIncludingBlockOfTxRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlockOfTxRequest")
-	}
-	return x.GetIncludingBlockOfTxRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockOfTxRequest) fromAppMessage(message *appmessage.GetIncludingBlockOfTxRequestMessage) error {
-	x.GetIncludingBlockOfTxRequest = &GetIncludingBlockOfTxRequestMessage{
-		TxID:                message.TxID,
-		IncludeTransactions: message.IncludeTransactions,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockOfTxRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockOfTxRequestMessage is nil")
-	}
-	return &appmessage.GetIncludingBlockOfTxRequestMessage{
-		TxID:                x.TxID,
-		IncludeTransactions: x.IncludeTransactions,
-	}, nil
-}
-
-func (x *KaspadMessage_GetIncludingBlockOfTxResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlockOfTxResponse is nil")
-	}
-	return x.GetIncludingBlockOfTxResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockOfTxResponse) fromAppMessage(message *appmessage.GetIncludingBlockOfTxResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-	rpcBlock := &RpcBlock{}
-
-	err := rpcBlock.fromAppMessage(message.Block)
-	if err != nil {
-		return err
-	}
-	x.GetIncludingBlockOfTxResponse = &GetIncludingBlockOfTxResponseMessage{
-		Block: rpcBlock,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockOfTxResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockOfTxResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.Block != nil {
-		return nil, errors.New("GetIncludingBlockOfTxResponseMessage contains both an error and a response")
-	}
-
-	appBlock, err := x.Block.toAppMessage()
-	if err != nil {
-		return nil, err
-	}
-
-	return &appmessage.GetIncludingBlockOfTxResponseMessage{
-		Block: appBlock,
-		Error: rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_including_blockhash_of_tx.go

@@ -1,70 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetIncludingBlockHashOfTxRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlockHashOfTxRequest")
-	}
-	return x.GetIncludingBlockHashOfTxRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashOfTxRequest) fromAppMessage(message *appmessage.GetIncludingBlockHashOfTxRequestMessage) error {
-	x.GetIncludingBlockHashOfTxRequest = &GetIncludingBlockHashOfTxRequestMessage{
-		TxID: message.TxID,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockHashOfTxRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockHashOfTxRequestMessage is nil")
-	}
-	return &appmessage.GetIncludingBlockHashOfTxRequestMessage{
-		TxID: x.TxID,
-	}, nil
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashOfTxResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlockHashOfTxResponse is nil")
-	}
-	return x.GetIncludingBlockHashOfTxResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashOfTxResponse) fromAppMessage(message *appmessage.GetIncludingBlockHashOfTxResponseMessage) error {
-	var err *RPCError
-	if message.Error != nil {
-		err = &RPCError{Message: message.Error.Message}
-	}
-	x.GetIncludingBlockHashOfTxResponse = &GetIncludingBlockHashOfTxResponseMessage{
-		Hash: message.Hash,
-
-		Error: err,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockHashOfTxResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockHashOfTxResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.Hash != "" {
-		return nil, errors.New("GetIncludingBlockHashOfTxResponseMessage contains both an error and a response")
-	}
-
-	return &appmessage.GetIncludingBlockHashOfTxResponseMessage{
-		Hash:  x.Hash,
-		Error: rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_including_blockhashes_of_txs.go

@@ -1,85 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetIncludingBlockHashesOfTxsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlockHashesOfTxsRequest")
-	}
-	return x.GetIncludingBlockHashesOfTxsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashesOfTxsRequest) fromAppMessage(message *appmessage.GetIncludingBlockHashesOfTxsRequestMessage) error {
-	x.GetIncludingBlockHashesOfTxsRequest = &GetIncludingBlockHashesOfTxsRequestMessage{
-		TxIDs: message.TxIDs,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockHashesOfTxsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockHashesOfTxsRequestMessage is nil")
-	}
-	return &appmessage.GetIncludingBlockHashesOfTxsRequestMessage{
-		TxIDs: x.TxIDs,
-	}, nil
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashesOfTxsResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludinglockHashesOfTxsResponse is nil")
-	}
-	return x.GetIncludingBlockHashesOfTxsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlockHashesOfTxsResponse) fromAppMessage(message *appmessage.GetIncludingBlockHashesOfTxsResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-
-	rpcTxIDBlockHashPairs := make([]*RpcTxIDBlockHashPair, len(message.TxIDBlockHashPairs))
-	for i := range rpcTxIDBlockHashPairs {
-		rpcTxIDBlockHashPairs[i] = &RpcTxIDBlockHashPair{}
-		rpcTxIDBlockHashPairs[i].fromAppMessage(message.TxIDBlockHashPairs[i])
-	}
-
-	x.GetIncludingBlockHashesOfTxsResponse = &GetIncludingBlockHashesOfTxsResponseMessage{
-		TxIDBlockHashPairs: rpcTxIDBlockHashPairs,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlockHashesOfTxsResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlockHashesOfTxsResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.TxIDBlockHashPairs != nil {
-		return nil, errors.New("GetIncludingBlockHashesfTxsResponseMessage contains both an error and a response")
-	}
-
-	appTxIDBlockHashPairs := make([]*appmessage.TxIDBlockHashPair, len(x.TxIDBlockHashPairs))
-	for i := range appTxIDBlockHashPairs {
-		appTxIDBlockHashPairs[i], err = x.TxIDBlockHashPairs[i].toAppMessage()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return &appmessage.GetIncludingBlockHashesOfTxsResponseMessage{
-		TxIDBlockHashPairs: appTxIDBlockHashPairs,
-		Error:              rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_including_blocks_of_txs.go

@@ -1,90 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetIncludingBlocksOfTxsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlocksOfTxsRequest")
-	}
-	return x.GetIncludingBlocksOfTxsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlocksOfTxsRequest) fromAppMessage(message *appmessage.GetIncludingBlocksOfTxsRequestMessage) error {
-	x.GetIncludingBlocksOfTxsRequest = &GetIncludingBlocksOfTxsRequestMessage{
-		TxIDs:               message.TxIDs,
-		IncludeTransactions: message.IncludeTransactions,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlocksOfTxsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlocksOfTxsRequestMessage is nil")
-	}
-	return &appmessage.GetIncludingBlocksOfTxsRequestMessage{
-		TxIDs:               x.TxIDs,
-		IncludeTransactions: x.IncludeTransactions,
-	}, nil
-}
-
-func (x *KaspadMessage_GetIncludingBlocksOfTxsResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetIncludingBlocksOfTxsResponse is nil")
-	}
-	return x.GetIncludingBlocksOfTxsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetIncludingBlocksOfTxsResponse) fromAppMessage(message *appmessage.GetIncludingBlocksOfTxsResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-
-	rpcTxIDBlockPairs := make([]*RpcTxIDBlockPair, len(message.TxIDBlockPairs))
-	for i := range rpcTxIDBlockPairs {
-		rpcTxIDBlockPairs[i] = &RpcTxIDBlockPair{}
-		err := rpcTxIDBlockPairs[i].fromAppMessage(message.TxIDBlockPairs[i])
-		if err != nil {
-			return err
-		}
-	}
-
-	x.GetIncludingBlocksOfTxsResponse = &GetIncludingBlocksOfTxsResponseMessage{
-		TxIDBlockPairs: rpcTxIDBlockPairs,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetIncludingBlocksOfTxsResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetIncludingBlocksOfTxsResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.TxIDBlockPairs != nil {
-		return nil, errors.New("GetIncludingBlocksOfTxsResponseMessage contains both an error and a response")
-	}
-
-	appTxIDBlockPairs := make([]*appmessage.TxIDBlockPair, len(x.TxIDBlockPairs))
-	for i := range appTxIDBlockPairs {
-		appTxIDBlockPairs[i], err = x.TxIDBlockPairs[i].toAppMessage()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return &appmessage.GetIncludingBlocksOfTxsResponseMessage{
-		TxIDBlockPairs: appTxIDBlockPairs,
-		Error:          rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_tx.go

@@ -1,78 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetTxRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetTxRequest")
-	}
-	return x.GetTxRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetTxRequest) fromAppMessage(message *appmessage.GetTxRequestMessage) error {
-	x.GetTxRequest = &GetTxRequestMessage{
-		TxID: message.TxID,
-	}
-	return nil
-}
-
-func (x *GetTxRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetTxRequestMessage is nil")
-	}
-	return &appmessage.GetTxRequestMessage{
-		TxID: x.TxID,
-	}, nil
-}
-
-func (x *KaspadMessage_GetTxResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetTxResponse is nil")
-	}
-	return x.GetTxResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetTxResponse) fromAppMessage(message *appmessage.GetTxResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-	rpcTransaction := &RpcTransaction{}
-	rpcTransaction.fromAppMessage(message.Transaction)
-
-	x.GetTxResponse = &GetTxResponseMessage{
-		Transaction: rpcTransaction,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetTxResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetTxResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if rpcErr != nil && x.Transaction != nil {
-		return nil, errors.New("GetTxResponseMessage contains both an error and a response")
-	}
-
-	appTransaction, err := x.Transaction.toAppMessage()
-	if err != nil {
-		return nil, err
-	}
-
-	return &appmessage.GetTxResponseMessage{
-		Transaction: appTransaction,
-		Error:       rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_tx_confirmations.go

@@ -1,71 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_GetTxConfirmationsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetTxConfirmationsRequest")
-	}
-	return x.GetTxConfirmationsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_GetTxConfirmationsRequest) fromAppMessage(message *appmessage.GetTxConfirmationsRequestMessage) error {
-	x.GetTxConfirmationsRequest = &GetTxConfirmationsRequestMessage{
-		TxID: message.TxID,
-	}
-	return nil
-}
-
-func (x *GetTxConfirmationsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetTxConfirmationsRequestMessage is nil")
-	}
-	return &appmessage.GetTxConfirmationsRequestMessage{
-		TxID: x.TxID,
-	}, nil
-}
-
-func (x *KaspadMessage_GetTxConfirmationsResponse) toAppMessage() (appmessage.Message, error) {
-
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetTxConfirmationsResponse is nil")
-	}
-	return x.GetTxConfirmationsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_GetTxConfirmationsResponse) fromAppMessage(message *appmessage.GetTxConfirmationsResponseMessage) error {
-	var rpcErr *RPCError
-	if message.Error != nil {
-		rpcErr = &RPCError{Message: message.Error.Message}
-	}
-
-	x.GetTxConfirmationsResponse = &GetTxConfirmationsResponseMessage{
-		Confirmations: message.Confirmations,
-
-		Error: rpcErr,
-	}
-	return nil
-}
-
-func (x *GetTxConfirmationsResponseMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "GetTxConfirmationsResponseMessage is nil")
-	}
-	rpcErr, err := x.Error.toAppMessage()
-	// Error is an optional field
-	if err != nil && !errors.Is(err, errorNil) {
-		return nil, err
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &appmessage.GetTxConfirmationsResponseMessage{
-		Confirmations: x.Confirmations,
-		Error:         rpcErr,
-	}, nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_modify_notify_addresses_txs_params.go

@@ -1,53 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_ModifyNotifyAddressesTxsParamsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_ModifyNotifyAddressesTxsParamsRequest is nil")
-	}
-	return x.ModifyNotifyAddressesTxsParamsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_ModifyNotifyAddressesTxsParamsRequest) fromAppMessage(message *appmessage.ModifyNotifyAddressesTxsParamsRequestMessage) error {
-	x.ModifyNotifyAddressesTxsParamsRequest = &ModifyNotifyAddressesTxsParamsRequestMessage{
-		RequiredConfirmations: message.RequiredConfirmations,
-		IncludePending: message.IncludePending,
-		IncludeSending: message.IncludeSending,
-		IncludeReceiving: message.IncludeReceiving,
-	}
-	return nil
-}
-
-func (x *ModifyNotifyAddressesTxsParamsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "ModifyNotifyAddressesTxsParamsRequestMessage is nil")
-	}
-	return &appmessage.ModifyNotifyAddressesTxsParamsRequestMessage{
-		RequiredConfirmations: x.RequiredConfirmations,
-		IncludePending: x.IncludePending,
-		IncludeSending: x.IncludeSending,
-		IncludeReceiving: x.IncludeReceiving,
-	}, nil
-}
-
-func (x *KaspadMessage_ModifyNotifyAddressesTxsParamsResponse) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "ModifyNotifyAddressesTxsParamsResponseMessage is nil")
-	}
-	return x.ModifyNotifyAddressesTxsParamsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_ModifyNotifyAddressesTxsParamsResponse) fromAppMessage(message *appmessage.ModifyNotifyAddressesTxsParamsResponseMessage) error {
-	var err *RPCError
-	if message.Error != nil {
-		err = &RPCError{Message: message.Error.Message}
-	}
-	x.ModifyNotifyAddressesTxsParamsResponse = &ModifyNotifytTxsConfirmationChangedParamsResponseMessage{
-		Error: err,
-	}
-	return nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_modify_notify_txs_confirmation_changed_params.go

@@ -1,49 +0,0 @@
-package protowire
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/pkg/errors"
-)
-
-func (x *KaspadMessage_ModifyNotifyTxsConfirmationChangedParamsRequest) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_ModifyNotifyTxsConfirmationChangedParamsRequest is nil")
-	}
-	return x.ModifyNotifyTxsConfirmationChangedParamsRequest.toAppMessage()
-}
-
-func (x *KaspadMessage_ModifyNotifyTxsConfirmationChangedParamsRequest) fromAppMessage(message *appmessage.ModifyNotifyTxsConfirmationChangedParamsRequestMessage) error {
-	x.ModifyNotifyTxsConfirmationChangedParamsRequest = &ModifyNotifyTxsConfirmationChangedParamsRequestMessage{
-		RequiredConfirmations: message.RequiredConfirmations,
-		IncludePending: message.IncludePending,
-	}
-	return nil
-}
-
-func (x *ModifyNotifyTxsConfirmationChangedParamsRequestMessage) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "ModifyNotifyTxsConfirmationChangedParamsRequestMessage is nil")
-	}
-	return &appmessage.ModifyNotifyTxsConfirmationChangedParamsRequestMessage{
-		RequiredConfirmations: x.RequiredConfirmations,
-		IncludePending: x.IncludePending,
-	}, nil
-}
-
-func (x *KaspadMessage_ModifyNotifyTxsConfirmationChangedParamsResponse) toAppMessage() (appmessage.Message, error) {
-	if x == nil {
-		return nil, errors.Wrapf(errorNil, "ModifyNotifyTxsConfirmationChangedParamsResponseMessage is nil")
-	}
-	return x.ModifyNotifyTxsConfirmationChangedParamsResponse.toAppMessage()
-}
-
-func (x *KaspadMessage_ModifyNotifyTxsConfirmationChangedParamsResponse) fromAppMessage(message *appmessage.ModifyNotifyTxsConfirmationChangedParamsResponseMessage) error {
-	var err *RPCError
-	if message.Error != nil {
-		err = &RPCError{Message: message.Error.Message}
-	}
-	x.ModifyNotifyTxsConfirmationChangedParamsResponse = &ModifyNotifytTxsConfirmationChangedParamsResponseMessage{
-		Error: err,
-	}
-	return nil
-}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_modify_notifying_addresses_txs.go

@@ -0,0 +1,53 @@
+package protowire
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/pkg/errors"
+)
+
+func (x *KaspadMessage_ModifyNotifyingAddressesTxsRequest) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "KaspadMessage_ModifyNotifyingAddressesTxsRequest is nil")
+	}
+	return x.ModifyNotifyingAddressesTxsRequest.toAppMessage()
+}
+
+func (x *KaspadMessage_ModifyNotifyingAddressesTxsRequest) fromAppMessage(message *appmessage.ModifyNotifyingAddressesTxsRequestMessage) error {
+	x.ModifyNotifyingAddressesTxsRequest = &ModifyNotifyingAddressesTxsRequestMessage{
+		RequiredConfirmations: message.RequiredConfirmations,
+		IncludePending: message.IncludePending,
+		IncludeSending: message.IncludeSending,
+		IncludeReceiving: message.IncludeReceiving,
+	}
+	return nil
+}
+
+func (x *ModifyNotifyingAddressesTxsRequestMessage) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "ModifyNotifyingAddressesTxsRequestMessage is nil")
+	}
+	return &appmessage.ModifyNotifyingAddressesTxsRequestMessage{
+		RequiredConfirmations: x.RequiredConfirmations,
+		IncludePending: x.IncludePending,
+		IncludeSending: x.IncludeSending,
+		IncludeReceiving: x.IncludeReceiving,
+	}, nil
+}
+
+func (x *KaspadMessage_ModifyNotifyingAddressesTxsResponse) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "ModifyNotifyingAddressesTxsResponseMessage is nil")
+	}
+	return x.ModifyNotifyingAddressesTxsResponse.toAppMessage()
+}
+
+func (x *KaspadMessage_ModifyNotifyingAddressesTxsResponse) fromAppMessage(message *appmessage.ModifyNotifyingAddressesTxsResponseMessage) error {
+	var err *RPCError
+	if message.Error != nil {
+		err = &RPCError{Message: message.Error.Message}
+	}
+	x.ModifyNotifyingAddressesTxsResponse = &ModifyNotifytTxsConfirmingationChangedResponseMessage{
+		Error: err,
+	}
+	return nil
+}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_modify_notifying_txs_confirmation_changed.go

@@ -0,0 +1,49 @@
+package protowire
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/pkg/errors"
+)
+
+func (x *KaspadMessage_ModifyNotifyingTxsConfirmationChangedRequest) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "KaspadMessage_ModifyNotifyingTxsConfirmationChangedRequest is nil")
+	}
+	return x.ModifyNotifyingTxsConfirmationChangedRequest.toAppMessage()
+}
+
+func (x *KaspadMessage_ModifyNotifyingTxsConfirmationChangedRequest) fromAppMessage(message *appmessage.ModifyNotifyingTxsConfirmationChangedRequestMessage) error {
+	x.ModifyNotifyingTxsConfirmationChangedRequest = &ModifyNotifyingTxsConfirmationChangedRequestMessage{
+		RequiredConfirmations: message.RequiredConfirmations,
+		IncludePending: message.IncludePending,
+	}
+	return nil
+}
+
+func (x *ModifyNotifyingTxsConfirmationChangedRequestMessage) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "ModifyNotifyingTxsConfirmationChangedRequestMessage is nil")
+	}
+	return &appmessage.ModifyNotifyingTxsConfirmationChangedRequestMessage{
+		RequiredConfirmations: x.RequiredConfirmations,
+		IncludePending: x.IncludePending,
+	}, nil
+}
+
+func (x *KaspadMessage_ModifyNotifyingTxsConfirmationChangedResponse) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "ModifyNotifyingTxsConfirmationChangedResponseMessage is nil")
+	}
+	return x.ModifyNotifyingTxsConfirmationChangedResponse.toAppMessage()
+}
+
+func (x *KaspadMessage_ModifyNotifyingTxsConfirmationChangedResponse) fromAppMessage(message *appmessage.ModifyNotifyingTxsConfirmationChangedResponseMessage) error {
+	var err *RPCError
+	if message.Error != nil {
+		err = &RPCError{Message: message.Error.Message}
+	}
+	x.ModifyNotifyingTxsConfirmationChangedResponse = &ModifyNotifytingTxsConfirmationChangedResponseMessage{
+		Error: err,
+	}
+	return nil
+}

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_notify_addresses_txs.go

@@ -3,17 +3,17 @@ package protowire
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/pkg/errors"
-) NotifyAddressesTxsParams
+)
 
 func (x *KaspadMessage_NotifyAddressesTxsRequest) toAppMessage() (appmessage.Message, error) {
 	if x == nil {
 		return nil, errors.Wrapf(errorNil, "KaspadMessage_NotifyAddressesTxsRequest is nil")
 	}
-	return x.NotifyAddressesTxsRequst.toAppMessage()
+	return x.NotifyAddressesTxsRequest.toAppMessage()
 }
 
-func (x *KaspadMessage_NotifyAddressesTxsRequest) fromAppMessage(message *appmessage.NotifyAddressesTxsRequstMessage) error {
+func (x *KaspadMessage_NotifyAddressesTxsRequest) fromAppMessage(message *appmessage.NotifyAddressesTxsRequestMessage) error {
-	x.NotifyAddressesTxsRequest = &NotifyAddressesTxsRequstMessage{
+	x.NotifyAddressesTxsRequest = &NotifyAddressesTxsRequestMessage{
 		Addresses : message.Addresses,
 		RequiredConfirmations: message.RequiredConfirmations,
 		IncludePending: message.IncludePending,
@@ -76,23 +76,12 @@ func (x *KaspadMessage_AddressesTxsNotification) toAppMessage() (appmessage.Mess
 }
 
 func (x *KaspadMessage_AddressesTxsNotification) fromAppMessage(message *appmessage.AddressesTxsNotificationMessage) error {
-	pending := make([]*TxEntriesByAddresses, len(message.Pending))
-	for i, entry := range message.Pending {
-		entry[i] = &TxEntriesByAddresses{}
-		entry[i].fromAppMessage(entry)
-	}
 
-	confirmed := make([]*TxEntriesByAddresses, len(message.Confirmed))
+	pending := message.Pending.fromAppMessage()
-	for i, entry := range message.Confirmed {
-		entry[i] = &TxEntriesByAddresses{}
-		entry[i].fromAppMessage(entry)
-	}
 
-	unconfirmed := make([]*TxEntriesByAddresses, len(message.Unconfirmed))
+	confirmed := message.Confirmed.fromAppMessage()
-	for i, entry := range message.Confirmed {
+
-		entry[i] = &TxEntriesByAddresses{}
+	unconfirmed := message.Unconfirmed.fromAppMessage()
-		entry[i].fromAppMessage(entry)
-	}
 
 	x.AddressesTxsNotification = &AddressesTxsNotificationMessage{
 		RequiredConfirmations: message.RequiredConfirmations,
@@ -107,33 +96,20 @@ func (x *AddressesTxsNotificationMessage) toAppMessage() (appmessage.Message, er
 	if x == nil {
 		return nil, errors.Wrapf(errorNil, "AddressesTxsNotificationMessage is nil")
 	}
-	pending := make([]*appmessage.TxEntriesByAddresses, len(x.Pending))
+	pending, err := x.Pending.toAppMessage()
-	for i, entry := range x.Pending {
-		entry, err := entry.toAppMessage()
 	if err != nil {
 		return nil, err
 	}
-		pending[i] = entry
-	}
 
-	confirmed := make([]*appmessage.TxEntriesByAddresses, len(x.Confirmed))
+	confirmed, err := x.Pending.toAppMessage()
-	for i, entry := range x.Confirmed {
-		entry, err := entry.toAppMessage()
 	if err != nil {
 		return nil, err
 	}
-		confirmed[i] = entry
-	}
 
-	unconfirmed := make([]*appmessage.TxEntriesByAddresses, len(x.Unconfirmed))
+	unconfirmed, err := x.Unconfirmed.toAppMessage()
-	for i, entry := range x.Unconfirmed {
-		entry, err := entry.toAppMessage()
 	if err != nil {
 		return nil, err
 	}
-		confirmed[i] = entry
-	}
-
 
 	return &appmessage.AddressesTxsNotificationMessage{
 		RequiredConfirmations: x.RequiredConfirmations,

infrastructure/network/netadapter/server/grpcserver/protowire/wire.go

@@ -968,20 +968,6 @@ func toRPCPayload(message appmessage.Message) (isKaspadMessage_Payload, error) {
 			return nil, err
 		}
 		return payload, nil
-	case *appmessage.GetAcceptingBlockHashOfTxRequestMessage:
-		payload := new(KaspadMessage_GetAcceptingBlockHashOfTxRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetAcceptingBlockHashOfTxResponseMessage:
-		payload := new(KaspadMessage_GetAcceptingBlockHashOfTxResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
 	case *appmessage.GetAcceptingBlockHashesOfTxsRequestMessage:
 		payload := new(KaspadMessage_GetAcceptingBlockHashesOfTxsRequest)
 		err := payload.fromAppMessage(message)
@@ -996,104 +982,6 @@ func toRPCPayload(message appmessage.Message) (isKaspadMessage_Payload, error) {
 			return nil, err
 		}
 		return payload, nil
-	case *appmessage.GetAcceptingBlockOfTxRequestMessage:
-		payload := new(KaspadMessage_GetAcceptingBlockOfTxRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetAcceptingBlockOfTxResponseMessage:
-		payload := new(KaspadMessage_GetAcceptingBlockOfTxResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetAcceptingBlocksOfTxsRequestMessage:
-		payload := new(KaspadMessage_GetAcceptingBlocksOfTxsRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetAcceptingBlocksOfTxsResponseMessage:
-		payload := new(KaspadMessage_GetAcceptingBlocksOfTxsResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockHashesOfTxsRequestMessage:
-		payload := new(KaspadMessage_GetIncludingBlockHashesOfTxsRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockHashesOfTxsResponseMessage:
-		payload := new(KaspadMessage_GetIncludingBlockHashesOfTxsResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockOfTxRequestMessage:
-		payload := new(KaspadMessage_GetIncludingBlockOfTxRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockOfTxResponseMessage:
-		payload := new(KaspadMessage_GetIncludingBlockOfTxResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlocksOfTxsRequestMessage:
-		payload := new(KaspadMessage_GetIncludingBlocksOfTxsRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlocksOfTxsResponseMessage:
-		payload := new(KaspadMessage_GetIncludingBlocksOfTxsResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockHashOfTxRequestMessage:
-		payload := new(KaspadMessage_GetIncludingBlockHashOfTxRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetIncludingBlockHashOfTxResponseMessage:
-		payload := new(KaspadMessage_GetIncludingBlockHashOfTxResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetTxRequestMessage:
-		payload := new(KaspadMessage_GetTxRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetTxResponseMessage:
-		payload := new(KaspadMessage_GetTxResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
 	case *appmessage.GetTxsRequestMessage:
 		payload := new(KaspadMessage_GetTxsRequest)
 		err := payload.fromAppMessage(message)
@@ -1108,20 +996,6 @@ func toRPCPayload(message appmessage.Message) (isKaspadMessage_Payload, error) {
 			return nil, err
 		}
 		return payload, nil
-	case *appmessage.GetTxConfirmationsRequestMessage:
-		payload := new(KaspadMessage_GetTxConfirmationsRequest)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
-	case *appmessage.GetTxConfirmationsResponseMessage:
-		payload := new(KaspadMessage_GetTxConfirmationsResponse)
-		err := payload.fromAppMessage(message)
-		if err != nil {
-			return nil, err
-		}
-		return payload, nil
 	case *appmessage.GetTxsConfirmationsRequestMessage:
 		payload := new(KaspadMessage_GetTxsConfirmationsRequest)
 		err := payload.fromAppMessage(message)

infrastructure/network/rpcclient/rpc_get_accepting_block_of_tx.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetAcceptingBlockOfTx sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetAcceptingBlockOfTx(txID string, includeTransactions bool) (*appmessage.GetAcceptingBlockOfTxResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlockOfTxRequest(txID, includeTransactions))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetAcceptingBlockOfTxResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getAcceptingBlockOfTxResponse := response.(*appmessage.GetAcceptingBlockOfTxResponseMessage)
-	if getAcceptingBlockOfTxResponse.Error != nil {
-		return nil, c.convertRPCError(getAcceptingBlockOfTxResponse.Error)
-	}
-	return getAcceptingBlockOfTxResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_accepting_blockhash_of_tx.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetAcceptingBlockHashOfTx sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetAcceptingBlockHashOfTx(txID string) (*appmessage.GetAcceptingBlockHashOfTxResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlockHashOfTxRequest(txID))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetAcceptingBlockHashOfTxResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getAcceptingBlockHashOfTxResponse := response.(*appmessage.GetAcceptingBlockHashOfTxResponseMessage)
-	if getAcceptingBlockHashOfTxResponse.Error != nil {
-		return nil, c.convertRPCError(getAcceptingBlockHashOfTxResponse.Error)
-	}
-	return getAcceptingBlockHashOfTxResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_accepting_blocks_of_txs.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetAcceptingBlocksTxs sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetAcceptingBlocksTxs(txIDs []string, includeTransactions bool) (*appmessage.GetAcceptingBlocksOfTxsResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlocksOfTxsRequest(txIDs, includeTransactions))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetAcceptingBlocksOfTxsResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getAcceptingBlocksOfTxsResponse := response.(*appmessage.GetAcceptingBlocksOfTxsResponseMessage)
-	if getAcceptingBlocksOfTxsResponse.Error != nil {
-		return nil, c.convertRPCError(getAcceptingBlocksOfTxsResponse.Error)
-	}
-	return getAcceptingBlocksOfTxsResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_including_block_of_tx.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetIncludingBlockOfTx sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetIncludingBlockOfTx(txID string, includeTransactions bool) (*appmessage.GetIncludingBlockOfTxResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetIncludingBlockOfTxRequest(txID, includeTransactions))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetIncludingBlockOfTxResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getIncludingBlockOfTxResponse := response.(*appmessage.GetIncludingBlockOfTxResponseMessage)
-	if getIncludingBlockOfTxResponse.Error != nil {
-		return nil, c.convertRPCError(getIncludingBlockOfTxResponse.Error)
-	}
-	return getIncludingBlockOfTxResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_including_blockhash_of_tx.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetIncludingBlockHashOfTxs sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetIncludingBlockHashOfTxs(txID string) (*appmessage.GetIncludingBlockHashOfTxResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetIncludingBlockHashOfTxRequest(txID))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetIncludingBlockHashOfTxResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getIncludingBlockHashOfTxResponse := response.(*appmessage.GetIncludingBlockHashOfTxResponseMessage)
-	if getIncludingBlockHashOfTxResponse.Error != nil {
-		return nil, c.convertRPCError(getIncludingBlockHashOfTxResponse.Error)
-	}
-	return getIncludingBlockHashOfTxResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_including_blockhashes_of_txs.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetIncludingBlockHashesOfTxs sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetIncludingBlockHashesOfTxs(txIDs []string) (*appmessage.GetIncludingBlockHashesOfTxsResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetIncludingBlockHashesOfTxsRequest(txIDs))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetIncludingBlockHashesOfTxsResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getIncludingBlockHashesOfTxsResponse := response.(*appmessage.GetIncludingBlockHashesOfTxsResponseMessage)
-	if getIncludingBlockHashesOfTxsResponse.Error != nil {
-		return nil, c.convertRPCError(getIncludingBlockHashesOfTxsResponse.Error)
-	}
-	return getIncludingBlockHashesOfTxsResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_including_blocks_of_txs.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetIncludingBlocksTxs sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetIncludingBlocksTxs(txIDs []string, includeTransactions bool) (*appmessage.GetIncludingBlocksOfTxsResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetIncludingBlocksOfTxsRequest(txIDs, includeTransactions))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetIncludingBlocksOfTxsResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getIncludingBlocksOfTxsResponse := response.(*appmessage.GetIncludingBlocksOfTxsResponseMessage)
-	if getIncludingBlocksOfTxsResponse.Error != nil {
-		return nil, c.convertRPCError(getIncludingBlocksOfTxsResponse.Error)
-	}
-	return getIncludingBlocksOfTxsResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_tx.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetTx sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetTx(txID string) (*appmessage.GetTxResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetTxRequest(txID))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetTxResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getTxResponse := response.(*appmessage.GetTxResponseMessage)
-	if getTxResponse.Error != nil {
-		return nil, c.convertRPCError(getTxResponse.Error)
-	}
-	return getTxResponse, nil
-}

infrastructure/network/rpcclient/rpc_get_tx_confirmations.go

@@ -1,20 +0,0 @@
-package rpcclient
-
-import "github.com/kaspanet/kaspad/app/appmessage"
-
-// GetTxConfirmations sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetTxConfirmations(txID string) (*appmessage.GetTxConfirmationsResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetTxConfirmationsRequest(txID))
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.route(appmessage.CmdGetTxConfirmationsResponseMessage).DequeueWithTimeout(c.timeout)
-	if err != nil {
-		return nil, err
-	}
-	getTxConfirmationsResponse := response.(*appmessage.GetTxConfirmationsResponseMessage)
-	if getTxConfirmationsResponse.Error != nil {
-		return nil, c.convertRPCError(getTxConfirmationsResponse.Error)
-	}
-	return getTxConfirmationsResponse, nil
-}