func (c *Client) GetPeerInfoAsync() FutureGetPeerInfoResult {
	cmd := soterjson.NewGetPeerInfoCmd()
	return c.sendCmd(cmd)
}
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.
package rpcclient
import (
	"encoding/json"
	"github.com/soteria-dag/soterd/soterjson"
)
type AddNodeCommand string
const (
	ANAdd AddNodeCommand = "add"
	ANRemove AddNodeCommand = "remove"
	ANOneTry AddNodeCommand = "onetry"
)
func (cmd AddNodeCommand) String() string {
	return string(cmd)
}
type FutureAddNodeResult chan *response
func (r FutureAddNodeResult) Receive() error {
	_, err := receiveFuture(r)
	return err
}
func (c *Client) AddNodeAsync(host string, command AddNodeCommand) FutureAddNodeResult {
	cmd := soterjson.NewAddNodeCmd(host, soterjson.AddNodeSubCmd(command))
	return c.sendCmd(cmd)
}
func (c *Client) AddNode(host string, command AddNodeCommand) error {
	return c.AddNodeAsync(host, command).Receive()
}
type FutureNodeResult chan *response
func (r FutureNodeResult) Receive() error {
	_, err := receiveFuture(r)
	return err
}
func (c *Client) NodeAsync(command soterjson.NodeSubCmd, host string,
	connectSubCmd *string) FutureNodeResult {
	cmd := soterjson.NewNodeCmd(command, host, connectSubCmd)
	return c.sendCmd(cmd)
}
func (c *Client) Node(command soterjson.NodeSubCmd, host string,
	connectSubCmd *string) error {
	return c.NodeAsync(command, host, connectSubCmd).Receive()
}
type FutureGetAddedNodeInfoResult chan *response
func (r FutureGetAddedNodeInfoResult) Receive() ([]soterjson.GetAddedNodeInfoResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var nodeInfo []soterjson.GetAddedNodeInfoResult
	err = json.Unmarshal(res, &nodeInfo)
	if err != nil {
		return nil, err
	}
	return nodeInfo, nil
}
func (c *Client) GetAddedNodeInfoAsync(peer string) FutureGetAddedNodeInfoResult {
	cmd := soterjson.NewGetAddedNodeInfoCmd(true, &peer)
	return c.sendCmd(cmd)
}
func (c *Client) GetAddedNodeInfo(peer string) ([]soterjson.GetAddedNodeInfoResult, error) {
	return c.GetAddedNodeInfoAsync(peer).Receive()
}
type FutureGetAddedNodeInfoNoDNSResult chan *response
func (r FutureGetAddedNodeInfoNoDNSResult) Receive() ([]string, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var nodes []string
	err = json.Unmarshal(res, &nodes)
	if err != nil {
		return nil, err
	}
	return nodes, nil
}
func (c *Client) GetAddedNodeInfoNoDNSAsync(peer string) FutureGetAddedNodeInfoNoDNSResult {
	cmd := soterjson.NewGetAddedNodeInfoCmd(false, &peer)
	return c.sendCmd(cmd)
}
func (c *Client) GetAddedNodeInfoNoDNS(peer string) ([]string, error) {
	return c.GetAddedNodeInfoNoDNSAsync(peer).Receive()
}
type FutureGetConnectionCountResult chan *response
func (r FutureGetConnectionCountResult) Receive() (int64, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return 0, err
	}
	var count int64
	err = json.Unmarshal(res, &count)
	if err != nil {
		return 0, err
	}
	return count, nil
}
type FutureGetAddrCacheResult chan *response
func (r FutureGetAddrCacheResult) Receive() (*soterjson.GetAddrCacheResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var addrCache soterjson.GetAddrCacheResult
	if err := json.Unmarshal(res, &addrCache); err != nil {
		return nil, err
	}
	return &addrCache, nil
}
func (c *Client) GetAddrCacheAsync() FutureGetAddrCacheResult {
	cmd := soterjson.NewGetAddrCacheCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetAddrCache() (*soterjson.GetAddrCacheResult, error) {
	return c.GetAddrCacheAsync().Receive()
}
func (c *Client) GetConnectionCountAsync() FutureGetConnectionCountResult {
	cmd := soterjson.NewGetConnectionCountCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetConnectionCount() (int64, error) {
	return c.GetConnectionCountAsync().Receive()
}
type FuturePingResult chan *response
func (r FuturePingResult) Receive() error {
	_, err := receiveFuture(r)
	return err
}
type FutureGetListenAddrsResult chan *response
func (r FutureGetListenAddrsResult) Receive() (*soterjson.GetListenAddrsResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var listenAddrs soterjson.GetListenAddrsResult
	if err := json.Unmarshal(res, &listenAddrs); err != nil {
		return nil, err
	}
	return &listenAddrs, nil
}
func (c *Client) GetListenAddrsAsync() FutureGetListenAddrsResult {
	cmd := soterjson.NewGetListenAddrsCmd()
	return c.sendCmd(cmd)
}
func (c *Client) GetListenAddrs() (*soterjson.GetListenAddrsResult, error) {
	return c.GetListenAddrsAsync().Receive()
}
func (c *Client) PingAsync() FuturePingResult {
	cmd := soterjson.NewPingCmd()
	return c.sendCmd(cmd)
}
func (c *Client) Ping() error {
	return c.PingAsync().Receive()
}
type FutureGetPeerInfoResult chan *response
func (r FutureGetPeerInfoResult) Receive() ([]soterjson.GetPeerInfoResult, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}
	var peerInfo []soterjson.GetPeerInfoResult
	err = json.Unmarshal(res, &peerInfo)
	if err != nil {
		return nil, err
	}
	return peerInfo, nil
}