bchwallet: github.com/gcash/bchwallet/chain Index | Files

package chain

import "github.com/gcash/bchwallet/chain"

Index

Package Files

bitcoind_client.go bitcoind_conn.go block_filterer.go interface.go log.go neutrino.go queue.go rpc.go

Variables

var (
    // ErrBitcoindClientShuttingDown is an error returned when we attempt
    // to receive a notification for a specific item and the bitcoind client
    // is in the middle of shutting down.
    ErrBitcoindClientShuttingDown = errors.New("client is shutting down")
)
var ErrFilterReqInterrupt = errors.New("filter blocks interrupt")

ErrFilterReqInterrupt represents an error that is returned when the FilterBlocks method is interrupted.

func BackEnds Uses

func BackEnds() []string

BackEnds returns a list of the available back ends. TODO: Refactor each into a driver and use dynamic registration.

func DisableLog Uses

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until either UseLogger or SetLogWriter are called.

func UseLogger Uses

func UseLogger(logger bchlog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using bchlog.

type BitcoindClient Uses

type BitcoindClient struct {
    // contains filtered or unexported fields
}

BitcoindClient represents a persistent client connection to a bitcoind server for information regarding the current best block chain.

func (*BitcoindClient) BackEnd Uses

func (c *BitcoindClient) BackEnd() string

BackEnd returns the name of the driver.

func (*BitcoindClient) BlockStamp Uses

func (c *BitcoindClient) BlockStamp() (*waddrmgr.BlockStamp, error)

BlockStamp returns the latest block notified by the client, or an error if the client has been shut down.

func (*BitcoindClient) FilterBlocks Uses

func (c *BitcoindClient) FilterBlocks(
    req *FilterBlocksRequest) (*FilterBlocksResponse, error)

FilterBlocks scans the blocks contained in the FilterBlocksRequest for any addresses of interest. Each block will be fetched and filtered sequentially, returning a FilterBlocksReponse for the first block containing a matching address. If no matches are found in the range of blocks requested, the returned response will be nil.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) GetBestBlock Uses

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

GetBestBlock returns the highest block known to bitcoind.

func (*BitcoindClient) GetBlock Uses

func (c *BitcoindClient) GetBlock(hash *chainhash.Hash) (*wire.MsgBlock, error)

GetBlock returns a block from the hash.

func (*BitcoindClient) GetBlockHash Uses

func (c *BitcoindClient) GetBlockHash(height int64) (*chainhash.Hash, error)

GetBlockHash returns a block hash from the height.

func (*BitcoindClient) GetBlockHeader Uses

func (c *BitcoindClient) GetBlockHeader(
    hash *chainhash.Hash) (*wire.BlockHeader, error)

GetBlockHeader returns a block header from the hash.

func (*BitcoindClient) GetBlockHeaderVerbose Uses

func (c *BitcoindClient) GetBlockHeaderVerbose(
    hash *chainhash.Hash) (*btcjson.GetBlockHeaderVerboseResult, error)

GetBlockHeaderVerbose returns a block header from the hash.

func (*BitcoindClient) GetBlockHeight Uses

func (c *BitcoindClient) GetBlockHeight(hash *chainhash.Hash) (int32, error)

GetBlockHeight returns the height for the hash, if known, or returns an error.

func (*BitcoindClient) GetBlockVerbose Uses

func (c *BitcoindClient) GetBlockVerbose(
    hash *chainhash.Hash) (*btcjson.GetBlockVerboseResult, error)

GetBlockVerbose returns a verbose block from the hash.

func (*BitcoindClient) GetRawTransactionVerbose Uses

func (c *BitcoindClient) GetRawTransactionVerbose(
    hash *chainhash.Hash) (*btcjson.TxRawResult, error)

GetRawTransactionVerbose returns a transaction from the tx hash.

func (*BitcoindClient) GetTxOut Uses

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

GetTxOut returns a txout from the outpoint info provided.

func (*BitcoindClient) IsCurrent Uses

func (c *BitcoindClient) IsCurrent() bool

IsCurrent returns whether the chain backend considers its view of the network as "current".

func (*BitcoindClient) LoadTxFilter Uses

func (c *BitcoindClient) LoadTxFilter(reset bool, filters ...interface{}) error

LoadTxFilter uses the given filters to what we should match transactions against to determine if they are relevant to the client. The reset argument is used to reset the current filters.

The current filters supported are of the following types:

[]bchutil.Address
[]wire.OutPoint
[]*wire.OutPoint
map[wire.OutPoint]bchutil.Address
[]chainhash.Hash
[]*chainhash.Hash

func (*BitcoindClient) Notifications Uses

func (c *BitcoindClient) Notifications() <-chan interface{}

Notifications returns a channel to retrieve notifications from.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) NotifyBlocks Uses

func (c *BitcoindClient) NotifyBlocks() error

NotifyBlocks allows the chain backend to notify the caller whenever a block is connected or disconnected.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) NotifyReceived Uses

func (c *BitcoindClient) NotifyReceived(addrs []bchutil.Address) error

NotifyReceived allows the chain backend to notify the caller whenever a transaction pays to any of the given addresses.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) NotifySpent Uses

func (c *BitcoindClient) NotifySpent(outPoints []*wire.OutPoint) error

NotifySpent allows the chain backend to notify the caller whenever a transaction spends any of the given outpoints.

func (*BitcoindClient) NotifyTx Uses

func (c *BitcoindClient) NotifyTx(txids []chainhash.Hash) error

NotifyTx allows the chain backend to notify the caller whenever any of the given transactions confirm within the chain.

func (*BitcoindClient) Rescan Uses

func (c *BitcoindClient) Rescan(blockHash *chainhash.Hash,
    addresses []bchutil.Address, outPoints map[wire.OutPoint]bchutil.Address) error

Rescan rescans from the block with the given hash until the current block, after adding the passed addresses and outpoints to the client's watch list.

func (*BitcoindClient) RescanBlocks Uses

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

RescanBlocks rescans any blocks passed, returning only the blocks that matched as []btcjson.BlockDetails.

func (*BitcoindClient) SendRawTransaction Uses

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

SendRawTransaction sends a raw transaction via bitcoind.

func (*BitcoindClient) SetBirthday Uses

func (c *BitcoindClient) SetBirthday(t time.Time)

SetBirthday sets the birthday of the bitcoind rescan client.

NOTE: This should be done before the client has been started in order for it to properly carry its duties.

func (*BitcoindClient) Start Uses

func (c *BitcoindClient) Start() error

Start initializes the bitcoind rescan client using the backing bitcoind connection and starts all goroutines necessary in order to process rescans and ZMQ notifications.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) Stop Uses

func (c *BitcoindClient) Stop()

Stop stops the bitcoind rescan client from processing rescans and ZMQ notifications.

NOTE: This is part of the chain.Interface interface.

func (*BitcoindClient) WaitForShutdown Uses

func (c *BitcoindClient) WaitForShutdown()

WaitForShutdown blocks until the client has finished disconnecting and all handlers have exited.

NOTE: This is part of the chain.Interface interface.

type BitcoindConn Uses

type BitcoindConn struct {
    // contains filtered or unexported fields
}

BitcoindConn represents a persistent client connection to a bitcoind node that listens for events read from a ZMQ connection.

func NewBitcoindConn Uses

func NewBitcoindConn(chainParams *chaincfg.Params,
    host, user, pass, zmqBlockHost, zmqTxHost string,
    zmqPollInterval time.Duration) (*BitcoindConn, error)

NewBitcoindConn creates a client connection to the node described by the host string. The ZMQ connections are established immediately to ensure liveness. If the remote node does not operate on the same bitcoin network as described by the passed chain parameters, the connection will be disconnected.

func (*BitcoindConn) AddClient Uses

func (c *BitcoindConn) AddClient(client *BitcoindClient)

AddClient adds a client to the set of active rescan clients of the current chain connection. This allows the connection to include the specified client in its notification delivery.

NOTE: This function is safe for concurrent access.

func (*BitcoindConn) NewBitcoindClient Uses

func (c *BitcoindConn) NewBitcoindClient() *BitcoindClient

NewBitcoindClient returns a bitcoind client using the current bitcoind connection. This allows us to share the same connection using multiple clients.

func (*BitcoindConn) RemoveClient Uses

func (c *BitcoindConn) RemoveClient(id uint64)

RemoveClient removes the client with the given ID from the set of active rescan clients. Once removed, the client will no longer receive block and transaction notifications from the chain connection.

NOTE: This function is safe for concurrent access.

func (*BitcoindConn) Start Uses

func (c *BitcoindConn) Start() error

Start attempts to establish a RPC and ZMQ connection to a bitcoind node. If successful, a goroutine is spawned to read events from the ZMQ connection. It's possible for this function to fail due to a limited number of connection attempts. This is done to prevent waiting forever on the connection to be established in the case that the node is down.

func (*BitcoindConn) Stop Uses

func (c *BitcoindConn) Stop()

Stop terminates the RPC and ZMQ connection to a bitcoind node and removes any active rescan clients.

type BlockConnected Uses

type BlockConnected wtxmgr.BlockMeta

BlockConnected is a notification for a newly-attached block to the best chain.

type BlockDisconnected Uses

type BlockDisconnected wtxmgr.BlockMeta

BlockDisconnected is a notifcation that the block described by the BlockStamp was reorganized out of the best chain.

type BlockFilterer Uses

type BlockFilterer struct {
    // Params specifies the chain params of the current network.
    Params *chaincfg.Params

    // ExReverseFilter holds a reverse index mapping an external address to
    // the scoped index from which it was derived.
    ExReverseFilter map[string]waddrmgr.ScopedIndex

    // InReverseFilter holds a reverse index mapping an internal address to
    // the scoped index from which it was derived.
    InReverseFilter map[string]waddrmgr.ScopedIndex

    // WathcedOutPoints is a global set of outpoints being tracked by the
    // wallet. This allows the block filterer to check for spends from an
    // outpoint we own.
    WatchedOutPoints map[wire.OutPoint]bchutil.Address

    // FoundExternal is a two-layer map recording the scope and index of
    // external addresses found in a single block.
    FoundExternal map[waddrmgr.KeyScope]map[uint32]struct{}

    // FoundInternal is a two-layer map recording the scope and index of
    // internal addresses found in a single block.
    FoundInternal map[waddrmgr.KeyScope]map[uint32]struct{}

    // FoundOutPoints is a set of outpoints found in a single block whose
    // address belongs to the wallet.
    FoundOutPoints map[wire.OutPoint]bchutil.Address

    // RelevantTxns records the transactions found in a particular block
    // that contained matches from an address in either ExReverseFilter or
    // InReverseFilter.
    RelevantTxns []*wire.MsgTx
}

BlockFilterer is used to iteratively scan blocks for a set of addresses of interest. This is done by constructing reverse indexes mapping the addresses to a ScopedIndex, which permits the reconstruction of the exact child deriviation paths that reported matches.

Once initialized, a BlockFilterer can be used to scan any number of blocks until a invocation of `FilterBlock` returns true. This allows the reverse indexes to be resused in the event that the set of addresses does not need to be altered. After a match is reported, a new BlockFilterer should be initialized with the updated set of addresses that include any new keys that are now within our look-ahead.

We track internal and external addresses separately in order to conserve the amount of space occupied in memory. Specifically, the account and branch combined contribute only 1-bit of information when using the default scopes used by the wallet. Thus we can avoid storing an additional 64-bits per address of interest by not storing the full derivation paths, and instead opting to allow the caller to contextually infer the account (DefaultAccount) and branch (Internal or External).

func NewBlockFilterer Uses

func NewBlockFilterer(params *chaincfg.Params,
    req *FilterBlocksRequest) *BlockFilterer

NewBlockFilterer constructs the reverse indexes for the current set of external and internal addresses that we are searching for, and is used to scan successive blocks for addresses of interest. A particular block filter can be reused until the first call from `FitlerBlock` returns true.

func (*BlockFilterer) FilterBlock Uses

func (bf *BlockFilterer) FilterBlock(block *wire.MsgBlock) bool

FilterBlock parses all txns in the provided block, searching for any that contain addresses of interest in either the external or internal reverse filters. This method return true iff the block contains a non-zero number of addresses of interest, or a transaction in the block spends from outpoints controlled by the wallet.

func (*BlockFilterer) FilterOutputAddrs Uses

func (bf *BlockFilterer) FilterOutputAddrs(addrs []bchutil.Address) bool

FilterOutputAddrs tests the set of addresses against the block filterer's external and internal reverse address indexes. If any are found, they are added to set of external and internal found addresses, respectively. This method returns true iff a non-zero number of the provided addresses are of interest.

func (*BlockFilterer) FilterTx Uses

func (bf *BlockFilterer) FilterTx(tx *wire.MsgTx) bool

FilterTx scans all txouts in the provided txn, testing to see if any found addresses match those contained within the external or internal reverse indexes. This method returns true iff the txn contains a non-zero number of addresses of interest, or the transaction spends from an outpoint that belongs to the wallet.

type ClientConnected Uses

type ClientConnected struct{}

ClientConnected is a notification for when a client connection is opened or reestablished to the chain server.

type ConcurrentQueue Uses

type ConcurrentQueue struct {
    // contains filtered or unexported fields
}

ConcurrentQueue is a concurrent-safe FIFO queue with unbounded capacity. Clients interact with the queue by pushing items into the in channel and popping items from the out channel. There is a goroutine that manages moving items from the in channel to the out channel in the correct order that must be started by calling Start().

func NewConcurrentQueue Uses

func NewConcurrentQueue(bufferSize int) *ConcurrentQueue

NewConcurrentQueue constructs a ConcurrentQueue. The bufferSize parameter is the capacity of the output channel. When the size of the queue is below this threshold, pushes do not incur the overhead of the less efficient overflow structure.

func (*ConcurrentQueue) ChanIn Uses

func (cq *ConcurrentQueue) ChanIn() chan<- interface{}

ChanIn returns a channel that can be used to push new items into the queue.

func (*ConcurrentQueue) ChanOut Uses

func (cq *ConcurrentQueue) ChanOut() <-chan interface{}

ChanOut returns a channel that can be used to pop items from the queue.

func (*ConcurrentQueue) Start Uses

func (cq *ConcurrentQueue) Start()

Start begins a goroutine that manages moving items from the in channel to the out channel. The queue tries to move items directly to the out channel minimize overhead, but if the out channel is full it pushes items to an overflow queue. This must be called before using the queue.

func (*ConcurrentQueue) Stop Uses

func (cq *ConcurrentQueue) Stop()

Stop ends the goroutine that moves items from the in channel to the out channel.

type FilterBlocksRequest Uses

type FilterBlocksRequest struct {
    Blocks           []wtxmgr.BlockMeta
    ExternalAddrs    map[waddrmgr.ScopedIndex]bchutil.Address
    InternalAddrs    map[waddrmgr.ScopedIndex]bchutil.Address
    WatchedOutPoints map[wire.OutPoint]bchutil.Address
    Interrupt        chan struct{}
}

FilterBlocksRequest specifies a range of blocks and the set of internal and external addresses of interest, indexed by corresponding scoped-index of the child address. A global set of watched outpoints is also included to monitor for spends.

type FilterBlocksResponse Uses

type FilterBlocksResponse struct {
    BatchIndex         uint32
    BlockMeta          wtxmgr.BlockMeta
    FoundExternalAddrs map[waddrmgr.KeyScope]map[uint32]struct{}
    FoundInternalAddrs map[waddrmgr.KeyScope]map[uint32]struct{}
    FoundOutPoints     map[wire.OutPoint]bchutil.Address
    RelevantTxns       []*wire.MsgTx
}

FilterBlocksResponse reports the set of all internal and external addresses found in response to a FilterBlockRequest, any outpoints found that correspond to those addresses, as well as the relevant transactions that can modify the wallet's balance. The index of the block within the FilterBlocksRequest is returned, such that the caller can reinitiate a request for the subsequent block after updating the addresses of interest.

type FilteredBlockConnected Uses

type FilteredBlockConnected struct {
    Block       *wtxmgr.BlockMeta
    RelevantTxs []*wtxmgr.TxRecord
}

FilteredBlockConnected is an alternate notification that contains both block and relevant transaction information in one struct, which allows atomic updates.

type Interface Uses

type Interface interface {
    Start() error
    Stop()
    WaitForShutdown()
    GetBestBlock() (*chainhash.Hash, int32, error)
    GetBlock(*chainhash.Hash) (*wire.MsgBlock, error)
    GetBlockHash(int64) (*chainhash.Hash, error)
    GetBlockHeader(*chainhash.Hash) (*wire.BlockHeader, error)
    IsCurrent() bool
    FilterBlocks(*FilterBlocksRequest) (*FilterBlocksResponse, error)
    BlockStamp() (*waddrmgr.BlockStamp, error)
    SendRawTransaction(*wire.MsgTx, bool) (*chainhash.Hash, error)
    Rescan(*chainhash.Hash, []bchutil.Address, map[wire.OutPoint]bchutil.Address) error
    NotifyReceived([]bchutil.Address) error
    NotifyBlocks() error
    Notifications() <-chan interface{}
    BackEnd() string
}

Interface allows more than one backing blockchain source, such as a bchd RPC chain server, or an SPV library, as long as we write a driver for it.

type NeutrinoClient Uses

type NeutrinoClient struct {
    CS *neutrino.ChainService
    // contains filtered or unexported fields
}

NeutrinoClient is an implementation of the bchwalet chain.Interface interface.

func NewNeutrinoClient Uses

func NewNeutrinoClient(chainParams *chaincfg.Params,
    chainService *neutrino.ChainService) *NeutrinoClient

NewNeutrinoClient creates a new NeutrinoClient struct with a backing ChainService.

func (*NeutrinoClient) BackEnd Uses

func (s *NeutrinoClient) BackEnd() string

BackEnd returns the name of the driver.

func (*NeutrinoClient) BlockStamp Uses

func (s *NeutrinoClient) BlockStamp() (*waddrmgr.BlockStamp, error)

BlockStamp returns the latest block notified by the client, or an error if the client has been shut down.

func (*NeutrinoClient) FilterBlocks Uses

func (s *NeutrinoClient) FilterBlocks(
    req *FilterBlocksRequest) (*FilterBlocksResponse, error)

FilterBlocks scans the blocks contained in the FilterBlocksRequest for any addresses of interest. For each requested block, the corresponding compact filter will first be checked for matches, skipping those that do not report anything. If the filter returns a postive match, the full block will be fetched and filtered. This method returns a FilterBlocksReponse for the first block containing a matching address. If no matches are found in the range of blocks requested, the returned response will be nil.

func (*NeutrinoClient) GetBestBlock Uses

func (s *NeutrinoClient) GetBestBlock() (*chainhash.Hash, int32, error)

GetBestBlock replicates the RPC client's GetBestBlock command.

func (*NeutrinoClient) GetBlock Uses

func (s *NeutrinoClient) GetBlock(hash *chainhash.Hash) (*wire.MsgBlock, error)

GetBlock replicates the RPC client's GetBlock command.

func (*NeutrinoClient) GetBlockHash Uses

func (s *NeutrinoClient) GetBlockHash(height int64) (*chainhash.Hash, error)

GetBlockHash returns the block hash for the given height, or an error if the client has been shut down or the hash at the block height doesn't exist or is unknown.

func (*NeutrinoClient) GetBlockHeader Uses

func (s *NeutrinoClient) GetBlockHeader(
    blockHash *chainhash.Hash) (*wire.BlockHeader, error)

GetBlockHeader returns the block header for the given block hash, or an error if the client has been shut down or the hash doesn't exist or is unknown.

func (*NeutrinoClient) GetBlockHeight Uses

func (s *NeutrinoClient) GetBlockHeight(hash *chainhash.Hash) (int32, error)

GetBlockHeight gets the height of a block by its hash. It serves as a replacement for the use of GetBlockVerboseTxAsync for the wallet package since we can't actually return a FutureGetBlockVerboseResult because the underlying type is private to rpcclient.

func (*NeutrinoClient) IsCurrent Uses

func (s *NeutrinoClient) IsCurrent() bool

IsCurrent returns whether the chain backend considers its view of the network as "current".

func (*NeutrinoClient) Notifications Uses

func (s *NeutrinoClient) Notifications() <-chan interface{}

Notifications replicates the RPC client's Notifications method.

func (*NeutrinoClient) NotifyBlocks Uses

func (s *NeutrinoClient) NotifyBlocks() error

NotifyBlocks replicates the RPC client's NotifyBlocks command.

func (*NeutrinoClient) NotifyReceived Uses

func (s *NeutrinoClient) NotifyReceived(addrs []bchutil.Address) error

NotifyReceived replicates the RPC client's NotifyReceived command.

func (*NeutrinoClient) Rescan Uses

func (s *NeutrinoClient) Rescan(startHash *chainhash.Hash, addrs []bchutil.Address,
    outPoints map[wire.OutPoint]bchutil.Address) error

Rescan replicates the RPC client's Rescan command.

func (*NeutrinoClient) SendRawTransaction Uses

func (s *NeutrinoClient) SendRawTransaction(tx *wire.MsgTx, allowHighFees bool) (
    *chainhash.Hash, error)

SendRawTransaction replicates the RPC client's SendRawTransaction command.

func (*NeutrinoClient) SetStartTime Uses

func (s *NeutrinoClient) SetStartTime(startTime time.Time)

SetStartTime is a non-interface method to set the birthday of the wallet using this object. Since only a single rescan at a time is currently supported, only one birthday needs to be set. This does not fully restart a running rescan, so should not be used to update a rescan while it is running. TODO: When factoring out to multiple rescans per Neutrino client, add a birthday per client.

func (*NeutrinoClient) Start Uses

func (s *NeutrinoClient) Start() error

Start replicates the RPC client's Start method.

func (*NeutrinoClient) Stop Uses

func (s *NeutrinoClient) Stop()

Stop replicates the RPC client's Stop method.

func (*NeutrinoClient) WaitForShutdown Uses

func (s *NeutrinoClient) WaitForShutdown()

WaitForShutdown replicates the RPC client's WaitForShutdown method.

type RPCClient Uses

type RPCClient struct {
    *rpcclient.Client
    // contains filtered or unexported fields
}

RPCClient represents a persistent client connection to a bitcoin RPC server for information regarding the current best block chain.

func NewRPCClient Uses

func NewRPCClient(chainParams *chaincfg.Params, connect, user, pass string, certs []byte,
    disableTLS bool, reconnectAttempts int) (*RPCClient, error)

NewRPCClient creates a client connection to the server described by the connect string. If disableTLS is false, the remote RPC certificate must be provided in the certs slice. The connection is not established immediately, but must be done using the Start method. If the remote server does not operate on the same bitcoin network as described by the passed chain parameters, the connection will be disconnected.

func (*RPCClient) BackEnd Uses

func (c *RPCClient) BackEnd() string

BackEnd returns the name of the driver.

func (*RPCClient) BlockStamp Uses

func (c *RPCClient) BlockStamp() (*waddrmgr.BlockStamp, error)

BlockStamp returns the latest block notified by the client, or an error if the client has been shut down.

func (*RPCClient) FilterBlocks Uses

func (c *RPCClient) FilterBlocks(
    req *FilterBlocksRequest) (*FilterBlocksResponse, error)

FilterBlocks scans the blocks contained in the FilterBlocksRequest for any addresses of interest. For each requested block, the corresponding compact filter will first be checked for matches, skipping those that do not report anything. If the filter returns a postive match, the full block will be fetched and filtered. This method returns a FilterBlocksReponse for the first block containing a matching address. If no matches are found in the range of blocks requested, the returned response will be nil.

func (*RPCClient) IsCurrent Uses

func (c *RPCClient) IsCurrent() bool

IsCurrent returns whether the chain backend considers its view of the network as "current".

func (*RPCClient) Notifications Uses

func (c *RPCClient) Notifications() <-chan interface{}

Notifications returns a channel of parsed notifications sent by the remote bitcoin RPC server. This channel must be continually read or the process may abort for running out memory, as unread notifications are queued for later reads.

func (*RPCClient) POSTClient Uses

func (c *RPCClient) POSTClient() (*rpcclient.Client, error)

POSTClient creates the equivalent HTTP POST rpcclient.Client.

func (*RPCClient) Rescan Uses

func (c *RPCClient) Rescan(startHash *chainhash.Hash, addrs []bchutil.Address,
    outPoints map[wire.OutPoint]bchutil.Address) error

Rescan wraps the normal Rescan command with an additional paramter that allows us to map an oupoint to the address in the chain that it pays to. This is useful when using BIP 158 filters as they include the prev pkScript rather than the full outpoint.

func (*RPCClient) Start Uses

func (c *RPCClient) Start() error

Start attempts to establish a client connection with the remote server. If successful, handler goroutines are started to process notifications sent by the server. After a limited number of connection attempts, this function gives up, and therefore will not block forever waiting for the connection to be established to a server that may not exist.

func (*RPCClient) Stop Uses

func (c *RPCClient) Stop()

Stop disconnects the client and signals the shutdown of all goroutines started by Start.

func (*RPCClient) WaitForShutdown Uses

func (c *RPCClient) WaitForShutdown()

WaitForShutdown blocks until both the client has finished disconnecting and all handlers have exited.

type RecoveryProgress Uses

type RecoveryProgress struct {
    Hash   *chainhash.Hash
    Height int32
    Time   time.Time
}

RecoveryProgress is a notification describing the current status of an in-progress recovery.

type RelevantTx Uses

type RelevantTx struct {
    TxRecord *wtxmgr.TxRecord
    Block    *wtxmgr.BlockMeta // nil if unmined
}

RelevantTx is a notification for a transaction which spends wallet inputs or pays to a watched address.

type RescanFinished Uses

type RescanFinished struct {
    Hash   *chainhash.Hash
    Height int32
    Time   time.Time
}

RescanFinished is a notification that a previous rescan request has finished.

type RescanProgress Uses

type RescanProgress struct {
    Hash   *chainhash.Hash
    Height int32
    Time   time.Time
}

RescanProgress is a notification describing the current status of an in-progress rescan.

Package chain imports 24 packages (graph) and is imported by 4 packages. Updated 2019-09-12. Refresh now. Tools for package owners.