neutrino: github.com/gcash/neutrino Index | Files | Directories

package neutrino

import "github.com/gcash/neutrino"

Index

Package Files

batch_spend_reporter.go blockmanager.go errors.go headerlogger.go log.go mempool.go mock_store.go neutrino.go notifications.go query.go rescan.go utxoscanner.go

Variables

var (
    // ErrGetUtxoCancelled signals that a GetUtxo request was cancelled.
    ErrGetUtxoCancelled = errors.New("get utxo request cancelled")

    // ErrShuttingDown signals that neutrino received a shutdown request.
    ErrShuttingDown = errors.New("neutrino shutting down")
)
var (
    // ConnectionRetryInterval is the base amount of time to wait in
    // between retries when connecting to persistent peers.  It is adjusted
    // by the number of retries such that there is a retry backoff.
    ConnectionRetryInterval = time.Second * 5

    // UserAgentName is the user agent name and is used to help identify
    // ourselves to other bitcoin peers.
    UserAgentName = "neutrino"

    // UserAgentVersion is the user agent version and is used to help
    // identify ourselves to other bitcoin peers.
    UserAgentVersion = "0.0.4-beta"

    // Services describes the services that are supported by the server.
    Services = wire.SFNodeCF

    // RequiredServices describes the services that are required to be
    // supported by outbound peers.
    RequiredServices = wire.SFNodeNetwork | wire.SFNodeCF

    // BanThreshold is the maximum ban score before a peer is banned.
    BanThreshold = uint32(100)

    // BanDuration is the duration of a ban.
    BanDuration = time.Hour * 24

    // TargetOutbound is the number of outbound peers to target.
    TargetOutbound = 8

    // MaxPeers is the maximum number of connections the client maintains.
    MaxPeers = 125

    // DisableDNSSeed disables getting initial addresses for Bitcoin nodes
    // from DNS.
    DisableDNSSeed = false

    // DefaultFilterCacheSize is the size (in bytes) of filters neutrino
    // will keep in memory if no size is specified in the neutrino.Config.
    // Since we utilize the cache during batch filter fetching, it is
    // beneficial if it is able to to keep a whole batch. The current batch
    // size is 1000, so we default to 30 MB, which can fit about 1450 to
    // 2300 mainnet filters.
    DefaultFilterCacheSize uint64 = 3120 * 10 * 1000

    // DefaultBlockCacheSize is the size (in bytes) of blocks neutrino will
    // keep in memory if no size is specified in the neutrino.Config.
    DefaultBlockCacheSize uint64 = 4096 * 10 * 1000 // 40 MB
)

These are exported variables so they can be changed by users.

TODO: Export functional options for these as much as possible so they can be changed call-to-call.

var (
    // QueryTimeout specifies how long to wait for a peer to answer a
    // query.
    QueryTimeout = time.Second * 10

    // QueryBatchTimeout is the total time we'll wait for a batch fetch
    // query to complete.
    QueryBatchTimeout = time.Second * 30

    // QueryPeerCooldown is the time we'll wait before re-assigning a query
    // to a peer that previously failed because of a timeout.
    QueryPeerCooldown = time.Second * 5

    // QueryNumRetries specifies how many times to retry sending a query to
    // each peer before we've concluded we aren't going to get a valid
    // response. This allows to make up for missed messages in some
    // instances.
    QueryNumRetries = 2

    // QueryPeerConnectTimeout specifies how long to wait for the
    // underlying chain service to connect to a peer before giving up
    // on a query in case we don't have any peers.
    QueryPeerConnectTimeout = time.Second * 30

    // QueryEncoding specifies the default encoding (witness or not) for
    // `getdata` and other similar messages.
    QueryEncoding = wire.BaseEncoding
)
var (
    // ErrRescanExit is an error returned to the caller in case the ongoing
    // rescan exits.
    ErrRescanExit = errors.New("rescan exited")
)

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 ChainService Uses

type ChainService struct {
    FilterDB         filterdb.FilterDatabase
    BlockHeaders     headerfs.BlockHeaderStore
    RegFilterHeaders *headerfs.FilterHeaderStore

    FilterCache *lru.Cache
    BlockCache  *lru.Cache
    // contains filtered or unexported fields
}

ChainService is instantiated with functional options

func NewChainService Uses

func NewChainService(cfg Config) (*ChainService, error)

NewChainService returns a new chain service configured to connect to the bitcoin network type specified by chainParams. Use start to begin syncing with peers.

func (*ChainService) AddBytesReceived Uses

func (s *ChainService) AddBytesReceived(bytesReceived uint64)

AddBytesReceived adds the passed number of bytes to the total bytes received counter for the server. It is safe for concurrent access.

func (*ChainService) AddBytesSent Uses

func (s *ChainService) AddBytesSent(bytesSent uint64)

AddBytesSent adds the passed number of bytes to the total bytes sent counter for the server. It is safe for concurrent access.

func (*ChainService) AddPeer Uses

func (s *ChainService) AddPeer(sp *ServerPeer)

AddPeer adds a new peer that has already been connected to the server.

func (*ChainService) AddedNodeInfo Uses

func (s *ChainService) AddedNodeInfo() []*ServerPeer

AddedNodeInfo returns an array of btcjson.GetAddedNodeInfoResult structures describing the persistent (added) nodes.

func (*ChainService) BanPeer Uses

func (s *ChainService) BanPeer(addr string, reason banman.Reason) error

BanPeer bans a peer due to a specific reason for a duration of BanDuration.

func (*ChainService) BestBlock Uses

func (s *ChainService) BestBlock() (*waddrmgr.BlockStamp, error)

BestBlock retrieves the most recent block's height and hash where we have both the header and filter header ready.

func (*ChainService) ChainParams Uses

func (s *ChainService) ChainParams() chaincfg.Params

ChainParams returns a copy of the ChainService's chaincfg.Params.

func (*ChainService) ConnectNode Uses

func (s *ChainService) ConnectNode(addr string, permanent bool) error

ConnectNode adds `addr' as a new outbound peer. If permanent is true then the peer will be persistent and reconnect if the connection is lost. It is an error to call this with an already existing peer.

func (*ChainService) ConnectedCount Uses

func (s *ChainService) ConnectedCount() int32

ConnectedCount returns the number of currently connected peers.

func (*ChainService) DisconnectNodeByAddr Uses

func (s *ChainService) DisconnectNodeByAddr(addr string) error

DisconnectNodeByAddr disconnects a peer by target address. Both outbound and inbound nodes will be searched for the target node. An error message will be returned if the peer was not found.

func (*ChainService) DisconnectNodeByID Uses

func (s *ChainService) DisconnectNodeByID(id int32) error

DisconnectNodeByID disconnects a peer by target node id. Both outbound and inbound nodes will be searched for the target node. An error message will be returned if the peer was not found.

func (*ChainService) ForAllPeers Uses

func (s *ChainService) ForAllPeers(closure func(sp *ServerPeer))

ForAllPeers runs a closure over all peers (outbound and persistent) to which the ChainService is connected. Nothing is returned because the peerState's ForAllPeers method doesn't return anything as the closure passed to it doesn't return anything.

func (*ChainService) GetBlock Uses

func (s *ChainService) GetBlock(blockHash chainhash.Hash,
    options ...QueryOption) (*bchutil.Block, error)

GetBlock gets a block by requesting it from the network, one peer at a time, until one answers. If the block is found in the cache, it will be returned immediately.

func (*ChainService) GetBlockHash Uses

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

GetBlockHash returns the block hash at the given height.

func (*ChainService) GetBlockHeader Uses

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

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

func (*ChainService) GetBlockHeight Uses

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

GetBlockHeight gets the height of a block by its hash. An error is returned if the given block hash is unknown.

func (*ChainService) GetCFilter Uses

func (s *ChainService) GetCFilter(blockHash chainhash.Hash,
    filterType wire.FilterType, options ...QueryOption) (*gcs.Filter, error)

GetCFilter gets a cfilter from the database. Failing that, it requests the cfilter from the network and writes it to the database. If extended is true, an extended filter will be queried for. Otherwise, we'll fetch the regular filter.

func (*ChainService) GetUtxo Uses

func (s *ChainService) GetUtxo(options ...RescanOption) (*SpendReport, error)

GetUtxo gets the appropriate TxOut or errors if it's spent. The option WatchOutPoints (with a single outpoint) is required. StartBlock can be used to give a hint about which block the transaction is in, and TxIdx can be used to give a hint of which transaction in the block matches it (coinbase is 0, first normal transaction is 1, etc.).

TODO(roasbeef): WTB utxo-commitments

func (*ChainService) IsBanned Uses

func (s *ChainService) IsBanned(addr string) bool

IsBanned returns true if the peer is banned, and false otherwise.

func (*ChainService) IsCurrent Uses

func (s *ChainService) IsCurrent() bool

IsCurrent lets the caller know whether the chain service's block manager thinks its view of the network is current.

func (*ChainService) NetTotals Uses

func (s *ChainService) NetTotals() (uint64, uint64)

NetTotals returns the sum of all bytes received and sent across the network for all peers. It is safe for concurrent access.

func (*ChainService) NotifyMempoolReceived Uses

func (s *ChainService) NotifyMempoolReceived(addrs []bchutil.Address)

NotifyMempoolReceived registers addresses to receive a callback on when a transaction paying to them enters the mempool.

func (*ChainService) OutboundGroupCount Uses

func (s *ChainService) OutboundGroupCount(key string) int

OutboundGroupCount returns the number of peers connected to the given outbound group key.

func (*ChainService) PeerByAddr Uses

func (s *ChainService) PeerByAddr(addr string) *ServerPeer

PeerByAddr lets the caller look up a peer address in the service's peer table, if connected to that peer address.

func (*ChainService) Peers Uses

func (s *ChainService) Peers() []*ServerPeer

Peers returns an array of all connected peers.

func (*ChainService) RegisterMempoolCallback Uses

func (s *ChainService) RegisterMempoolCallback(onRecvTx func(tx *bchutil.Tx, block *btcjson.BlockDetails))

RegisterMempoolCallback registers a callback to be fired whenever a new transaction is received into the mempool

func (*ChainService) RemoveNodeByAddr Uses

func (s *ChainService) RemoveNodeByAddr(addr string) error

RemoveNodeByAddr removes a peer from the list of persistent peers if present. An error will be returned if the peer was not found.

func (*ChainService) RemoveNodeByID Uses

func (s *ChainService) RemoveNodeByID(id int32) error

RemoveNodeByID removes a peer by node ID from the list of persistent peers if present. An error will be returned if the peer was not found.

func (*ChainService) RequestMempoolFilter Uses

func (s *ChainService) RequestMempoolFilter(addrs []bchutil.Address)

RequestMempoolFilter requests the mempool filter from a single peer.

func (*ChainService) SendTransaction Uses

func (s *ChainService) SendTransaction(tx *wire.MsgTx) error

SendTransaction broadcasts the transaction to all currently active peers so it can be propagated to other nodes and eventually mined. An error won't be returned if the transaction already exists within the mempool. Any transaction broadcast through this method will be rebroadcast upon every change of the tip of the chain.

func (*ChainService) Start Uses

func (s *ChainService) Start() error

Start begins connecting to peers and syncing the blockchain.

func (*ChainService) Stop Uses

func (s *ChainService) Stop() error

Stop gracefully shuts down the server by stopping and disconnecting all peers and the main listener.

func (*ChainService) UpdatePeerHeights Uses

func (s *ChainService) UpdatePeerHeights(latestBlkHash *chainhash.Hash,
    latestHeight int32, updateSource *ServerPeer)

UpdatePeerHeights updates the heights of all peers who have have announced the latest connected main chain block, or a recognized orphan. These height updates allow us to dynamically refresh peer heights, ensuring sync peer selection has access to the latest block heights for each peer.

type ChainSource Uses

type ChainSource interface {
    // ChainParams returns the parameters of the current chain.
    ChainParams() chaincfg.Params

    // BestBlock retrieves the most recent block's height and hash where we
    // have both the header and filter header ready.
    BestBlock() (*waddrmgr.BlockStamp, error)

    // GetBlockHeaderByHeight returns the header of the block with the given
    // height.
    GetBlockHeaderByHeight(uint32) (*wire.BlockHeader, error)

    // GetBlockHeader returns the header of the block with the given hash.
    GetBlockHeader(*chainhash.Hash) (*wire.BlockHeader, uint32, error)

    // GetBlock returns the block with the given hash.
    GetBlock(chainhash.Hash, ...QueryOption) (*bchutil.Block, error)

    // GetFilterHeaderByHeight returns the filter header of the block with
    // the given height.
    GetFilterHeaderByHeight(uint32) (*chainhash.Hash, error)

    // GetCFilter returns the filter of the given type for the block with
    // the given hash.
    GetCFilter(chainhash.Hash, wire.FilterType,
        ...QueryOption) (*gcs.Filter, error)

    // Subscribe returns a block subscription that delivers block
    // notifications in order. The bestHeight parameter can be used to
    // signal that a backlog of notifications should be delivered from this
    // height. When providing a bestHeight of 0, a backlog will not be
    // delivered.
    //
    // TODO(wilmer): extend with best hash as well.
    Subscribe(bestHeight uint32) (*blockntfns.Subscription, error)
}

ChainSource is an interface that's in charge of retrieving information about the existing chain.

type Config Uses

type Config struct {
    // DataDir is the directory that neutrino will store all header
    // information within.
    DataDir string

    // Database is an *open* database instance that we'll use to storm
    // indexes of teh chain.
    Database walletdb.DB

    // ChainParams is the chain that we're running on.
    ChainParams chaincfg.Params

    // ConnectPeers is a slice of hosts that should be connected to on
    // startup, and be established as persistent peers.
    //
    // NOTE: If specified, we'll *only* connect to this set of peers and
    // won't attempt to automatically seek outbound peers.
    ConnectPeers []string

    // AddPeers is a slice of hosts that should be connected to on startup,
    // and be maintained as persistent peers.
    AddPeers []string

    // Dialer is an optional function closure that will be used to
    // establish outbound TCP connections. If specified, then the
    // connection manager will use this in place of net.Dial for all
    // outbound connection attempts.
    Dialer func(addr net.Addr) (net.Conn, error)

    // NameResolver is an optional function closure that will be used to
    // lookup the IP of any host. If specified, then the address manager,
    // along with regular outbound connection attempts will use this
    // instead.
    NameResolver func(host string) ([]net.IP, error)

    // FilterCacheSize indicates the size (in bytes) of filters the cache will
    // hold in memory at most.
    FilterCacheSize uint64

    // BlockCacheSize indicates the size (in bytes) of blocks the block
    // cache will hold in memory at most.
    BlockCacheSize uint64

    // BlocksOnly sets whether or not to download unconfirmed transactions
    // off the wire. If true the ChainService will send notifications when an
    // unconfirmed transaction matches a watching address. The trade-off here is
    // you're going to use a lot more bandwidth but it may be acceptable for apps
    // which only run for brief periods of time.
    BlocksOnly bool

    // Proxy is an address to use to connect remote peers using the socks5 proxy.
    Proxy string

    // AssertFilterHeader is an optional field that allows the creator of
    // the ChainService to ensure that if any chain data exists, it's
    // compliant with the expected filter header state. If neutrino starts
    // up and this filter header state has diverged, then it'll remove the
    // current on disk filter headers to sync them anew.
    AssertFilterHeader *headerfs.FilterHeader
}

Config is a struct detailing the configuration of the chain service.

type GetUtxoRequest Uses

type GetUtxoRequest struct {
    // Input is the target outpoint with script to watch for spentness.
    Input *InputWithScript

    // BirthHeight is the height at which we expect to find the original
    // unspent outpoint. This is also the height used when starting the
    // search for spends.
    BirthHeight uint32
    // contains filtered or unexported fields
}

GetUtxoRequest is a request to scan for InputWithScript from the height BirthHeight.

func (*GetUtxoRequest) Result Uses

func (r *GetUtxoRequest) Result(cancel <-chan struct{}) (*SpendReport, error)

Result is callback returning either a spend report or an error.

type GetUtxoRequestPQ Uses

type GetUtxoRequestPQ []*GetUtxoRequest

A GetUtxoRequestPQ implements heap.Interface and holds GetUtxoRequests. The queue maintains that heap.Pop() will always return the GetUtxo request with the least starting height. This allows us to add new GetUtxo requests to an already running batch.

func (*GetUtxoRequestPQ) IsEmpty Uses

func (pq *GetUtxoRequestPQ) IsEmpty() bool

IsEmpty returns true if the queue has no elements.

func (GetUtxoRequestPQ) Len Uses

func (pq GetUtxoRequestPQ) Len() int

func (GetUtxoRequestPQ) Less Uses

func (pq GetUtxoRequestPQ) Less(i, j int) bool

func (*GetUtxoRequestPQ) Peek Uses

func (pq *GetUtxoRequestPQ) Peek() *GetUtxoRequest

Peek returns the least height element in the queue without removing it.

func (*GetUtxoRequestPQ) Pop Uses

func (pq *GetUtxoRequestPQ) Pop() interface{}

Pop is called by the heap.Interface implementation to remove an element from the end of the backing store. The heap library will then maintain the heap invariant.

func (*GetUtxoRequestPQ) Push Uses

func (pq *GetUtxoRequestPQ) Push(x interface{})

Push is called by the heap.Interface implementation to add an element to the end of the backing store. The heap library will then maintain the heap invariant.

func (GetUtxoRequestPQ) Swap Uses

func (pq GetUtxoRequestPQ) Swap(i, j int)

type InputWithScript Uses

type InputWithScript struct {
    // OutPoint identifies the previous output to watch.
    OutPoint wire.OutPoint

    // PkScript is the script of the previous output.
    PkScript []byte
}

InputWithScript couples an previous outpoint along with its input script. We'll use the prev script to match the filter itself, but then scan for the particular outpoint when we need to make a notification decision.

type Mempool Uses

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

Mempool is used when we are downloading unconfirmed transactions. We will use this object to track which transactions we've already downloaded so that we don't download them more than once.

func NewMempool Uses

func NewMempool() *Mempool

NewMempool returns an initialized mempool

func (*Mempool) AddTransaction Uses

func (mp *Mempool) AddTransaction(tx *bchutil.Tx)

AddTransaction adds a new transaction to the mempool and maybe calls back if it matches any watched addresses.

func (*Mempool) Clear Uses

func (mp *Mempool) Clear()

Clear will remove all transactions from the mempool. This should be done whenever a new block is accepted.

func (*Mempool) HaveTransaction Uses

func (mp *Mempool) HaveTransaction(hash *chainhash.Hash) bool

HaveTransaction returns whether or not the passed transaction already exists in the mempool.

func (*Mempool) NotifyReceived Uses

func (mp *Mempool) NotifyReceived(addrs []bchutil.Address)

NotifyReceived stores addresses to watch

func (*Mempool) RegisterCallback Uses

func (mp *Mempool) RegisterCallback(onRecvTx func(tx *bchutil.Tx, block *btcjson.BlockDetails))

RegisterCallback will register a callback that will fire when a transaction matching a watched address enters the mempool.

type QueryAccess Uses

type QueryAccess interface {
    // contains filtered or unexported methods
}

QueryAccess is an interface that gives acces to query a set of peers in different ways.

type QueryOption Uses

type QueryOption func(*queryOptions)

QueryOption is a functional option argument to any of the network query methods, such as GetBlock and GetCFilter (when that resorts to a network query). These are always processed in order, with later options overriding earlier ones.

func DoneChan Uses

func DoneChan(doneChan chan<- struct{}) QueryOption

DoneChan allows the caller to pass a channel that will get closed when the query is finished.

func Encoding Uses

func Encoding(encoding wire.MessageEncoding) QueryOption

Encoding is a query option that allows the caller to set a message encoding for the query messages.

func NumRetries Uses

func NumRetries(numRetries uint8) QueryOption

NumRetries is a query option that lets the query know the maximum number of times each peer should be queried. The default is one.

func OptimisticBatch Uses

func OptimisticBatch() QueryOption

OptimisticBatch allows the caller to tell that items following the requested one should be included in the query.

func OptimisticReverseBatch Uses

func OptimisticReverseBatch() QueryOption

OptimisticReverseBatch allows the caller to tell that items preceding the requested one should be included in the query.

func PeerConnectTimeout Uses

func PeerConnectTimeout(timeout time.Duration) QueryOption

PeerConnectTimeout is a query option that lets the query know how long to wait for the underlying chain service to connect to a peer before giving up on a query in case we don't have any peers.

func PersistToDisk Uses

func PersistToDisk() QueryOption

PersistToDisk allows the caller to tell that the filter should be kept on disk once it's found.

func Timeout Uses

func Timeout(timeout time.Duration) QueryOption

Timeout is a query option that lets the query know how long to wait for each peer we ask the query to answer it before moving on.

type Rescan Uses

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

Rescan is an object that represents a long-running rescan/notification client with updateable filters. It's meant to be close to a drop-in replacement for the bchd rescan and notification functionality used in wallets. It only contains information about whether a goroutine is running.

func NewRescan Uses

func NewRescan(chain ChainSource, options ...RescanOption) *Rescan

NewRescan returns a rescan object that runs in another goroutine and has an updatable filter. It returns the long-running rescan object, and a channel which returns any error on termination of the rescan process.

func (*Rescan) Start Uses

func (r *Rescan) Start() <-chan error

Start kicks off the rescan goroutine, which will begin to scan the chain according to the specified rescan options.

func (*Rescan) Update Uses

func (r *Rescan) Update(options ...UpdateOption) error

Update sends an update to a long-running rescan/notification goroutine.

func (*Rescan) WaitForShutdown Uses

func (r *Rescan) WaitForShutdown()

WaitForShutdown waits until all goroutines associated with the rescan have exited. This method is to be called once the passed quitchan (if any) has been closed.

type RescanChainSource Uses

type RescanChainSource struct {
    *ChainService
}

RescanChainSource is a wrapper type around the ChainService struct that will be used to satisfy the rescan.ChainSource interface.

func (*RescanChainSource) GetBlockHeader Uses

func (s *RescanChainSource) GetBlockHeader(
    hash *chainhash.Hash) (*wire.BlockHeader, uint32, error)

GetBlockHeader returns the header of the block with the given hash.

func (*RescanChainSource) GetBlockHeaderByHeight Uses

func (s *RescanChainSource) GetBlockHeaderByHeight(
    height uint32) (*wire.BlockHeader, error)

GetBlockHeaderByHeight returns the header of the block with the given height.

func (*RescanChainSource) GetFilterHeaderByHeight Uses

func (s *RescanChainSource) GetFilterHeaderByHeight(
    height uint32) (*chainhash.Hash, error)

GetFilterHeaderByHeight returns the filter header of the block with the given height.

func (*RescanChainSource) Subscribe Uses

func (s *RescanChainSource) Subscribe(
    bestHeight uint32) (*blockntfns.Subscription, error)

Subscribe returns a block subscription that delivers block notifications in order. The bestHeight parameter can be used to signal that a backlog of notifications should be delivered from this height. When providing a height of 0, a backlog will not be delivered.

type RescanOption Uses

type RescanOption func(ro *rescanOptions)

RescanOption is a functional option argument to any of the rescan and notification subscription methods. These are always processed in order, with later options overriding earlier ones.

func EndBlock Uses

func EndBlock(endBlock *waddrmgr.BlockStamp) RescanOption

EndBlock specifies the end block. The hash is checked first; if there's no such hash (zero hash avoids lookup), the height is checked next. If the height is 0 or in the future or the end block isn't specified, the quit channel MUST be specified as Rescan will sync to the tip of the blockchain and continue to stay in sync and pass notifications. This is enforced at runtime.

func NotificationHandlers Uses

func NotificationHandlers(ntfn rpcclient.NotificationHandlers) RescanOption

NotificationHandlers specifies notification handlers for the rescan. These will always run in the same goroutine as the caller.

func QueryOptions Uses

func QueryOptions(options ...QueryOption) RescanOption

QueryOptions pass onto the underlying queries.

func QuitChan Uses

func QuitChan(quit <-chan struct{}) RescanOption

QuitChan specifies the quit channel. This can be used by the caller to let an indefinite rescan (one with no EndBlock set) know it should gracefully shut down. If this isn't specified, an end block MUST be specified as Rescan must know when to stop. This is enforced at runtime.

func StartBlock Uses

func StartBlock(startBlock *waddrmgr.BlockStamp) RescanOption

StartBlock specifies the start block. The hash is checked first; if there's no such hash (zero hash avoids lookup), the height is checked next. If the height is 0 or the start block isn't specified, starts from the genesis block. This block is assumed to already be known, and no notifications will be sent for this block. The rescan uses the latter of StartBlock and StartTime.

func StartTime Uses

func StartTime(startTime time.Time) RescanOption

StartTime specifies the start time. The time is compared to the timestamp of each block, and the rescan only begins once the first block crosses that timestamp. When using this, it is advisable to use a margin of error and start rescans slightly earlier than required. The rescan uses the latter of StartBlock and StartTime.

func TxIdx Uses

func TxIdx(txIdx uint32) RescanOption

TxIdx specifies a hint transaction index into the block in which the UTXO is created (eg, coinbase is 0, next transaction is 1, etc.)

func WatchAddrs Uses

func WatchAddrs(watchAddrs ...bchutil.Address) RescanOption

WatchAddrs specifies the addresses to watch/filter for. Each call to this function adds to the list of addresses being watched rather than replacing the list. Each time a transaction spends to the specified address, the outpoint is added to the WatchOutPoints list.

func WatchInputs Uses

func WatchInputs(watchInputs ...InputWithScript) RescanOption

WatchInputs specifies the outpoints to watch for on-chain spends. We also require the script as we'll match on the script, but then notify based on the outpoint. Each call to this function adds to the list of outpoints being watched rather than replacing the list.

type ServerPeer Uses

type ServerPeer struct {
    *peer.Peer
    // contains filtered or unexported fields
}

ServerPeer extends the peer to maintain state shared by the server and the blockmanager.

func (*ServerPeer) OnAddr Uses

func (sp *ServerPeer) OnAddr(_ *peer.Peer, msg *wire.MsgAddr)

OnAddr is invoked when a peer receives an addr bitcoin message and is used to notify the server about advertised addresses.

func (*ServerPeer) OnFeeFilter Uses

func (sp *ServerPeer) OnFeeFilter(_ *peer.Peer, msg *wire.MsgFeeFilter)

OnFeeFilter is invoked when a peer receives a feefilter bitcoin message and is used by remote peers to request that no transactions which have a fee rate lower than provided value are inventoried to them. The peer will be disconnected if an invalid fee filter value is provided.

func (*ServerPeer) OnHeaders Uses

func (sp *ServerPeer) OnHeaders(p *peer.Peer, msg *wire.MsgHeaders)

OnHeaders is invoked when a peer receives a headers bitcoin message. The message is passed down to the block manager.

func (*ServerPeer) OnInv Uses

func (sp *ServerPeer) OnInv(p *peer.Peer, msg *wire.MsgInv)

OnInv is invoked when a peer receives an inv bitcoin message and is used to examine the inventory being advertised by the remote peer and react accordingly. We pass the message down to blockmanager which will call QueueMessage with any appropriate responses.

func (*ServerPeer) OnRead Uses

func (sp *ServerPeer) OnRead(_ *peer.Peer, bytesRead int, msg wire.Message,
    err error)

OnRead is invoked when a peer receives a message and it is used to update the bytes received by the server.

func (*ServerPeer) OnReject Uses

func (sp *ServerPeer) OnReject(_ *peer.Peer, msg *wire.MsgReject)

OnReject is invoked when a peer receives a reject bitcoin message and is used to notify the server about a rejected transaction.

func (*ServerPeer) OnTx Uses

func (sp *ServerPeer) OnTx(p *peer.Peer, msg *wire.MsgTx)

OnTx is invoked when a peer sends us a new transaction. We will will pass it into the blockmanager for further processing.

func (*ServerPeer) OnVerAck Uses

func (sp *ServerPeer) OnVerAck(_ *peer.Peer, msg *wire.MsgVerAck)

OnVerAck is invoked when a peer receives a verack bitcoin message and is used to send the "sendheaders" command to peers that are of a sufficienty new protocol version.

func (*ServerPeer) OnVersion Uses

func (sp *ServerPeer) OnVersion(_ *peer.Peer, msg *wire.MsgVersion) *wire.MsgReject

OnVersion is invoked when a peer receives a version bitcoin message and is used to negotiate the protocol version details as well as kick start the communications.

func (*ServerPeer) OnWrite Uses

func (sp *ServerPeer) OnWrite(_ *peer.Peer, bytesWritten int, msg wire.Message, err error)

OnWrite is invoked when a peer sends a message and it is used to update the bytes sent by the server.

type SpendReport Uses

type SpendReport struct {
    // SpendingTx is the transaction that spent the output that a spend
    // report was requested for.
    //
    // NOTE: This field will only be populated if the target output has
    // been spent.
    SpendingTx *wire.MsgTx

    // SpendingTxIndex is the input index of the transaction above which
    // spends the target output.
    //
    // NOTE: This field will only be populated if the target output has
    // been spent.
    SpendingInputIndex uint32

    // SpendingTxHeight is the hight of the block that included the
    // transaction  above which spent the target output.
    //
    // NOTE: This field will only be populated if the target output has
    // been spent.
    SpendingTxHeight uint32

    // Output is the raw output of the target outpoint.
    //
    // NOTE: This field will only be populated if the target is still
    // unspent.
    Output *wire.TxOut
}

SpendReport is a struct which describes the current spentness state of a particular output. In the case that an output is spent, then the spending transaction and related details will be populated. Otherwise, only the target unspent output in the chain will be returned.

type UpdateOption Uses

type UpdateOption func(uo *updateOptions)

UpdateOption is a functional option argument for the Rescan.Update method.

func AddAddrs Uses

func AddAddrs(addrs ...bchutil.Address) UpdateOption

AddAddrs adds addresses to the filter.

func AddInputs Uses

func AddInputs(inputs ...InputWithScript) UpdateOption

AddInputs adds inputs to watch to the filter.

func DisableDisconnectedNtfns Uses

func DisableDisconnectedNtfns(disabled bool) UpdateOption

DisableDisconnectedNtfns tells the rescan not to send `OnBlockDisconnected` and `OnFilteredBlockDisconnected` notifications when rewinding.

func Rewind Uses

func Rewind(height uint32) UpdateOption

Rewind rewinds the rescan to the specified height (meaning, disconnects down to the block immediately after the specified height) and restarts it from that point with the (possibly) newly expanded filter. Especially useful when called in the same Update() as one of the previous three options.

type UtxoScanner Uses

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

UtxoScanner batches calls to GetUtxo so that a single scan can search for multiple outpoints. If a scan is in progress when a new element is added, we check whether it can safely be added to the current batch, if not it will be included in the next batch.

func NewUtxoScanner Uses

func NewUtxoScanner(cfg *UtxoScannerConfig) *UtxoScanner

NewUtxoScanner creates a new instance of UtxoScanner using the given chain interface.

func (*UtxoScanner) Enqueue Uses

func (s *UtxoScanner) Enqueue(input *InputWithScript,
    birthHeight uint32) (*GetUtxoRequest, error)

Enqueue takes a GetUtxoRequest and adds it to the next applicable batch.

func (*UtxoScanner) Start Uses

func (s *UtxoScanner) Start() error

Start begins running scan batches.

func (*UtxoScanner) Stop Uses

func (s *UtxoScanner) Stop() error

Stop any in-progress scan.

type UtxoScannerConfig Uses

type UtxoScannerConfig struct {
    // BestSnapshot returns the block stamp of the current chain tip.
    BestSnapshot func() (*waddrmgr.BlockStamp, error)

    // GetBlockHash returns the block hash at given height in main chain.
    GetBlockHash func(height int64) (*chainhash.Hash, error)

    // BlockFilterMatches checks the cfilter for the block hash for matches
    // against the rescan options.
    BlockFilterMatches func(ro *rescanOptions, blockHash *chainhash.Hash) (bool, error)

    // GetBlock fetches a block from the p2p network.
    GetBlock func(chainhash.Hash, ...QueryOption) (*bchutil.Block, error)
}

UtxoScannerConfig exposes configurable methods for interacting with the blockchain.

Directories

PathSynopsis
banman
blockntfns
blockntfns/queue
cache
cache/lru
chainsync
filterdb
headerfs
headerlist
pushtx

Package neutrino imports 38 packages (graph) and is imported by 4 packages. Updated 2020-06-01. Refresh now. Tools for package owners.