chain

type BlockConnected ¶

type BlockConnected wtxmgr.BlockMeta

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

type BlockDisconnected ¶

type BlockDisconnected wtxmgr.BlockMeta

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

type BlockFilterer ¶

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

	ImportedReverseFilter map[string]struct{}

	// 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]btcutil.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]btcutil.Address

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

	// If true, do not include coinbase transactions
	IgnoreCoinbase bool
}

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(params *chaincfg.Params,
	req *FilterBlocksRequest) *BlockFilterer

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

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

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

type ClientConnected ¶

type ClientConnected struct{}

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

type FilterBlocksRequest ¶

type FilterBlocksRequest struct {
	Blocks           []wtxmgr.BlockMeta
	ExternalAddrs    map[waddrmgr.ScopedIndex]btcutil.Address
	InternalAddrs    map[waddrmgr.ScopedIndex]btcutil.Address
	ImportedAddrs    []btcutil.Address
	WatchedOutPoints map[wire.OutPoint]btcutil.Address
	IgnoreCoinbase   bool
}

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 ¶

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]btcutil.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 ¶

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 ¶

type Interface interface {
	Start() er.R
	Stop()
	WaitForShutdown()
	GetBestBlock() (*chainhash.Hash, int32, er.R)
	GetBlock(*chainhash.Hash) (*wire.MsgBlock, er.R)
	GetBlockHash(int64) (*chainhash.Hash, er.R)
	GetBlockHeader(*chainhash.Hash) (*wire.BlockHeader, er.R)
	IsCurrent() bool
	FilterBlocks(*FilterBlocksRequest) (*FilterBlocksResponse, er.R)
	BlockStamp() (*waddrmgr.BlockStamp, er.R)
	SendRawTransaction(*wire.MsgTx, bool) (*chainhash.Hash, er.R)
	BackEnd() string
}

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

type NeutrinoClient ¶

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

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

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

func (s *NeutrinoClient) BackEnd() string

func (s *NeutrinoClient) BlockStamp() (*waddrmgr.BlockStamp, er.R)

func (s *NeutrinoClient) FilterBlocks(
	req *FilterBlocksRequest) (*FilterBlocksResponse, er.R)

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

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

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

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

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

func (s *NeutrinoClient) IsCurrent() bool

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

func (s *NeutrinoClient) Start() er.R

func (s *NeutrinoClient) Stop()

func (s *NeutrinoClient) WaitForShutdown()

type RPCClient ¶

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(chainParams *chaincfg.Params, connect, user, pass string, certs []byte,
	disableTLS bool, reconnectAttempts int) (*RPCClient, er.R)

func (c *RPCClient) BackEnd() string

func (c *RPCClient) BlockStamp() (*waddrmgr.BlockStamp, er.R)

func (c *RPCClient) FilterBlocks(
	req *FilterBlocksRequest) (*FilterBlocksResponse, er.R)

func (c *RPCClient) IsCurrent() bool

func (c *RPCClient) POSTClient() (*rpcclient.Client, er.R)

func (c *RPCClient) Start() er.R

func (c *RPCClient) Stop()

func (c *RPCClient) WaitForShutdown()

type RelevantTx ¶

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 ¶

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

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

type RescanProgress ¶

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

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