9ca93b30ad
This commit contains several changes needed to update the client to use the latest version of btcjson. In addition, it contains a couple of other minor changes along the way. While the underlying changes are quite large, the public API of this package is still the same, so caller should generally not have to update their code due to that. However, the underlying btcjson package API has changed significantly. Since this package hides the vast majority of that from callers, it should not afffect them very much. However, one area in particular to watch out for is that the old btcjson.Error is now btcjson.RPCError, so any callers doing any type assertions there will need to update. The following is a summary of the changes: - The underlying btcjson significantly changed how commands work, so the internals of this package have been reworked to be based off of requests instead of the now non-existant btcjson.Cmd interface - Update all call sites of btcjson.New<Foo>Cmd since they can no longer error or take varargs - The ids for each request are part of the request now instead of the command to match the new btcjson model and are strict uint64s so type assertions are no longer needed (slightly improved efficiency) - Remove the old temporary workaround for the getbalance command with an account of "*" since btcwallet has since been fixed - Change all instances of JSONToAmount to btcutil.NewAmount since that function was removed in favor of btcutil.Amount - Change all btcws invocations to btcjson since they have been combined
293 lines
9.3 KiB
Go
293 lines
9.3 KiB
Go
// Copyright (c) 2014-2015 Conformal Systems LLC.
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package btcrpcclient
|
|
|
|
import (
|
|
"encoding/json"
|
|
|
|
"github.com/btcsuite/btcd/btcjson/v2/btcjson"
|
|
)
|
|
|
|
// AddNodeCommand enumerates the available commands that the AddNode function
|
|
// accepts.
|
|
type AddNodeCommand string
|
|
|
|
// Constants used to indicate the command for the AddNode function.
|
|
const (
|
|
// ANAdd indicates the specified host should be added as a persistent
|
|
// peer.
|
|
ANAdd AddNodeCommand = "add"
|
|
|
|
// ANRemove indicates the specified peer should be removed.
|
|
ANRemove AddNodeCommand = "remove"
|
|
|
|
// ANOneTry indicates the specified host should try to connect once,
|
|
// but it should not be made persistent.
|
|
ANOneTry AddNodeCommand = "onetry"
|
|
)
|
|
|
|
// String returns the AddNodeCommand in human-readable form.
|
|
func (cmd AddNodeCommand) String() string {
|
|
return string(cmd)
|
|
}
|
|
|
|
// FutureAddNodeResult is a future promise to deliver the result of an
|
|
// AddNodeAsync RPC invocation (or an applicable error).
|
|
type FutureAddNodeResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns an error if
|
|
// any occurred when performing the specified command.
|
|
func (r FutureAddNodeResult) Receive() error {
|
|
_, err := receiveFuture(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// AddNodeAsync returns an instance of a type that can be used to get the result
|
|
// of the RPC at some future time by invoking the Receive function on the
|
|
// returned instance.
|
|
//
|
|
// See AddNode for the blocking version and more details.
|
|
func (c *Client) AddNodeAsync(host string, command AddNodeCommand) FutureAddNodeResult {
|
|
cmd := btcjson.NewAddNodeCmd(host, btcjson.AddNodeSubCmd(command))
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// AddNode attempts to perform the passed command on the passed persistent peer.
|
|
// For example, it can be used to add or a remove a persistent peer, or to do
|
|
// a one time connection to a peer.
|
|
//
|
|
// It may not be used to remove non-persistent peers.
|
|
func (c *Client) AddNode(host string, command AddNodeCommand) error {
|
|
return c.AddNodeAsync(host, command).Receive()
|
|
}
|
|
|
|
// FutureGetAddedNodeInfoResult is a future promise to deliver the result of a
|
|
// GetAddedNodeInfoAsync RPC invocation (or an applicable error).
|
|
type FutureGetAddedNodeInfoResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns information
|
|
// about manually added (persistent) peers.
|
|
func (r FutureGetAddedNodeInfoResult) Receive() ([]btcjson.GetAddedNodeInfoResult, error) {
|
|
res, err := receiveFuture(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Unmarshal as an array of getaddednodeinfo result objects.
|
|
var nodeInfo []btcjson.GetAddedNodeInfoResult
|
|
err = json.Unmarshal(res, &nodeInfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return nodeInfo, nil
|
|
}
|
|
|
|
// GetAddedNodeInfoAsync returns an instance of a type that can be used to get
|
|
// the result of the RPC at some future time by invoking the Receive function on
|
|
// the returned instance.
|
|
//
|
|
// See GetAddedNodeInfo for the blocking version and more details.
|
|
func (c *Client) GetAddedNodeInfoAsync(peer string) FutureGetAddedNodeInfoResult {
|
|
cmd := btcjson.NewGetAddedNodeInfoCmd(true, &peer)
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// GetAddedNodeInfo returns information about manually added (persistent) peers.
|
|
//
|
|
// See GetAddedNodeInfoNoDNS to retrieve only a list of the added (persistent)
|
|
// peers.
|
|
func (c *Client) GetAddedNodeInfo(peer string) ([]btcjson.GetAddedNodeInfoResult, error) {
|
|
return c.GetAddedNodeInfoAsync(peer).Receive()
|
|
}
|
|
|
|
// FutureGetAddedNodeInfoNoDNSResult is a future promise to deliver the result
|
|
// of a GetAddedNodeInfoNoDNSAsync RPC invocation (or an applicable error).
|
|
type FutureGetAddedNodeInfoNoDNSResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns a list of
|
|
// manually added (persistent) peers.
|
|
func (r FutureGetAddedNodeInfoNoDNSResult) Receive() ([]string, error) {
|
|
res, err := receiveFuture(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Unmarshal result as an array of strings.
|
|
var nodes []string
|
|
err = json.Unmarshal(res, &nodes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return nodes, nil
|
|
}
|
|
|
|
// GetAddedNodeInfoNoDNSAsync returns an instance of a type that can be used to
|
|
// get the result of the RPC at some future time by invoking the Receive
|
|
// function on the returned instance.
|
|
//
|
|
// See GetAddedNodeInfoNoDNS for the blocking version and more details.
|
|
func (c *Client) GetAddedNodeInfoNoDNSAsync(peer string) FutureGetAddedNodeInfoNoDNSResult {
|
|
cmd := btcjson.NewGetAddedNodeInfoCmd(false, &peer)
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// GetAddedNodeInfoNoDNS returns a list of manually added (persistent) peers.
|
|
// This works by setting the dns flag to false in the underlying RPC.
|
|
//
|
|
// See GetAddedNodeInfo to obtain more information about each added (persistent)
|
|
// peer.
|
|
func (c *Client) GetAddedNodeInfoNoDNS(peer string) ([]string, error) {
|
|
return c.GetAddedNodeInfoNoDNSAsync(peer).Receive()
|
|
}
|
|
|
|
// FutureGetConnectionCountResult is a future promise to deliver the result
|
|
// of a GetConnectionCountAsync RPC invocation (or an applicable error).
|
|
type FutureGetConnectionCountResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns the number
|
|
// of active connections to other peers.
|
|
func (r FutureGetConnectionCountResult) Receive() (int64, error) {
|
|
res, err := receiveFuture(r)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
// Unmarshal result as an int64.
|
|
var count int64
|
|
err = json.Unmarshal(res, &count)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return count, nil
|
|
}
|
|
|
|
// GetConnectionCountAsync returns an instance of a type that can be used to get
|
|
// the result of the RPC at some future time by invoking the Receive function on
|
|
// the returned instance.
|
|
//
|
|
// See GetConnectionCount for the blocking version and more details.
|
|
func (c *Client) GetConnectionCountAsync() FutureGetConnectionCountResult {
|
|
cmd := btcjson.NewGetConnectionCountCmd()
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// GetConnectionCount returns the number of active connections to other peers.
|
|
func (c *Client) GetConnectionCount() (int64, error) {
|
|
return c.GetConnectionCountAsync().Receive()
|
|
}
|
|
|
|
// FuturePingResult is a future promise to deliver the result of a PingAsync RPC
|
|
// invocation (or an applicable error).
|
|
type FuturePingResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns the result
|
|
// of queueing a ping to be sent to each connected peer.
|
|
func (r FuturePingResult) Receive() error {
|
|
_, err := receiveFuture(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// PingAsync returns an instance of a type that can be used to get the result of
|
|
// the RPC at some future time by invoking the Receive function on the returned
|
|
// instance.
|
|
//
|
|
// See Ping for the blocking version and more details.
|
|
func (c *Client) PingAsync() FuturePingResult {
|
|
cmd := btcjson.NewPingCmd()
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// Ping queues a ping to be sent to each connected peer.
|
|
//
|
|
// Use the GetPeerInfo function and examine the PingTime and PingWait fields to
|
|
// access the ping times.
|
|
func (c *Client) Ping() error {
|
|
return c.PingAsync().Receive()
|
|
}
|
|
|
|
// FutureGetPeerInfoResult is a future promise to deliver the result of a
|
|
// GetPeerInfoAsync RPC invocation (or an applicable error).
|
|
type FutureGetPeerInfoResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns data about
|
|
// each connected network peer.
|
|
func (r FutureGetPeerInfoResult) Receive() ([]btcjson.GetPeerInfoResult, error) {
|
|
res, err := receiveFuture(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Unmarshal result as an array of getpeerinfo result objects.
|
|
var peerInfo []btcjson.GetPeerInfoResult
|
|
err = json.Unmarshal(res, &peerInfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return peerInfo, nil
|
|
}
|
|
|
|
// GetPeerInfoAsync returns an instance of a type that can be used to get the
|
|
// result of the RPC at some future time by invoking the Receive function on the
|
|
// returned instance.
|
|
//
|
|
// See GetPeerInfo for the blocking version and more details.
|
|
func (c *Client) GetPeerInfoAsync() FutureGetPeerInfoResult {
|
|
cmd := btcjson.NewGetPeerInfoCmd()
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// GetPeerInfo returns data about each connected network peer.
|
|
func (c *Client) GetPeerInfo() ([]btcjson.GetPeerInfoResult, error) {
|
|
return c.GetPeerInfoAsync().Receive()
|
|
}
|
|
|
|
// FutureGetNetTotalsResult is a future promise to deliver the result of a
|
|
// GetNetTotalsAsync RPC invocation (or an applicable error).
|
|
type FutureGetNetTotalsResult chan *response
|
|
|
|
// Receive waits for the response promised by the future and returns network
|
|
// traffic statistics.
|
|
func (r FutureGetNetTotalsResult) Receive() (*btcjson.GetNetTotalsResult, error) {
|
|
res, err := receiveFuture(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Unmarshal result as a getnettotals result object.
|
|
var totals btcjson.GetNetTotalsResult
|
|
err = json.Unmarshal(res, &totals)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &totals, nil
|
|
}
|
|
|
|
// GetNetTotalsAsync returns an instance of a type that can be used to get the
|
|
// result of the RPC at some future time by invoking the Receive function on the
|
|
// returned instance.
|
|
//
|
|
// See GetNetTotals for the blocking version and more details.
|
|
func (c *Client) GetNetTotalsAsync() FutureGetNetTotalsResult {
|
|
cmd := btcjson.NewGetNetTotalsCmd()
|
|
return c.sendCmd(cmd)
|
|
}
|
|
|
|
// GetNetTotals returns network traffic statistics.
|
|
func (c *Client) GetNetTotals() (*btcjson.GetNetTotalsResult, error) {
|
|
return c.GetNetTotalsAsync().Receive()
|
|
}
|