Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

rpcclient

package

Go to main page

Versions in this module

v0

v0.26.1

Jul 18, 2023

Changes in this version

type Client

+ func (c *Client) GetBestChainlock() (*btcjson.GetBestChainlockResult, error)

+ func (c *Client) GetBestChainlockAsync() FutureGetBestChainlockResult

+ type FutureGetBestChainlockResult chan *Response

+ func (r FutureGetBestChainlockResult) Receive() (result *btcjson.GetBestChainlockResult, err error)

v0.26.0

Jul 12, 2023

v0.25.0

Jun 13, 2023

Changes in this version

+ var ErrClientAlreadyConnected = errors.New(...)

+ var ErrClientDisconnect = errors.New("the client has been disconnected")

+ var ErrClientNotConnected = errors.New("the client was never connected")

+ var ErrClientShutdown = errors.New("the client has been shutdown")

+ var ErrInvalidAuth = errors.New("authentication failure")

+ var ErrInvalidEndpoint = errors.New(...)

+ var ErrNotWebsocketClient = errors.New(...)

+ var ErrWebsocketsRequired = errors.New(...)

+ func DisableLog()

+ func ReceiveFuture(f chan *Response) ([]byte, error)

+ func UseLogger(logger btclog.Logger)

+ type AddNodeCommand string

+ const ANAdd

+ const ANOneTry

+ const ANRemove

+ func (cmd AddNodeCommand) String() string

+ type BackendVersion uint8

+ const BitcoindPost19

+ const BitcoindPre19

+ const Btcd

+ type BulkResult = map[uint64]IndividualBulkResult

+ type Client struct

+ func New(config *ConnConfig, ntfnHandlers *NotificationHandlers) (*Client, error)

+ func NewBatch(config *ConnConfig) (*Client, error)

+ func (c *Client) AddMultisigAddress(requiredSigs int, addresses []btcutil.Address, account string) (btcutil.Address, error)

+ func (c *Client) AddMultisigAddressAsync(requiredSigs int, addresses []btcutil.Address, account string) FutureAddMultisigAddressResult

+ func (c *Client) AddNode(host string, command AddNodeCommand) error

+ func (c *Client) AddNodeAsync(host string, command AddNodeCommand) FutureAddNodeResult

+ func (c *Client) AddWitnessAddress(address string) (btcutil.Address, error)

+ func (c *Client) AddWitnessAddressAsync(address string) FutureAddWitnessAddressResult

+ func (c *Client) BLSFromSecret(secret string) (*btcjson.BLSResult, error)

+ func (c *Client) BLSFromSecretAsync(secret string) FutureGetBLSResult

+ func (c *Client) BLSGenerate() (*btcjson.BLSResult, error)

+ func (c *Client) BLSGenerateAsync() FutureGetBLSResult

+ func (c *Client) BackendVersion() (BackendVersion, error)

+ func (c *Client) BackupWallet(destination string) error

+ func (c *Client) BackupWalletAsync(destination string) FutureBackupWalletResult

+ func (c *Client) Connect(tries int) error

+ func (c *Client) CreateEncryptedWallet(passphrase string) error

+ func (c *Client) CreateEncryptedWalletAsync(passphrase string) FutureCreateEncryptedWalletResult

+ func (c *Client) CreateMultisig(requiredSigs int, addresses []btcutil.Address) (*btcjson.CreateMultiSigResult, error)

+ func (c *Client) CreateMultisigAsync(requiredSigs int, addresses []btcutil.Address) FutureCreateMultisigResult

+ func (c *Client) CreateNewAccount(account string) error

+ func (c *Client) CreateNewAccountAsync(account string) FutureCreateNewAccountResult

+ func (c *Client) CreateRawTransaction(inputs []btcjson.TransactionInput, amounts map[btcutil.Address]btcutil.Amount, ...) (*wire.MsgTx, error)

+ func (c *Client) CreateRawTransactionAsync(inputs []btcjson.TransactionInput, amounts map[btcutil.Address]btcutil.Amount, ...) FutureCreateRawTransactionResult

+ func (c *Client) CreateWallet(name string, opts ...CreateWalletOpt) (*btcjson.CreateWalletResult, error)

+ func (c *Client) CreateWalletAsync(name string, opts ...CreateWalletOpt) FutureCreateWalletResult

+ func (c *Client) DebugLevel(levelSpec string) (string, error)

+ func (c *Client) DebugLevelAsync(levelSpec string) FutureDebugLevelResult

+ func (c *Client) DecodeRawTransaction(serializedTx []byte) (*btcjson.TxRawResult, error)

+ func (c *Client) DecodeRawTransactionAsync(serializedTx []byte) FutureDecodeRawTransactionResult

+ func (c *Client) DecodeScript(serializedScript []byte) (*btcjson.DecodeScriptResult, error)

+ func (c *Client) DecodeScriptAsync(serializedScript []byte) FutureDecodeScriptResult

+ func (c *Client) DeriveAddresses(descriptor string, descriptorRange *btcjson.DescriptorRange) (*btcjson.DeriveAddressesResult, error)

+ func (c *Client) DeriveAddressesAsync(descriptor string, descriptorRange *btcjson.DescriptorRange) FutureDeriveAddressesResult

+ func (c *Client) Disconnect()

+ func (c *Client) Disconnected() bool

+ func (c *Client) DumpPrivKey(address btcutil.Address) (*btcutil.WIF, error)

+ func (c *Client) DumpPrivKeyAsync(address btcutil.Address) FutureDumpPrivKeyResult

+ func (c *Client) DumpWallet(destination string) (*btcjson.DumpWalletResult, error)

+ func (c *Client) DumpWalletAsync(destination string) FutureDumpWalletResult

+ func (c *Client) EstimateFee(numBlocks int64) (float64, error)

+ func (c *Client) EstimateFeeAsync(numBlocks int64) FutureEstimateFeeResult

+ func (c *Client) EstimateSmartFee(confTarget int64, mode *btcjson.EstimateSmartFeeMode) (*btcjson.EstimateSmartFeeResult, error)

+ func (c *Client) EstimateSmartFeeAsync(confTarget int64, mode *btcjson.EstimateSmartFeeMode) FutureEstimateSmartFeeResult

+ func (c *Client) ExportWatchingWallet(account string) ([]byte, []byte, error)

+ func (c *Client) ExportWatchingWalletAsync(account string) FutureExportWatchingWalletResult

+ func (c *Client) FundRawTransaction(tx *wire.MsgTx, opts btcjson.FundRawTransactionOpts, isWitness *bool) (*btcjson.FundRawTransactionResult, error)

+ func (c *Client) FundRawTransactionAsync(tx *wire.MsgTx, opts btcjson.FundRawTransactionOpts, isWitness *bool) FutureFundRawTransactionResult

+ func (c *Client) Generate(numBlocks uint32) ([]*chainhash.Hash, error)

+ func (c *Client) GenerateAsync(numBlocks uint32) FutureGenerateResult

+ func (c *Client) GenerateToAddress(numBlocks int64, address btcutil.Address, maxTries *int64) ([]*chainhash.Hash, error)

+ func (c *Client) GenerateToAddressAsync(numBlocks int64, address btcutil.Address, maxTries *int64) FutureGenerateToAddressResult

+ func (c *Client) GetAccount(address btcutil.Address) (string, error)

+ func (c *Client) GetAccountAddress(account string) (btcutil.Address, error)

+ func (c *Client) GetAccountAddressAsync(account string) FutureGetAccountAddressResult

+ func (c *Client) GetAccountAsync(address btcutil.Address) FutureGetAccountResult

+ func (c *Client) GetAddedNodeInfo(peer string) ([]btcjson.GetAddedNodeInfoResult, error)

+ func (c *Client) GetAddedNodeInfoAsync(peer string) FutureGetAddedNodeInfoResult

+ func (c *Client) GetAddedNodeInfoNoDNS(peer string) ([]string, error)

+ func (c *Client) GetAddedNodeInfoNoDNSAsync(peer string) FutureGetAddedNodeInfoNoDNSResult

+ func (c *Client) GetAddressInfo(address string) (*btcjson.GetAddressInfoResult, error)

+ func (c *Client) GetAddressInfoAsync(address string) FutureGetAddressInfoResult

+ func (c *Client) GetAddressesByAccount(account string) ([]btcutil.Address, error)

+ func (c *Client) GetAddressesByAccountAsync(account string) FutureGetAddressesByAccountResult

+ func (c *Client) GetBalance(account string) (btcutil.Amount, error)

+ func (c *Client) GetBalanceAsync(account string) FutureGetBalanceResult

+ func (c *Client) GetBalanceMinConf(account string, minConfirms int) (btcutil.Amount, error)

+ func (c *Client) GetBalanceMinConfAsync(account string, minConfirms int) FutureGetBalanceResult

+ func (c *Client) GetBalances() (*btcjson.GetBalancesResult, error)

+ func (c *Client) GetBalancesAsync() FutureGetBalancesResult

+ func (c *Client) GetBestBlock() (*chainhash.Hash, int32, error)

+ func (c *Client) GetBestBlockAsync() FutureGetBestBlockResult

+ func (c *Client) GetBestBlockHash() (*chainhash.Hash, error)

+ func (c *Client) GetBestBlockHashAsync() FutureGetBestBlockHashResult

+ func (c *Client) GetBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error)

+ func (c *Client) GetBlockAsync(blockHash *chainhash.Hash) FutureGetBlockResult

+ func (c *Client) GetBlockChainInfo() (*btcjson.GetBlockChainInfoResult, error)

+ func (c *Client) GetBlockChainInfoAsync() FutureGetBlockChainInfoResult

+ func (c *Client) GetBlockCount() (int64, error)

+ func (c *Client) GetBlockCountAsync() FutureGetBlockCountResult

+ func (c *Client) GetBlockFilter(blockHash chainhash.Hash, filterType *btcjson.FilterTypeName) (*btcjson.GetBlockFilterResult, error)

+ func (c *Client) GetBlockFilterAsync(blockHash chainhash.Hash, filterType *btcjson.FilterTypeName) FutureGetBlockFilterResult

+ func (c *Client) GetBlockHash(blockHeight int64) (*chainhash.Hash, error)

+ func (c *Client) GetBlockHashAsync(blockHeight int64) FutureGetBlockHashResult

+ func (c *Client) GetBlockHeader(blockHash *chainhash.Hash) (*wire.BlockHeader, error)

+ func (c *Client) GetBlockHeaderAsync(blockHash *chainhash.Hash) FutureGetBlockHeaderResult

+ func (c *Client) GetBlockHeaderVerbose(blockHash *chainhash.Hash) (*btcjson.GetBlockHeaderVerboseResult, error)

+ func (c *Client) GetBlockHeaderVerboseAsync(blockHash *chainhash.Hash) FutureGetBlockHeaderVerboseResult

+ func (c *Client) GetBlockStats(hashOrHeight interface{}, stats *[]string) (*btcjson.GetBlockStatsResult, error)

+ func (c *Client) GetBlockStatsAsync(hashOrHeight interface{}, stats *[]string) FutureGetBlockStatsResult

+ func (c *Client) GetBlockTemplate(req *btcjson.TemplateRequest) (*btcjson.GetBlockTemplateResult, error)

+ func (c *Client) GetBlockTemplateAsync(req *btcjson.TemplateRequest) FutureGetBlockTemplateResponse

+ func (c *Client) GetBlockVerbose(blockHash *chainhash.Hash) (*btcjson.GetBlockVerboseResult, error)

+ func (c *Client) GetBlockVerboseAsync(blockHash *chainhash.Hash) FutureGetBlockVerboseResult

+ func (c *Client) GetBlockVerboseTx(blockHash *chainhash.Hash) (*btcjson.GetBlockVerboseTxResult, error)

+ func (c *Client) GetBlockVerboseTxAsync(blockHash *chainhash.Hash) FutureGetBlockVerboseTxResult

+ func (c *Client) GetCFilter(blockHash *chainhash.Hash, filterType wire.FilterType) (*wire.MsgCFilter, error)

+ func (c *Client) GetCFilterAsync(blockHash *chainhash.Hash, filterType wire.FilterType) FutureGetCFilterResult

+ func (c *Client) GetCFilterHeader(blockHash *chainhash.Hash, filterType wire.FilterType) (*wire.MsgCFHeaders, error)

+ func (c *Client) GetCFilterHeaderAsync(blockHash *chainhash.Hash, filterType wire.FilterType) FutureGetCFilterHeaderResult

+ func (c *Client) GetChainTxStats() (*btcjson.GetChainTxStatsResult, error)

+ func (c *Client) GetChainTxStatsAsync() FutureGetChainTxStatsResult

+ func (c *Client) GetChainTxStatsNBlocks(nBlocks int32) (*btcjson.GetChainTxStatsResult, error)

+ func (c *Client) GetChainTxStatsNBlocksAsync(nBlocks int32) FutureGetChainTxStatsResult

+ func (c *Client) GetChainTxStatsNBlocksBlockHash(nBlocks int32, blockHash chainhash.Hash) (*btcjson.GetChainTxStatsResult, error)

+ func (c *Client) GetChainTxStatsNBlocksBlockHashAsync(nBlocks int32, blockHash chainhash.Hash) FutureGetChainTxStatsResult

+ func (c *Client) GetConnectionCount() (int64, error)

+ func (c *Client) GetConnectionCountAsync() FutureGetConnectionCountResult

+ func (c *Client) GetCurrentNet() (wire.BitcoinNet, error)

+ func (c *Client) GetCurrentNetAsync() FutureGetCurrentNetResult

+ func (c *Client) GetDescriptorInfo(descriptor string) (*btcjson.GetDescriptorInfoResult, error)

+ func (c *Client) GetDescriptorInfoAsync(descriptor string) FutureGetDescriptorInfoResult

+ func (c *Client) GetDifficulty() (float64, error)

+ func (c *Client) GetDifficultyAsync() FutureGetDifficultyResult

+ func (c *Client) GetGenerate() (bool, error)

+ func (c *Client) GetGenerateAsync() FutureGetGenerateResult

+ func (c *Client) GetHashesPerSec() (int64, error)

+ func (c *Client) GetHashesPerSecAsync() FutureGetHashesPerSecResult

+ func (c *Client) GetHeaders(blockLocators []chainhash.Hash, hashStop *chainhash.Hash) ([]wire.BlockHeader, error)

+ func (c *Client) GetHeadersAsync(blockLocators []chainhash.Hash, hashStop *chainhash.Hash) FutureGetHeadersResult

+ func (c *Client) GetInfo() (*btcjson.InfoWalletResult, error)

+ func (c *Client) GetInfoAsync() FutureGetInfoResult

+ func (c *Client) GetMempoolEntry(txHash string) (*btcjson.GetMempoolEntryResult, error)

+ func (c *Client) GetMempoolEntryAsync(txHash string) FutureGetMempoolEntryResult

+ func (c *Client) GetMiningInfo() (*btcjson.GetMiningInfoResult, error)

+ func (c *Client) GetMiningInfoAsync() FutureGetMiningInfoResult

+ func (c *Client) GetNetTotals() (*btcjson.GetNetTotalsResult, error)

+ func (c *Client) GetNetTotalsAsync() FutureGetNetTotalsResult

+ func (c *Client) GetNetworkHashPS() (float64, error)

+ func (c *Client) GetNetworkHashPS2(blocks int) (float64, error)

+ func (c *Client) GetNetworkHashPS2Async(blocks int) FutureGetNetworkHashPS

+ func (c *Client) GetNetworkHashPS3(blocks, height int) (float64, error)

+ func (c *Client) GetNetworkHashPS3Async(blocks, height int) FutureGetNetworkHashPS

+ func (c *Client) GetNetworkHashPSAsync() FutureGetNetworkHashPS

+ func (c *Client) GetNetworkInfo() (*btcjson.GetNetworkInfoResult, error)

+ func (c *Client) GetNetworkInfoAsync() FutureGetNetworkInfoResult

+ func (c *Client) GetNewAddress(account string) (btcutil.Address, error)

+ func (c *Client) GetNewAddressAsync(account string) FutureGetNewAddressResult

+ func (c *Client) GetNodeAddresses(count *int32) ([]btcjson.GetNodeAddressesResult, error)

+ func (c *Client) GetNodeAddressesAsync(count *int32) FutureGetNodeAddressesResult

+ func (c *Client) GetPeerInfo() ([]btcjson.GetPeerInfoResult, error)

+ func (c *Client) GetPeerInfoAsync() FutureGetPeerInfoResult

+ func (c *Client) GetRawChangeAddress(account string) (btcutil.Address, error)

+ func (c *Client) GetRawChangeAddressAsync(account string) FutureGetRawChangeAddressResult

+ func (c *Client) GetRawMempool() ([]*chainhash.Hash, error)

+ func (c *Client) GetRawMempoolAsync() FutureGetRawMempoolResult

+ func (c *Client) GetRawMempoolVerbose() (map[string]btcjson.GetRawMempoolVerboseResult, error)

+ func (c *Client) GetRawMempoolVerboseAsync() FutureGetRawMempoolVerboseResult

+ func (c *Client) GetRawTransaction(txHash *chainhash.Hash) (*btcutil.Tx, error)

+ func (c *Client) GetRawTransactionAsync(txHash *chainhash.Hash) FutureGetRawTransactionResult

+ func (c *Client) GetRawTransactionVerbose(txHash *chainhash.Hash) (*btcjson.TxRawResult, error)

+ func (c *Client) GetRawTransactionVerboseAsync(txHash *chainhash.Hash) FutureGetRawTransactionVerboseResult

+ func (c *Client) GetReceivedByAccount(account string) (btcutil.Amount, error)

+ func (c *Client) GetReceivedByAccountAsync(account string) FutureGetReceivedByAccountResult

+ func (c *Client) GetReceivedByAccountMinConf(account string, minConfirms int) (btcutil.Amount, error)

+ func (c *Client) GetReceivedByAccountMinConfAsync(account string, minConfirms int) FutureGetReceivedByAccountResult

+ func (c *Client) GetReceivedByAddress(address btcutil.Address) (btcutil.Amount, error)

+ func (c *Client) GetReceivedByAddressAsync(address btcutil.Address) FutureGetReceivedByAddressResult

+ func (c *Client) GetReceivedByAddressMinConf(address btcutil.Address, minConfirms int) (btcutil.Amount, error)

+ func (c *Client) GetReceivedByAddressMinConfAsync(address btcutil.Address, minConfirms int) FutureGetReceivedByAddressResult

+ func (c *Client) GetTransaction(txHash *chainhash.Hash) (*btcjson.GetTransactionResult, error)

+ func (c *Client) GetTransactionAsync(txHash *chainhash.Hash) FutureGetTransactionResult

+ func (c *Client) GetTransactionWatchOnly(txHash *chainhash.Hash, watchOnly bool) (*btcjson.GetTransactionResult, error)

+ func (c *Client) GetTransactionWatchOnlyAsync(txHash *chainhash.Hash, watchOnly bool) FutureGetTransactionResult

+ func (c *Client) GetTxOut(txHash *chainhash.Hash, index uint32, mempool bool) (*btcjson.GetTxOutResult, error)

+ func (c *Client) GetTxOutAsync(txHash *chainhash.Hash, index uint32, mempool bool) FutureGetTxOutResult

+ func (c *Client) GetTxOutSetInfo() (*btcjson.GetTxOutSetInfoResult, error)

+ func (c *Client) GetTxOutSetInfoAsync() FutureGetTxOutSetInfoResult

+ func (c *Client) GetUnconfirmedBalance(account string) (btcutil.Amount, error)

+ func (c *Client) GetUnconfirmedBalanceAsync(account string) FutureGetUnconfirmedBalanceResult

+ func (c *Client) GetWalletInfo() (*btcjson.GetWalletInfoResult, error)

+ func (c *Client) GetWalletInfoAsync() FutureGetWalletInfoResult

+ func (c *Client) GetWork() (*btcjson.GetWorkResult, error)

+ func (c *Client) GetWorkAsync() FutureGetWork

+ func (c *Client) GetWorkSubmit(data string) (bool, error)

+ func (c *Client) GetWorkSubmitAsync(data string) FutureGetWorkSubmit

+ func (c *Client) ImportAddress(address string) error

+ func (c *Client) ImportAddressAsync(address string) FutureImportAddressResult

+ func (c *Client) ImportAddressRescan(address string, account string, rescan bool) error

+ func (c *Client) ImportAddressRescanAsync(address string, account string, rescan bool) FutureImportAddressResult

+ func (c *Client) ImportMulti(requests []btcjson.ImportMultiRequest, options *btcjson.ImportMultiOptions) (btcjson.ImportMultiResults, error)

+ func (c *Client) ImportMultiAsync(requests []btcjson.ImportMultiRequest, options *btcjson.ImportMultiOptions) FutureImportMultiResult

+ func (c *Client) ImportPrivKey(privKeyWIF *btcutil.WIF) error

+ func (c *Client) ImportPrivKeyAsync(privKeyWIF *btcutil.WIF) FutureImportPrivKeyResult

+ func (c *Client) ImportPrivKeyLabel(privKeyWIF *btcutil.WIF, label string) error

+ func (c *Client) ImportPrivKeyLabelAsync(privKeyWIF *btcutil.WIF, label string) FutureImportPrivKeyResult

+ func (c *Client) ImportPrivKeyRescan(privKeyWIF *btcutil.WIF, label string, rescan bool) error

+ func (c *Client) ImportPrivKeyRescanAsync(privKeyWIF *btcutil.WIF, label string, rescan bool) FutureImportPrivKeyResult

+ func (c *Client) ImportPubKey(pubKey string) error

+ func (c *Client) ImportPubKeyAsync(pubKey string) FutureImportPubKeyResult

+ func (c *Client) ImportPubKeyRescan(pubKey string, rescan bool) error

+ func (c *Client) ImportPubKeyRescanAsync(pubKey string, rescan bool) FutureImportPubKeyResult

+ func (c *Client) ImportWallet(filename string) error

+ func (c *Client) ImportWalletAsync(filename string) FutureImportWalletResult

+ func (c *Client) InvalidateBlock(blockHash *chainhash.Hash) error

+ func (c *Client) InvalidateBlockAsync(blockHash *chainhash.Hash) FutureInvalidateBlockResult

+ func (c *Client) KeyPoolRefill() error

+ func (c *Client) KeyPoolRefillAsync() FutureKeyPoolRefillResult

+ func (c *Client) KeyPoolRefillSize(newSize uint) error

+ func (c *Client) KeyPoolRefillSizeAsync(newSize uint) FutureKeyPoolRefillResult

+ func (c *Client) ListAccounts() (map[string]btcutil.Amount, error)

+ func (c *Client) ListAccountsAsync() FutureListAccountsResult

+ func (c *Client) ListAccountsMinConf(minConfirms int) (map[string]btcutil.Amount, error)

+ func (c *Client) ListAccountsMinConfAsync(minConfirms int) FutureListAccountsResult

+ func (c *Client) ListAddressTransactions(addresses []btcutil.Address, account string) ([]btcjson.ListTransactionsResult, error)

+ func (c *Client) ListAddressTransactionsAsync(addresses []btcutil.Address, account string) FutureListAddressTransactionsResult

+ func (c *Client) ListLockUnspent() ([]*wire.OutPoint, error)

+ func (c *Client) ListLockUnspentAsync() FutureListLockUnspentResult

+ func (c *Client) ListReceivedByAccount() ([]btcjson.ListReceivedByAccountResult, error)

+ func (c *Client) ListReceivedByAccountAsync() FutureListReceivedByAccountResult

+ func (c *Client) ListReceivedByAccountIncludeEmpty(minConfirms int, includeEmpty bool) ([]btcjson.ListReceivedByAccountResult, error)

+ func (c *Client) ListReceivedByAccountIncludeEmptyAsync(minConfirms int, includeEmpty bool) FutureListReceivedByAccountResult

+ func (c *Client) ListReceivedByAccountMinConf(minConfirms int) ([]btcjson.ListReceivedByAccountResult, error)

+ func (c *Client) ListReceivedByAccountMinConfAsync(minConfirms int) FutureListReceivedByAccountResult

+ func (c *Client) ListReceivedByAddress() ([]btcjson.ListReceivedByAddressResult, error)

+ func (c *Client) ListReceivedByAddressAsync() FutureListReceivedByAddressResult

+ func (c *Client) ListReceivedByAddressIncludeEmpty(minConfirms int, includeEmpty bool) ([]btcjson.ListReceivedByAddressResult, error)

+ func (c *Client) ListReceivedByAddressIncludeEmptyAsync(minConfirms int, includeEmpty bool) FutureListReceivedByAddressResult

+ func (c *Client) ListReceivedByAddressMinConf(minConfirms int) ([]btcjson.ListReceivedByAddressResult, error)

+ func (c *Client) ListReceivedByAddressMinConfAsync(minConfirms int) FutureListReceivedByAddressResult

+ func (c *Client) ListSinceBlock(blockHash *chainhash.Hash) (*btcjson.ListSinceBlockResult, error)

+ func (c *Client) ListSinceBlockAsync(blockHash *chainhash.Hash) FutureListSinceBlockResult

+ func (c *Client) ListSinceBlockMinConf(blockHash *chainhash.Hash, minConfirms int) (*btcjson.ListSinceBlockResult, error)

+ func (c *Client) ListSinceBlockMinConfAsync(blockHash *chainhash.Hash, minConfirms int) FutureListSinceBlockResult

+ func (c *Client) ListSinceBlockMinConfWatchOnly(blockHash *chainhash.Hash, minConfirms int, watchOnly bool) (*btcjson.ListSinceBlockResult, error)

+ func (c *Client) ListSinceBlockMinConfWatchOnlyAsync(blockHash *chainhash.Hash, minConfirms int, watchOnly bool) FutureListSinceBlockResult

+ func (c *Client) ListTransactions(account string) ([]btcjson.ListTransactionsResult, error)

+ func (c *Client) ListTransactionsAsync(account string) FutureListTransactionsResult

+ func (c *Client) ListTransactionsCount(account string, count int) ([]btcjson.ListTransactionsResult, error)

+ func (c *Client) ListTransactionsCountAsync(account string, count int) FutureListTransactionsResult

+ func (c *Client) ListTransactionsCountFrom(account string, count, from int) ([]btcjson.ListTransactionsResult, error)

+ func (c *Client) ListTransactionsCountFromAsync(account string, count, from int) FutureListTransactionsResult

+ func (c *Client) ListTransactionsCountFromWatchOnly(account string, count, from int, watchOnly bool) ([]btcjson.ListTransactionsResult, error)

+ func (c *Client) ListTransactionsCountFromWatchOnlyAsync(account string, count, from int, watchOnly bool) FutureListTransactionsResult

+ func (c *Client) ListUnspent() ([]btcjson.ListUnspentResult, error)

+ func (c *Client) ListUnspentAsync() FutureListUnspentResult

+ func (c *Client) ListUnspentMin(minConf int) ([]btcjson.ListUnspentResult, error)

+ func (c *Client) ListUnspentMinAsync(minConf int) FutureListUnspentResult

+ func (c *Client) ListUnspentMinMax(minConf, maxConf int) ([]btcjson.ListUnspentResult, error)

+ func (c *Client) ListUnspentMinMaxAddresses(minConf, maxConf int, addrs []btcutil.Address) ([]btcjson.ListUnspentResult, error)

+ func (c *Client) ListUnspentMinMaxAddressesAsync(minConf, maxConf int, addrs []btcutil.Address) FutureListUnspentResult

+ func (c *Client) ListUnspentMinMaxAsync(minConf, maxConf int) FutureListUnspentResult

+ func (c *Client) LoadTxFilter(reload bool, addresses []btcutil.Address, outPoints []wire.OutPoint) error

+ func (c *Client) LoadTxFilterAsync(reload bool, addresses []btcutil.Address, outPoints []wire.OutPoint) FutureLoadTxFilterResult

+ func (c *Client) LoadWallet(walletName string) (*btcjson.LoadWalletResult, error)

+ func (c *Client) LoadWalletAsync(walletName string) FutureLoadWalletResult

+ func (c *Client) LockUnspent(unlock bool, ops []*wire.OutPoint) error

+ func (c *Client) LockUnspentAsync(unlock bool, ops []*wire.OutPoint) FutureLockUnspentResult

+ func (c *Client) MasternodeCount() (*btcjson.MasternodeCountResult, error)

+ func (c *Client) MasternodeCountAsync() FutureGetMasternodeCountResult

+ func (c *Client) MasternodeCurrent() (*btcjson.MasternodeResult, error)

+ func (c *Client) MasternodeCurrentAsync() FutureGetMasternodeResult

+ func (c *Client) MasternodeList(mode, filter string) (interface{}, error)

+ func (c *Client) MasternodeListAsync(mode, filter string) FutureGetMasternodeListResult

+ func (c *Client) MasternodeListJSON(filter string) (map[string]btcjson.MasternodelistResultJSON, error)

+ func (c *Client) MasternodeOutputs() (map[string]string, error)

+ func (c *Client) MasternodeOutputsAsync() FutureGetMasternodeOutputsResult

+ func (c *Client) MasternodeStatus() (*btcjson.MasternodeStatusResult, error)

+ func (c *Client) MasternodeStatusAsync() FutureGetMasternodeStatusResult

+ func (c *Client) MasternodeWinner() (*btcjson.MasternodeResult, error)

+ func (c *Client) MasternodeWinnerAsync() FutureGetMasternodeResult

+ func (c *Client) MasternodeWinners(count int, filter string) (map[string]string, error)

+ func (c *Client) MasternodeWinnersAsync(count int, filter string) FutureGetMasternodeWinnersResult

+ func (c *Client) Move(fromAccount, toAccount string, amount btcutil.Amount) (bool, error)

+ func (c *Client) MoveAsync(fromAccount, toAccount string, amount btcutil.Amount) FutureMoveResult

+ func (c *Client) MoveComment(fromAccount, toAccount string, amount btcutil.Amount, minConf int, ...) (bool, error)

+ func (c *Client) MoveCommentAsync(fromAccount, toAccount string, amount btcutil.Amount, minConfirms int, ...) FutureMoveResult

+ func (c *Client) MoveMinConf(fromAccount, toAccount string, amount btcutil.Amount, minConf int) (bool, error)

+ func (c *Client) MoveMinConfAsync(fromAccount, toAccount string, amount btcutil.Amount, minConfirms int) FutureMoveResult

+ func (c *Client) NextID() uint64

+ func (c *Client) Node(command btcjson.NodeSubCmd, host string, connectSubCmd *string) error

+ func (c *Client) NodeAsync(command btcjson.NodeSubCmd, host string, connectSubCmd *string) FutureNodeResult

+ func (c *Client) NotifyBlocks() error

+ func (c *Client) NotifyBlocksAsync() FutureNotifyBlocksResult

+ func (c *Client) NotifyNewTransactions(verbose bool) error

+ func (c *Client) NotifyNewTransactionsAsync(verbose bool) FutureNotifyNewTransactionsResult

+ func (c *Client) NotifyReceived(addresses []btcutil.Address) error

+ func (c *Client) NotifyReceivedAsync(addresses []btcutil.Address) FutureNotifyReceivedResult

+ func (c *Client) NotifySpent(outpoints []*wire.OutPoint) error

+ func (c *Client) NotifySpentAsync(outpoints []*wire.OutPoint) FutureNotifySpentResult

+ func (c *Client) Ping() error

+ func (c *Client) PingAsync() FuturePingResult

+ func (c *Client) ProTxDiff(baseBlock, block int) (*btcjson.ProTxDiffResult, error)

+ func (c *Client) ProTxDiffAsync(baseBlock, block int) FutureGetProTxDiffResult

+ func (c *Client) ProTxInfo(proTxHash string) (*btcjson.ProTxInfoResult, error)

+ func (c *Client) ProTxInfoAsync(proTxHash string) FutureGetProTxInfoResult

+ func (c *Client) ProTxList(cmdType btcjson.ProTxListType, detailed bool, height int) (interface{}, error)

+ func (c *Client) ProTxListAsync(cmdType btcjson.ProTxListType, detailed bool, height int) FutureGetProTxListResult

+ func (c *Client) ProTxRegister(collateralHash string, collateralIndex int, ...) (string, error)

+ func (c *Client) ProTxRegisterAsync(collateralHash string, collateralIndex int, ...) FutureGetProTxStringResult

+ func (c *Client) ProTxRegisterFund(...) (string, error)

+ func (c *Client) ProTxRegisterFundAsync(...) FutureGetProTxStringResult

+ func (c *Client) ProTxRegisterPrepare(collateralHash string, collateralIndex int, ...) (*btcjson.ProTxRegisterPrepareResult, error)

+ func (c *Client) ProTxRegisterPrepareAsync(collateralHash string, collateralIndex int, ...) FutureGetProTxRegisterPrepareResult

+ func (c *Client) ProTxRegisterSubmit(tx, sig string) (string, error)

+ func (c *Client) ProTxRegisterSubmitAsync(tx, sig string) FutureGetProTxStringResult

+ func (c *Client) ProTxRevoke(proTxHash, operatorPrivateKey string, reason int, feeSourceAddress string) (string, error)

+ func (c *Client) ProTxRevokeAsync(proTxHash, operatorPrivateKey string, reason int, feeSourceAddress string) FutureGetProTxStringResult

+ func (c *Client) ProTxUpdateRegistrar(...) (string, error)

+ func (c *Client) ProTxUpdateRegistrarAsync(...) FutureGetProTxStringResult

+ func (c *Client) ProTxUpdateService(...) (string, error)

+ func (c *Client) ProTxUpdateServiceAsync(...) FutureGetProTxStringResult

+ func (c *Client) QuorumDKGStatus(detailLevel btcjson.DetailLevel) (interface{}, error)

+ func (c *Client) QuorumDKGStatusAsync(detailLevel btcjson.DetailLevel) FutureGetQuorumDKGStatusResult

+ func (c *Client) QuorumDKGStatusCounts() (*btcjson.QuorumDKGStatusCountsResult, error)

+ func (c *Client) QuorumGetRecSig(quorumType btcjson.LLMQType, requestID, messageHash string) ([]btcjson.QuorumSignResult, error)

+ func (c *Client) QuorumGetRecSigAsync(quorumType btcjson.LLMQType, requestID, messageHash string) FutureGetQuorumGetRecSigResult

+ func (c *Client) QuorumHasRecSig(quorumType btcjson.LLMQType, requestID, messageHash string) (bool, error)

+ func (c *Client) QuorumHasRecSigAsync(quorumType btcjson.LLMQType, requestID, messageHash string) FutureGetQuorumGetBoolResult

+ func (c *Client) QuorumInfo(quorumType btcjson.LLMQType, quorumHash string, includeSkShare bool) (*btcjson.QuorumInfoResult, error)

+ func (c *Client) QuorumInfoAsync(quorumType btcjson.LLMQType, quorumHash string, includeSkShare bool) FutureGetQuorumInfoResult

+ func (c *Client) QuorumIsConflicting(quorumType btcjson.LLMQType, requestID, messageHash string) (bool, error)

+ func (c *Client) QuorumIsConflictingAsync(quorumType btcjson.LLMQType, requestID, messageHash string) FutureGetQuorumGetBoolResult

+ func (c *Client) QuorumList() (*btcjson.QuorumListResult, error)

+ func (c *Client) QuorumListAsync() FutureGetQuorumListResult

+ func (c *Client) QuorumMemberOf(proTxHash string, scanQuorumsCount int) ([]btcjson.QuorumMemberOfResult, error)

+ func (c *Client) QuorumMemberOfAsync(proTxHash string, scanQuorumsCount int) FutureGetQuorumMemberOfResult

+ func (c *Client) QuorumSelectQuorum(quorumType btcjson.LLMQType, requestID string) (*btcjson.QuorumSelectQuorumResult, error)

+ func (c *Client) QuorumSelectQuorumAsync(quorumType btcjson.LLMQType, requestID string) FutureGetQuorumSelectQuorumResult

+ func (c *Client) QuorumSign(quorumType btcjson.LLMQType, requestID, messageHash, quorumHash string, ...) (*btcjson.QuorumSignResultWithBool, error)

+ func (c *Client) QuorumSignAsync(quorumType btcjson.LLMQType, requestID, messageHash, quorumHash string, ...) FutureGetQuorumSignResult

+ func (c *Client) QuorumSignSubmit(quorumType btcjson.LLMQType, requestID, messageHash, quorumHash string) (bool, error)

+ func (c *Client) QuorumVerify(quorumType btcjson.LLMQType, requestID string, messageHash string, ...) (bool, error)

+ func (c *Client) QuorumVerifyAsync(quorumType btcjson.LLMQType, requestID string, messageHash string, ...) FutureGetQuorumVerifyResult

+ func (c *Client) RawRequest(method string, params []json.RawMessage) (json.RawMessage, error)

+ func (c *Client) RawRequestAsync(method string, params []json.RawMessage) FutureRawResult

+ func (c *Client) RenameAccount(oldAccount, newAccount string) error

+ func (c *Client) RenameAccountAsync(oldAccount, newAccount string) FutureRenameAccountResult

+ func (c *Client) Rescan(startBlock *chainhash.Hash, addresses []btcutil.Address, ...) error

+ func (c *Client) RescanAsync(startBlock *chainhash.Hash, addresses []btcutil.Address, ...) FutureRescanResult

+ func (c *Client) RescanBlocks(blockHashes []chainhash.Hash) ([]btcjson.RescannedBlock, error)

+ func (c *Client) RescanBlocksAsync(blockHashes []chainhash.Hash) FutureRescanBlocksResult

+ func (c *Client) RescanEndBlockAsync(startBlock *chainhash.Hash, addresses []btcutil.Address, ...) FutureRescanResult

+ func (c *Client) RescanEndHeight(startBlock *chainhash.Hash, addresses []btcutil.Address, ...) error

+ func (c *Client) SearchRawTransactions(address btcutil.Address, skip, count int, reverse bool, filterAddrs []string) ([]*wire.MsgTx, error)

+ func (c *Client) SearchRawTransactionsAsync(address btcutil.Address, skip, count int, reverse bool, filterAddrs []string) FutureSearchRawTransactionsResult

+ func (c *Client) SearchRawTransactionsVerbose(address btcutil.Address, skip, count int, includePrevOut, reverse bool, ...) ([]*btcjson.SearchRawTransactionsResult, error)

+ func (c *Client) SearchRawTransactionsVerboseAsync(address btcutil.Address, skip, count int, includePrevOut, reverse bool, ...) FutureSearchRawTransactionsVerboseResult

+ func (c *Client) Send() error

+ func (c *Client) SendCmd(cmd interface{}) chan *Response

+ func (c *Client) SendCmdAndWait(cmd interface{}) (interface{}, error)

+ func (c *Client) SendFrom(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount) (*chainhash.Hash, error)

+ func (c *Client) SendFromAsync(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount) FutureSendFromResult

+ func (c *Client) SendFromComment(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount, ...) (*chainhash.Hash, error)

+ func (c *Client) SendFromCommentAsync(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount, ...) FutureSendFromResult

+ func (c *Client) SendFromMinConf(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount, ...) (*chainhash.Hash, error)

+ func (c *Client) SendFromMinConfAsync(fromAccount string, toAddress btcutil.Address, amount btcutil.Amount, ...) FutureSendFromResult

+ func (c *Client) SendMany(fromAccount string, amounts map[btcutil.Address]btcutil.Amount) (*chainhash.Hash, error)

+ func (c *Client) SendManyAsync(fromAccount string, amounts map[btcutil.Address]btcutil.Amount) FutureSendManyResult

+ func (c *Client) SendManyComment(fromAccount string, amounts map[btcutil.Address]btcutil.Amount, ...) (*chainhash.Hash, error)

+ func (c *Client) SendManyCommentAsync(fromAccount string, amounts map[btcutil.Address]btcutil.Amount, ...) FutureSendManyResult

+ func (c *Client) SendManyMinConf(fromAccount string, amounts map[btcutil.Address]btcutil.Amount, ...) (*chainhash.Hash, error)

+ func (c *Client) SendManyMinConfAsync(fromAccount string, amounts map[btcutil.Address]btcutil.Amount, ...) FutureSendManyResult

+ func (c *Client) SendRawTransaction(tx *wire.MsgTx, allowHighFees bool) (*chainhash.Hash, error)

+ func (c *Client) SendRawTransactionAsync(tx *wire.MsgTx, allowHighFees bool) FutureSendRawTransactionResult

+ func (c *Client) SendToAddress(address btcutil.Address, amount btcutil.Amount) (*chainhash.Hash, error)

+ func (c *Client) SendToAddressAsync(address btcutil.Address, amount btcutil.Amount) FutureSendToAddressResult

+ func (c *Client) SendToAddressComment(address btcutil.Address, amount btcutil.Amount, comment, commentTo string) (*chainhash.Hash, error)

+ func (c *Client) SendToAddressCommentAsync(address btcutil.Address, amount btcutil.Amount, comment, commentTo string) FutureSendToAddressResult

+ func (c *Client) Session() (*btcjson.SessionResult, error)

+ func (c *Client) SessionAsync() FutureSessionResult

+ func (c *Client) SetAccount(address btcutil.Address, account string) error

+ func (c *Client) SetAccountAsync(address btcutil.Address, account string) FutureSetAccountResult

+ func (c *Client) SetGenerate(enable bool, numCPUs int) error

+ func (c *Client) SetGenerateAsync(enable bool, numCPUs int) FutureSetGenerateResult

+ func (c *Client) SetTxFee(fee btcutil.Amount) error

+ func (c *Client) SetTxFeeAsync(fee btcutil.Amount) FutureSetTxFeeResult

+ func (c *Client) Shutdown()

+ func (c *Client) SignMessage(address btcutil.Address, message string) (string, error)

+ func (c *Client) SignMessageAsync(address btcutil.Address, message string) FutureSignMessageResult

+ func (c *Client) SignRawTransaction(tx *wire.MsgTx) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransaction2(tx *wire.MsgTx, inputs []btcjson.RawTxInput) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransaction2Async(tx *wire.MsgTx, inputs []btcjson.RawTxInput) FutureSignRawTransactionResult

+ func (c *Client) SignRawTransaction3(tx *wire.MsgTx, inputs []btcjson.RawTxInput, privKeysWIF []string) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransaction3Async(tx *wire.MsgTx, inputs []btcjson.RawTxInput, privKeysWIF []string) FutureSignRawTransactionResult

+ func (c *Client) SignRawTransaction4(tx *wire.MsgTx, inputs []btcjson.RawTxInput, privKeysWIF []string, ...) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransaction4Async(tx *wire.MsgTx, inputs []btcjson.RawTxInput, privKeysWIF []string, ...) FutureSignRawTransactionResult

+ func (c *Client) SignRawTransactionAsync(tx *wire.MsgTx) FutureSignRawTransactionResult

+ func (c *Client) SignRawTransactionWithWallet(tx *wire.MsgTx) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransactionWithWallet2(tx *wire.MsgTx, inputs []btcjson.RawTxWitnessInput) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransactionWithWallet2Async(tx *wire.MsgTx, inputs []btcjson.RawTxWitnessInput) FutureSignRawTransactionWithWalletResult

+ func (c *Client) SignRawTransactionWithWallet3(tx *wire.MsgTx, inputs []btcjson.RawTxWitnessInput, hashType SigHashType) (*wire.MsgTx, bool, error)

+ func (c *Client) SignRawTransactionWithWallet3Async(tx *wire.MsgTx, inputs []btcjson.RawTxWitnessInput, hashType SigHashType) FutureSignRawTransactionWithWalletResult

+ func (c *Client) SignRawTransactionWithWalletAsync(tx *wire.MsgTx) FutureSignRawTransactionWithWalletResult

+ func (c *Client) SubmitBlock(block *btcutil.Block, options *btcjson.SubmitBlockOptions) error

+ func (c *Client) SubmitBlockAsync(block *btcutil.Block, options *btcjson.SubmitBlockOptions) FutureSubmitBlockResult

+ func (c *Client) UnloadWallet(walletName *string) error

+ func (c *Client) UnloadWalletAsync(walletName *string) FutureUnloadWalletResult

+ func (c *Client) ValidateAddress(address btcutil.Address) (*btcjson.ValidateAddressWalletResult, error)

+ func (c *Client) ValidateAddressAsync(address btcutil.Address) FutureValidateAddressResult

+ func (c *Client) VerifyChain() (bool, error)

+ func (c *Client) VerifyChainAsync() FutureVerifyChainResult

+ func (c *Client) VerifyChainBlocks(checkLevel, numBlocks int32) (bool, error)

+ func (c *Client) VerifyChainBlocksAsync(checkLevel, numBlocks int32) FutureVerifyChainResult

+ func (c *Client) VerifyChainLevel(checkLevel int32) (bool, error)

+ func (c *Client) VerifyChainLevelAsync(checkLevel int32) FutureVerifyChainResult

+ func (c *Client) VerifyMessage(address btcutil.Address, signature, message string) (bool, error)

+ func (c *Client) VerifyMessageAsync(address btcutil.Address, signature, message string) FutureVerifyMessageResult

+ func (c *Client) Version() (map[string]btcjson.VersionResult, error)

+ func (c *Client) VersionAsync() FutureVersionResult

+ func (c *Client) WaitForShutdown()

+ func (c *Client) WalletCreateFundedPsbt(inputs []btcjson.PsbtInput, outputs []btcjson.PsbtOutput, locktime *uint32, ...) (*btcjson.WalletCreateFundedPsbtResult, error)

+ func (c *Client) WalletCreateFundedPsbtAsync(inputs []btcjson.PsbtInput, outputs []btcjson.PsbtOutput, locktime *uint32, ...) FutureWalletCreateFundedPsbtResult

+ func (c *Client) WalletLock() error

+ func (c *Client) WalletLockAsync() FutureWalletLockResult

+ func (c *Client) WalletPassphrase(passphrase string, timeoutSecs int64) error

+ func (c *Client) WalletPassphraseChange(old, new string) error

+ func (c *Client) WalletPassphraseChangeAsync(old, new string) FutureWalletPassphraseChangeResult

+ func (c *Client) WalletProcessPsbt(psbt string, sign *bool, sighashType SigHashType, bip32Derivs *bool) (*btcjson.WalletProcessPsbtResult, error)

+ func (c *Client) WalletProcessPsbtAsync(psbt string, sign *bool, sighashType SigHashType, bip32Derivs *bool) FutureWalletProcessPsbtResult

+ type ConnConfig struct

+ Certificates []byte

+ CookiePath string

+ DisableAutoReconnect bool

+ DisableConnectOnNew bool

+ DisableTLS bool

+ EnableBCInfoHacks bool

+ Endpoint string

+ ExtraHeaders map[string]string

+ HTTPPostMode bool

+ Host string

+ Params string

+ Pass string

+ Proxy string

+ ProxyPass string

+ ProxyUser string

+ User string

+ type CreateWalletOpt func(*btcjson.CreateWalletCmd)

+ func WithCreateWalletAvoidReuse() CreateWalletOpt

+ func WithCreateWalletBlank() CreateWalletOpt

+ func WithCreateWalletDisablePrivateKeys() CreateWalletOpt

+ func WithCreateWalletPassphrase(value string) CreateWalletOpt

+ type FutureAddMultisigAddressResult struct

+ func (r FutureAddMultisigAddressResult) Receive() (btcutil.Address, error)

+ type FutureAddNodeResult chan *Response

+ func (r FutureAddNodeResult) Receive() error

+ type FutureAddWitnessAddressResult struct

+ func (r FutureAddWitnessAddressResult) Receive() (btcutil.Address, error)

+ type FutureBackupWalletResult chan *Response

+ func (r FutureBackupWalletResult) Receive() error

+ type FutureCreateEncryptedWalletResult chan *Response

+ func (r FutureCreateEncryptedWalletResult) Receive() error

+ type FutureCreateMultisigResult chan *Response

+ func (r FutureCreateMultisigResult) Receive() (*btcjson.CreateMultiSigResult, error)

+ type FutureCreateNewAccountResult chan *Response

+ func (r FutureCreateNewAccountResult) Receive() error

+ type FutureCreateRawTransactionResult chan *Response

+ func (r FutureCreateRawTransactionResult) Receive() (*wire.MsgTx, error)

+ type FutureCreateWalletResult chan *Response

+ func (r FutureCreateWalletResult) Receive() (*btcjson.CreateWalletResult, error)

+ type FutureDebugLevelResult chan *Response

+ func (r FutureDebugLevelResult) Receive() (string, error)

+ type FutureDecodeRawTransactionResult chan *Response

+ func (r FutureDecodeRawTransactionResult) Receive() (*btcjson.TxRawResult, error)

+ type FutureDecodeScriptResult chan *Response

+ func (r FutureDecodeScriptResult) Receive() (*btcjson.DecodeScriptResult, error)

+ type FutureDeriveAddressesResult chan *Response

+ func (r FutureDeriveAddressesResult) Receive() (*btcjson.DeriveAddressesResult, error)

+ type FutureDumpPrivKeyResult chan *Response

+ func (r FutureDumpPrivKeyResult) Receive() (*btcutil.WIF, error)

+ type FutureDumpWalletResult chan *Response

+ func (r FutureDumpWalletResult) Receive() (*btcjson.DumpWalletResult, error)

+ type FutureEstimateFeeResult chan *Response

+ func (r FutureEstimateFeeResult) Receive() (float64, error)

+ type FutureEstimateSmartFeeResult chan *Response

+ func (r FutureEstimateSmartFeeResult) Receive() (*btcjson.EstimateSmartFeeResult, error)

+ type FutureExportWatchingWalletResult chan *Response

+ func (r FutureExportWatchingWalletResult) Receive() ([]byte, []byte, error)

+ type FutureFundRawTransactionResult chan *Response

+ func (r FutureFundRawTransactionResult) Receive() (*btcjson.FundRawTransactionResult, error)

+ type FutureGenerateResult chan *Response

+ func (r FutureGenerateResult) Receive() ([]*chainhash.Hash, error)

+ type FutureGenerateToAddressResult chan *Response

+ func (f FutureGenerateToAddressResult) Receive() ([]*chainhash.Hash, error)

+ type FutureGetAccountAddressResult struct

+ func (r FutureGetAccountAddressResult) Receive() (btcutil.Address, error)

+ type FutureGetAccountResult chan *Response

+ func (r FutureGetAccountResult) Receive() (string, error)

+ type FutureGetAddedNodeInfoNoDNSResult chan *Response

+ func (r FutureGetAddedNodeInfoNoDNSResult) Receive() ([]string, error)

+ type FutureGetAddedNodeInfoResult chan *Response

+ func (r FutureGetAddedNodeInfoResult) Receive() ([]btcjson.GetAddedNodeInfoResult, error)

+ type FutureGetAddressInfoResult chan *Response

+ func (r FutureGetAddressInfoResult) Receive() (*btcjson.GetAddressInfoResult, error)

+ type FutureGetAddressesByAccountResult struct

+ func (r FutureGetAddressesByAccountResult) Receive() ([]btcutil.Address, error)

+ type FutureGetBLSResult struct

+ Response chan *Response

+ func (r FutureGetBLSResult) Receive() (*btcjson.BLSResult, error)

+ type FutureGetBalanceParseResult chan *Response

+ func (r FutureGetBalanceParseResult) Receive() (btcutil.Amount, error)

+ type FutureGetBalanceResult chan *Response

+ func (r FutureGetBalanceResult) Receive() (btcutil.Amount, error)

+ type FutureGetBalancesResult chan *Response

+ func (r FutureGetBalancesResult) Receive() (*btcjson.GetBalancesResult, error)

+ type FutureGetBestBlockHashResult chan *Response

+ func (r FutureGetBestBlockHashResult) Receive() (*chainhash.Hash, error)

+ type FutureGetBestBlockResult chan *Response

+ func (r FutureGetBestBlockResult) Receive() (*chainhash.Hash, int32, error)

+ type FutureGetBlockChainInfoResult struct

+ Response chan *Response

+ func (r FutureGetBlockChainInfoResult) Receive() (*btcjson.GetBlockChainInfoResult, error)

+ type FutureGetBlockCountResult chan *Response

+ func (r FutureGetBlockCountResult) Receive() (int64, error)

+ type FutureGetBlockFilterResult chan *Response

+ func (r FutureGetBlockFilterResult) Receive() (*btcjson.GetBlockFilterResult, error)

+ type FutureGetBlockHashResult chan *Response

+ func (r FutureGetBlockHashResult) Receive() (*chainhash.Hash, error)

+ type FutureGetBlockHeaderResult chan *Response

+ func (r FutureGetBlockHeaderResult) Receive() (*wire.BlockHeader, error)

+ type FutureGetBlockHeaderVerboseResult chan *Response

+ func (r FutureGetBlockHeaderVerboseResult) Receive() (*btcjson.GetBlockHeaderVerboseResult, error)

+ type FutureGetBlockResult struct

+ Response chan *Response

+ func (r FutureGetBlockResult) Receive() (*wire.MsgBlock, error)

+ type FutureGetBlockStatsResult chan *Response

+ func (r FutureGetBlockStatsResult) Receive() (*btcjson.GetBlockStatsResult, error)

+ type FutureGetBlockTemplateResponse chan *Response

+ func (r FutureGetBlockTemplateResponse) Receive() (*btcjson.GetBlockTemplateResult, error)

+ type FutureGetBlockVerboseResult struct

+ Response chan *Response

+ func (r FutureGetBlockVerboseResult) Receive() (*btcjson.GetBlockVerboseResult, error)

+ type FutureGetBlockVerboseTxResult struct

+ Response chan *Response

+ func (r FutureGetBlockVerboseTxResult) Receive() (*btcjson.GetBlockVerboseTxResult, error)

+ type FutureGetBulkResult chan *Response

+ func (r FutureGetBulkResult) Receive() (BulkResult, error)

+ type FutureGetCFilterHeaderResult chan *Response

+ func (r FutureGetCFilterHeaderResult) Receive() (*wire.MsgCFHeaders, error)

+ type FutureGetCFilterResult chan *Response

+ func (r FutureGetCFilterResult) Receive() (*wire.MsgCFilter, error)

+ type FutureGetChainTxStatsResult chan *Response

+ func (r FutureGetChainTxStatsResult) Receive() (*btcjson.GetChainTxStatsResult, error)

+ type FutureGetConnectionCountResult chan *Response

+ func (r FutureGetConnectionCountResult) Receive() (int64, error)

+ type FutureGetCurrentNetResult chan *Response

+ func (r FutureGetCurrentNetResult) Receive() (wire.BitcoinNet, error)

+ type FutureGetDescriptorInfoResult chan *Response

+ func (r FutureGetDescriptorInfoResult) Receive() (*btcjson.GetDescriptorInfoResult, error)

+ type FutureGetDifficultyResult chan *Response

+ func (r FutureGetDifficultyResult) Receive() (float64, error)

+ type FutureGetGenerateResult chan *Response

+ func (r FutureGetGenerateResult) Receive() (bool, error)

+ type FutureGetHashesPerSecResult chan *Response

+ func (r FutureGetHashesPerSecResult) Receive() (int64, error)

+ type FutureGetHeadersResult chan *Response

+ func (r FutureGetHeadersResult) Receive() ([]wire.BlockHeader, error)

+ type FutureGetInfoResult chan *Response

+ func (r FutureGetInfoResult) Receive() (*btcjson.InfoWalletResult, error)

+ type FutureGetMasternodeCountResult struct

+ Response chan *Response

+ func (r FutureGetMasternodeCountResult) Receive() (*btcjson.MasternodeCountResult, error)

+ type FutureGetMasternodeListResult struct

+ Mode string

+ Response chan *Response

+ func (r FutureGetMasternodeListResult) Receive() (interface{}, error)

+ type FutureGetMasternodeOutputsResult struct

+ Response chan *Response

+ func (r FutureGetMasternodeOutputsResult) Receive() (map[string]string, error)

+ type FutureGetMasternodeResult struct

+ Response chan *Response

+ func (r FutureGetMasternodeResult) Receive() (*btcjson.MasternodeResult, error)

+ type FutureGetMasternodeStatusResult struct

+ Response chan *Response

+ func (r FutureGetMasternodeStatusResult) Receive() (*btcjson.MasternodeStatusResult, error)

+ type FutureGetMasternodeWinnersResult struct

+ Response chan *Response

+ func (r FutureGetMasternodeWinnersResult) Receive() (map[string]string, error)

+ type FutureGetMempoolEntryResult chan *Response

+ func (r FutureGetMempoolEntryResult) Receive() (*btcjson.GetMempoolEntryResult, error)

+ type FutureGetMiningInfoResult chan *Response

+ func (r FutureGetMiningInfoResult) Receive() (*btcjson.GetMiningInfoResult, error)

+ type FutureGetNetTotalsResult chan *Response

+ func (r FutureGetNetTotalsResult) Receive() (*btcjson.GetNetTotalsResult, error)

+ type FutureGetNetworkHashPS chan *Response

+ func (r FutureGetNetworkHashPS) Receive() (float64, error)

+ type FutureGetNetworkInfoResult chan *Response

+ func (r FutureGetNetworkInfoResult) Receive() (*btcjson.GetNetworkInfoResult, error)

+ type FutureGetNewAddressResult struct

+ func (r FutureGetNewAddressResult) Receive() (btcutil.Address, error)

+ type FutureGetNodeAddressesResult chan *Response

+ func (r FutureGetNodeAddressesResult) Receive() ([]btcjson.GetNodeAddressesResult, error)

+ type FutureGetPeerInfoResult chan *Response

+ func (r FutureGetPeerInfoResult) Receive() ([]btcjson.GetPeerInfoResult, error)

+ type FutureGetProTxDiffResult struct

+ Response chan *Response

+ func (r FutureGetProTxDiffResult) Receive() (*btcjson.ProTxDiffResult, error)

+ type FutureGetProTxInfoResult struct

+ Response chan *Response

+ func (r FutureGetProTxInfoResult) Receive() (*btcjson.ProTxInfoResult, error)

+ type FutureGetProTxListResult struct

+ Response chan *Response

+ func (r FutureGetProTxListResult) Receive() (interface{}, error)

+ type FutureGetProTxRegisterPrepareResult struct

+ Response chan *Response

+ func (r FutureGetProTxRegisterPrepareResult) Receive() (*btcjson.ProTxRegisterPrepareResult, error)

+ type FutureGetProTxStringResult struct

+ Response chan *Response

+ func (r FutureGetProTxStringResult) Receive() (string, error)

+ type FutureGetQuorumDKGStatusResult struct

+ Response chan *Response

+ func (r FutureGetQuorumDKGStatusResult) Receive() (interface{}, error)

+ type FutureGetQuorumGetBoolResult struct

+ Response chan *Response

+ func (r FutureGetQuorumGetBoolResult) Receive() (bool, error)

+ type FutureGetQuorumGetRecSigResult struct

+ Response chan *Response

+ func (r FutureGetQuorumGetRecSigResult) Receive() ([]btcjson.QuorumSignResult, error)

+ type FutureGetQuorumInfoResult struct

+ Response chan *Response

+ func (r FutureGetQuorumInfoResult) Receive() (*btcjson.QuorumInfoResult, error)

+ type FutureGetQuorumListResult struct

+ Response chan *Response

+ func (r FutureGetQuorumListResult) Receive() (*btcjson.QuorumListResult, error)

+ type FutureGetQuorumMemberOfResult struct

+ Response chan *Response

+ func (r FutureGetQuorumMemberOfResult) Receive() ([]btcjson.QuorumMemberOfResult, error)

+ type FutureGetQuorumSelectQuorumResult struct

+ Response chan *Response

+ func (r FutureGetQuorumSelectQuorumResult) Receive() (*btcjson.QuorumSelectQuorumResult, error)

+ type FutureGetQuorumSignResult struct

+ Response chan *Response

+ func (r FutureGetQuorumSignResult) Receive() (*btcjson.QuorumSignResultWithBool, error)

+ type FutureGetQuorumVerifyResult struct

+ Response chan *Response

+ func (r FutureGetQuorumVerifyResult) Receive() (*btcjson.QuorumVerifyResult, error)

+ type FutureGetRawChangeAddressResult struct

+ func (r FutureGetRawChangeAddressResult) Receive() (btcutil.Address, error)

+ type FutureGetRawMempoolResult chan *Response

+ func (r FutureGetRawMempoolResult) Receive() ([]*chainhash.Hash, error)

+ type FutureGetRawMempoolVerboseResult chan *Response

+ func (r FutureGetRawMempoolVerboseResult) Receive() (map[string]btcjson.GetRawMempoolVerboseResult, error)

+ type FutureGetRawTransactionResult chan *Response

+ func (r FutureGetRawTransactionResult) Receive() (*btcutil.Tx, error)

+ type FutureGetRawTransactionVerboseResult chan *Response

+ func (r FutureGetRawTransactionVerboseResult) Receive() (*btcjson.TxRawResult, error)

+ type FutureGetReceivedByAccountResult chan *Response

+ func (r FutureGetReceivedByAccountResult) Receive() (btcutil.Amount, error)

+ type FutureGetReceivedByAddressResult chan *Response

+ func (r FutureGetReceivedByAddressResult) Receive() (btcutil.Amount, error)

+ type FutureGetTransactionResult chan *Response

+ func (r FutureGetTransactionResult) Receive() (*btcjson.GetTransactionResult, error)

+ type FutureGetTxOutResult chan *Response

+ func (r FutureGetTxOutResult) Receive() (*btcjson.GetTxOutResult, error)

+ type FutureGetTxOutSetInfoResult chan *Response

+ func (r FutureGetTxOutSetInfoResult) Receive() (*btcjson.GetTxOutSetInfoResult, error)

+ type FutureGetUnconfirmedBalanceResult chan *Response

+ func (r FutureGetUnconfirmedBalanceResult) Receive() (btcutil.Amount, error)

+ type FutureGetWalletInfoResult chan *Response

+ func (r FutureGetWalletInfoResult) Receive() (*btcjson.GetWalletInfoResult, error)

+ type FutureGetWork chan *Response

+ func (r FutureGetWork) Receive() (*btcjson.GetWorkResult, error)

+ type FutureGetWorkSubmit chan *Response

+ func (r FutureGetWorkSubmit) Receive() (bool, error)

+ type FutureImportAddressResult chan *Response

+ func (r FutureImportAddressResult) Receive() error

+ type FutureImportMultiResult chan *Response

+ func (r FutureImportMultiResult) Receive() (btcjson.ImportMultiResults, error)

+ type FutureImportPrivKeyResult chan *Response

+ func (r FutureImportPrivKeyResult) Receive() error

+ type FutureImportPubKeyResult chan *Response

+ func (r FutureImportPubKeyResult) Receive() error

+ type FutureImportWalletResult chan *Response

+ func (r FutureImportWalletResult) Receive() error

+ type FutureInvalidateBlockResult chan *Response

+ func (r FutureInvalidateBlockResult) Receive() error

+ type FutureKeyPoolRefillResult chan *Response

+ func (r FutureKeyPoolRefillResult) Receive() error

+ type FutureListAccountsResult chan *Response

+ func (r FutureListAccountsResult) Receive() (map[string]btcutil.Amount, error)

+ type FutureListAddressTransactionsResult chan *Response

+ func (r FutureListAddressTransactionsResult) Receive() ([]btcjson.ListTransactionsResult, error)

+ type FutureListLockUnspentResult chan *Response

+ func (r FutureListLockUnspentResult) Receive() ([]*wire.OutPoint, error)

+ type FutureListReceivedByAccountResult chan *Response

+ func (r FutureListReceivedByAccountResult) Receive() ([]btcjson.ListReceivedByAccountResult, error)

+ type FutureListReceivedByAddressResult chan *Response

+ func (r FutureListReceivedByAddressResult) Receive() ([]btcjson.ListReceivedByAddressResult, error)

+ type FutureListSinceBlockResult chan *Response

+ func (r FutureListSinceBlockResult) Receive() (*btcjson.ListSinceBlockResult, error)

+ type FutureListTransactionsResult chan *Response

+ func (r FutureListTransactionsResult) Receive() ([]btcjson.ListTransactionsResult, error)

+ type FutureListUnspentResult chan *Response

+ func (r FutureListUnspentResult) Receive() ([]btcjson.ListUnspentResult, error)

+ type FutureLoadTxFilterResult chan *Response

+ func (r FutureLoadTxFilterResult) Receive() error

+ type FutureLoadWalletResult chan *Response

+ func (r FutureLoadWalletResult) Receive() (*btcjson.LoadWalletResult, error)

+ type FutureLockUnspentResult chan *Response

+ func (r FutureLockUnspentResult) Receive() error

+ type FutureMoveResult chan *Response

+ func (r FutureMoveResult) Receive() (bool, error)

+ type FutureNodeResult chan *Response

+ func (r FutureNodeResult) Receive() error

+ type FutureNotifyBlocksResult chan *Response

+ func (r FutureNotifyBlocksResult) Receive() error

+ type FutureNotifyNewTransactionsResult chan *Response

+ func (r FutureNotifyNewTransactionsResult) Receive() error

+ type FutureNotifyReceivedResult chan *Response

+ func (r FutureNotifyReceivedResult) Receive() error

+ type FutureNotifySpentResult chan *Response

+ func (r FutureNotifySpentResult) Receive() error

+ type FuturePingResult chan *Response

+ func (r FuturePingResult) Receive() error

+ type FutureRawResult chan *Response

+ func (r FutureRawResult) Receive() (json.RawMessage, error)

+ type FutureRenameAccountResult chan *Response

+ func (r FutureRenameAccountResult) Receive() error

+ type FutureRescanBlocksResult chan *Response

+ func (r FutureRescanBlocksResult) Receive() ([]btcjson.RescannedBlock, error)

+ type FutureRescanResult chan *Response

+ func (r FutureRescanResult) Receive() error

+ type FutureSearchRawTransactionsResult chan *Response

+ func (r FutureSearchRawTransactionsResult) Receive() ([]*wire.MsgTx, error)

+ type FutureSearchRawTransactionsVerboseResult chan *Response

+ func (r FutureSearchRawTransactionsVerboseResult) Receive() ([]*btcjson.SearchRawTransactionsResult, error)

+ type FutureSendFromResult chan *Response

+ func (r FutureSendFromResult) Receive() (*chainhash.Hash, error)

+ type FutureSendManyResult chan *Response

+ func (r FutureSendManyResult) Receive() (*chainhash.Hash, error)

+ type FutureSendRawTransactionResult chan *Response

+ func (r FutureSendRawTransactionResult) Receive() (*chainhash.Hash, error)

+ type FutureSendToAddressResult chan *Response

+ func (r FutureSendToAddressResult) Receive() (*chainhash.Hash, error)

+ type FutureSessionResult chan *Response

+ func (r FutureSessionResult) Receive() (*btcjson.SessionResult, error)

+ type FutureSetAccountResult chan *Response

+ func (r FutureSetAccountResult) Receive() error

+ type FutureSetGenerateResult chan *Response

+ func (r FutureSetGenerateResult) Receive() error

+ type FutureSetTxFeeResult chan *Response

+ func (r FutureSetTxFeeResult) Receive() error

+ type FutureSignMessageResult chan *Response

+ func (r FutureSignMessageResult) Receive() (string, error)

+ type FutureSignRawTransactionResult chan *Response

+ func (r FutureSignRawTransactionResult) Receive() (*wire.MsgTx, bool, error)

+ type FutureSignRawTransactionWithWalletResult chan *Response

+ func (r FutureSignRawTransactionWithWalletResult) Receive() (*wire.MsgTx, bool, error)

+ type FutureSubmitBlockResult chan *Response

+ func (r FutureSubmitBlockResult) Receive() error

+ type FutureUnloadWalletResult chan *Response

+ func (r FutureUnloadWalletResult) Receive() error

+ type FutureValidateAddressResult chan *Response

+ func (r FutureValidateAddressResult) Receive() (*btcjson.ValidateAddressWalletResult, error)

+ type FutureVerifyChainResult chan *Response

+ func (r FutureVerifyChainResult) Receive() (bool, error)

+ type FutureVerifyMessageResult chan *Response

+ func (r FutureVerifyMessageResult) Receive() (bool, error)

+ type FutureVersionResult chan *Response

+ func (r FutureVersionResult) Receive() (map[string]btcjson.VersionResult, error)

+ type FutureWalletCreateFundedPsbtResult chan *Response

+ func (r FutureWalletCreateFundedPsbtResult) Receive() (*btcjson.WalletCreateFundedPsbtResult, error)

+ type FutureWalletLockResult chan *Response

+ func (r FutureWalletLockResult) Receive() error

+ type FutureWalletPassphraseChangeResult chan *Response

+ func (r FutureWalletPassphraseChangeResult) Receive() error

+ type FutureWalletProcessPsbtResult chan *Response

+ func (r FutureWalletProcessPsbtResult) Receive() (*btcjson.WalletProcessPsbtResult, error)

+ type IndividualBulkResult struct

+ Error *btcjson.RPCError

+ Id uint64

+ Result interface{}

+ type NotificationHandlers struct

+ OnAccountBalance func(account string, balance btcutil.Amount, confirmed bool)

+ OnBlockConnected func(hash *chainhash.Hash, height int32, t time.Time)

+ OnBlockDisconnected func(hash *chainhash.Hash, height int32, t time.Time)

+ OnBtcdConnected func(connected bool)

+ OnClientConnected func()

+ OnFilteredBlockConnected func(height int32, header *wire.BlockHeader, txs []*btcutil.Tx)

+ OnFilteredBlockDisconnected func(height int32, header *wire.BlockHeader)

+ OnRecvTx func(transaction *btcutil.Tx, details *btcjson.BlockDetails)

+ OnRedeemingTx func(transaction *btcutil.Tx, details *btcjson.BlockDetails)

+ OnRelevantTxAccepted func(transaction []byte)

+ OnRescanFinished func(hash *chainhash.Hash, height int32, blkTime time.Time)

+ OnRescanProgress func(hash *chainhash.Hash, height int32, blkTime time.Time)

+ OnTxAccepted func(hash *chainhash.Hash, amount btcutil.Amount)

+ OnTxAcceptedVerbose func(txDetails *btcjson.TxRawResult)

+ OnUnknownNotification func(method string, params []json.RawMessage)

+ OnWalletLockState func(locked bool)

+ type Response struct

+ type SigHashType string

+ const SigHashAll

+ const SigHashAllAnyoneCanPay

+ const SigHashNone

+ const SigHashNoneAnyoneCanPay

+ const SigHashSingle

+ const SigHashSingleAnyoneCanPay

+ func (s SigHashType) String() string