set-up client commnds

infrastructure/network/rpcclient/rpc_get_accepting_block_of_tx.go

@@ -0,0 +1,20 @@
+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) (*appmessage.GetAcceptingBlockOfTxResponseMessage, error) {
+	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlockOfTxRequest(txID))
+	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

@@ -2,8 +2,8 @@ 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) {
+// GetAcceptingBlockHashOfTxs sends an RPC request respective to the function's name and returns the RPC server's response
+func (c *RPCClient) GetAcceptingBlockHashOfTxs(txID string) (*appmessage.GetAcceptingBlockHashOfTxResponseMessage, error) {
 	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlockHashOfTxRequest(txID))
 	if err != nil {
 		return nil, err

infrastructure/network/rpcclient/rpc_get_accepting_blockhashes_of_txs.go

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

infrastructure/network/rpcclient/rpc_get_accepting_blocks_of_txs.go

@@ -0,0 +1,20 @@
+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) (*appmessage.GetAcceptingBlocksOfTxsResponseMessage, error) {
+	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetAcceptingBlocksOfTxsRequest(txIDs))
+	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_coin_supply copy.go

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

infrastructure/network/rpcclient/rpc_get_including_blockhash_of_tx.go

@@ -0,0 +1,20 @@
+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_tx.go

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

@@ -0,0 +1,20 @@
+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) 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
+}

infrastructure/network/rpcclient/rpc_get_txs.go

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

infrastructure/network/rpcclient/rpc_get_txs_confirmations.go

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