README

indexers

Build Status ISC License GoDoc

Package indexers implements optional block chain indexes.

These indexes are typically used to enhance the amount of information available via an RPC interface.

Supported Indexers

  • Transaction-by-hash (txbyhashidx) Index
    • Creates a mapping from the hash of each transaction to the block that contains it along with its offset and length within the serialized block
  • Transaction-by-address (txbyaddridx) Index
    • Creates a mapping from every address to all transactions which either credit or debit the address
    • Requires the transaction-by-hash index

Installation

$ go get -u github.com/gcash/bchd/blockchain/indexers

License

Package indexers is licensed under the copyfree ISC License.

Expand ▾ Collapse ▴

Documentation

Overview

    Package indexers implements optional block chain indexes.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func DisableLog

    func DisableLog()

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

      func DropAddrIndex

      func DropAddrIndex(db database.DB, interrupt <-chan struct{}) error

        DropAddrIndex drops the address index from the provided database if it exists.

        func DropCfIndex

        func DropCfIndex(db database.DB, interrupt <-chan struct{}) error

          DropCfIndex drops the CF index from the provided database if exists.

          func DropTxIndex

          func DropTxIndex(db database.DB, interrupt <-chan struct{}) error

            DropTxIndex drops the transaction index from the provided database if it exists. Since the address index relies on it, the address index will also be dropped when it exists.

            func UseLogger

            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 btclog.

              Types

              type AddrIndex

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

                AddrIndex implements a transaction by address index. That is to say, it supports querying all transactions that reference a given address because they are either crediting or debiting the address. The returned transactions are ordered according to their order of appearance in the blockchain. In other words, first by block height and then by offset inside the block.

                In addition, support is provided for a memory-only index of unconfirmed transactions such as those which are kept in the memory pool before inclusion in a block.

                func NewAddrIndex

                func NewAddrIndex(db database.DB, chainParams *chaincfg.Params) *AddrIndex

                  NewAddrIndex returns a new instance of an indexer that is used to create a mapping of all addresses in the blockchain to the respective transactions that involve them.

                  It implements the Indexer interface which plugs into the IndexManager that in turn is used by the blockchain package. This allows the index to be seamlessly maintained along with the chain.

                  func (*AddrIndex) AddUnconfirmedTx

                  func (idx *AddrIndex) AddUnconfirmedTx(tx *bchutil.Tx, utxoView *blockchain.UtxoViewpoint)

                    AddUnconfirmedTx adds all addresses related to the transaction to the unconfirmed (memory-only) address index.

                    NOTE: This transaction MUST have already been validated by the memory pool before calling this function with it and have all of the inputs available in the provided utxo view. Failure to do so could result in some or all addresses not being indexed.

                    This function is safe for concurrent access.

                    func (*AddrIndex) ConnectBlock

                    func (idx *AddrIndex) ConnectBlock(dbTx database.Tx, block *bchutil.Block,
                    	stxos []blockchain.SpentTxOut) error

                      ConnectBlock is invoked by the index manager when a new block has been connected to the main chain. This indexer adds a mapping for each address the transactions in the block involve.

                      This is part of the Indexer interface.

                      func (*AddrIndex) Create

                      func (idx *AddrIndex) Create(dbTx database.Tx) error

                        Create is invoked when the indexer manager determines the index needs to be created for the first time. It creates the bucket for the address index.

                        This is part of the Indexer interface.

                        func (*AddrIndex) DisconnectBlock

                        func (idx *AddrIndex) DisconnectBlock(dbTx database.Tx, block *bchutil.Block,
                        	stxos []blockchain.SpentTxOut) error

                          DisconnectBlock is invoked by the index manager when a block has been disconnected from the main chain. This indexer removes the address mappings each transaction in the block involve.

                          This is part of the Indexer interface.

                          func (*AddrIndex) Init

                          func (idx *AddrIndex) Init() error

                            Init is only provided to satisfy the Indexer interface as there is nothing to initialize for this index.

                            This is part of the Indexer interface.

                            func (*AddrIndex) Key

                            func (idx *AddrIndex) Key() []byte

                              Key returns the database key to use for the index as a byte slice.

                              This is part of the Indexer interface.

                              func (*AddrIndex) Migrate

                              func (idx *AddrIndex) Migrate(db database.DB, interrupt <-chan struct{}) error

                                Migrate is only provided to satisfy the Indexer interface as there is nothing to migrate this index.

                                This is part of the Indexer interface.

                                func (*AddrIndex) Name

                                func (idx *AddrIndex) Name() string

                                  Name returns the human-readable name of the index.

                                  This is part of the Indexer interface.

                                  func (*AddrIndex) NeedsInputs

                                  func (idx *AddrIndex) NeedsInputs() bool

                                    NeedsInputs signals that the index requires the referenced inputs in order to properly create the index.

                                    This implements the NeedsInputser interface.

                                    func (*AddrIndex) RemoveUnconfirmedTx

                                    func (idx *AddrIndex) RemoveUnconfirmedTx(hash *chainhash.Hash)

                                      RemoveUnconfirmedTx removes the passed transaction from the unconfirmed (memory-only) address index.

                                      This function is safe for concurrent access.

                                      func (*AddrIndex) TxRegionsForAddress

                                      func (idx *AddrIndex) TxRegionsForAddress(dbTx database.Tx, addr bchutil.Address, numToSkip, numRequested uint32, reverse bool) ([]database.BlockRegion, uint32, error)

                                        TxRegionsForAddress returns a slice of block regions which identify each transaction that involves the passed address according to the specified number to skip, number requested, and whether or not the results should be reversed. It also returns the number actually skipped since it could be less in the case where there are not enough entries.

                                        NOTE: These results only include transactions confirmed in blocks. See the UnconfirmedTxnsForAddress method for obtaining unconfirmed transactions that involve a given address.

                                        This function is safe for concurrent access.

                                        func (*AddrIndex) UnconfirmedTxnsForAddress

                                        func (idx *AddrIndex) UnconfirmedTxnsForAddress(addr bchutil.Address) []*bchutil.Tx

                                          UnconfirmedTxnsForAddress returns all transactions currently in the unconfirmed (memory-only) address index that involve the passed address. Unsupported address types are ignored and will result in no results.

                                          This function is safe for concurrent access.

                                          type AssertError

                                          type AssertError string

                                            AssertError identifies an error that indicates an internal code consistency issue and should be treated as a critical and unrecoverable error.

                                            func (AssertError) Error

                                            func (e AssertError) Error() string

                                              Error returns the assertion error as a huma-readable string and satisfies the error interface.

                                              type CfIndex

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

                                                CfIndex implements a committed filter (cf) by hash index.

                                                func NewCfIndex

                                                func NewCfIndex(db database.DB, chainParams *chaincfg.Params) *CfIndex

                                                  NewCfIndex returns a new instance of an indexer that is used to create a mapping of the hashes of all blocks in the blockchain to their respective committed filters.

                                                  It implements the Indexer interface which plugs into the IndexManager that in turn is used by the blockchain package. This allows the index to be seamlessly maintained along with the chain.

                                                  func (*CfIndex) ConnectBlock

                                                  func (idx *CfIndex) ConnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                  	stxos []blockchain.SpentTxOut) error

                                                    ConnectBlock is invoked by the index manager when a new block has been connected to the main chain. This indexer adds a hash-to-cf mapping for every passed block. This is part of the Indexer interface.

                                                    func (*CfIndex) Create

                                                    func (idx *CfIndex) Create(dbTx database.Tx) error

                                                      Create is invoked when the indexer manager determines the index needs to be created for the first time. It creates buckets for the two hash-based cf indexes (regular only currently).

                                                      func (*CfIndex) DisconnectBlock

                                                      func (idx *CfIndex) DisconnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                      	_ []blockchain.SpentTxOut) error

                                                        DisconnectBlock is invoked by the index manager when a block has been disconnected from the main chain. This indexer removes the hash-to-cf mapping for every passed block. This is part of the Indexer interface.

                                                        func (*CfIndex) FilterByBlockHash

                                                        func (idx *CfIndex) FilterByBlockHash(h *chainhash.Hash,
                                                        	filterType wire.FilterType) ([]byte, error)

                                                          FilterByBlockHash returns the serialized contents of a block's basic or committed filter.

                                                          func (*CfIndex) FilterHashByBlockHash

                                                          func (idx *CfIndex) FilterHashByBlockHash(h *chainhash.Hash,
                                                          	filterType wire.FilterType) ([]byte, error)

                                                            FilterHashByBlockHash returns the serialized contents of a block's basic committed filter hash.

                                                            func (*CfIndex) FilterHashesByBlockHashes

                                                            func (idx *CfIndex) FilterHashesByBlockHashes(blockHashes []*chainhash.Hash,
                                                            	filterType wire.FilterType) ([][]byte, error)

                                                              FilterHashesByBlockHashes returns the serialized contents of a block's basic committed filter hash for a set of blocks by hash.

                                                              func (*CfIndex) FilterHeaderByBlockHash

                                                              func (idx *CfIndex) FilterHeaderByBlockHash(h *chainhash.Hash,
                                                              	filterType wire.FilterType) ([]byte, error)

                                                                FilterHeaderByBlockHash returns the serialized contents of a block's basic committed filter header.

                                                                func (*CfIndex) FilterHeadersByBlockHashes

                                                                func (idx *CfIndex) FilterHeadersByBlockHashes(blockHashes []*chainhash.Hash,
                                                                	filterType wire.FilterType) ([][]byte, error)

                                                                  FilterHeadersByBlockHashes returns the serialized contents of a block's basic committed filter header for a set of blocks by hash.

                                                                  func (*CfIndex) FiltersByBlockHashes

                                                                  func (idx *CfIndex) FiltersByBlockHashes(blockHashes []*chainhash.Hash,
                                                                  	filterType wire.FilterType) ([][]byte, error)

                                                                    FiltersByBlockHashes returns the serialized contents of a block's basic or committed filter for a set of blocks by hash.

                                                                    func (*CfIndex) Init

                                                                    func (idx *CfIndex) Init() error

                                                                      Init initializes the hash-based cf index. This is part of the Indexer interface.

                                                                      func (*CfIndex) Key

                                                                      func (idx *CfIndex) Key() []byte

                                                                        Key returns the database key to use for the index as a byte slice. This is part of the Indexer interface.

                                                                        func (*CfIndex) Migrate

                                                                        func (idx *CfIndex) Migrate(db database.DB, interrupt <-chan struct{}) error

                                                                          Migrate migrates the index up to the current version. For the CfIndex we will just drop the index here and write the new version number. The IndexManager will then rebuild the index from the blockchain, using the new scheme, as it continues its Init function.

                                                                          This is part of the Indexer interface.

                                                                          func (*CfIndex) Name

                                                                          func (idx *CfIndex) Name() string

                                                                            Name returns the human-readable name of the index. This is part of the Indexer interface.

                                                                            func (*CfIndex) NeedsInputs

                                                                            func (idx *CfIndex) NeedsInputs() bool

                                                                              NeedsInputs signals that the index requires the referenced inputs in order to properly create the index.

                                                                              This implements the NeedsInputser interface.

                                                                              type Indexer

                                                                              type Indexer interface {
                                                                              	// Key returns the key of the index as a byte slice.
                                                                              	Key() []byte
                                                                              
                                                                              	// Name returns the human-readable name of the index.
                                                                              	Name() string
                                                                              
                                                                              	// Create is invoked when the indexer manager determines the index needs
                                                                              	// to be created for the first time.
                                                                              	Create(dbTx database.Tx) error
                                                                              
                                                                              	// Migrate is invoked after Init and allows each index the opportunity
                                                                              	// to perform any migrations as necessary. This should be a noop if
                                                                              	// there are no migrations to perform.
                                                                              	Migrate(db database.DB, interrupt <-chan struct{}) error
                                                                              
                                                                              	// Init is invoked when the index manager is first initializing the
                                                                              	// index.  This differs from the Create method in that it is called on
                                                                              	// every load, including the case the index was just created.
                                                                              	Init() error
                                                                              
                                                                              	// ConnectBlock is invoked when a new block has been connected to the
                                                                              	// main chain. The set of output spent within a block is also passed in
                                                                              	// so indexers can access the pevious output scripts input spent if
                                                                              	// required.
                                                                              	ConnectBlock(database.Tx, *bchutil.Block, []blockchain.SpentTxOut) error
                                                                              
                                                                              	// DisconnectBlock is invoked when a block has been disconnected from
                                                                              	// the main chain. The set of outputs scripts that were spent within
                                                                              	// this block is also returned so indexers can clean up the prior index
                                                                              	// state for this block
                                                                              	DisconnectBlock(database.Tx, *bchutil.Block, []blockchain.SpentTxOut) error
                                                                              }

                                                                                Indexer provides a generic interface for an indexer that is managed by an index manager such as the Manager type provided by this package.

                                                                                type Manager

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

                                                                                  Manager defines an index manager that manages multiple optional indexes and implements the blockchain.IndexManager interface so it can be seamlessly plugged into normal chain processing.

                                                                                  func NewManager

                                                                                  func NewManager(db database.DB, enabledIndexes []Indexer) *Manager

                                                                                    NewManager returns a new index manager with the provided indexes enabled.

                                                                                    The manager returned satisfies the blockchain.IndexManager interface and thus cleanly plugs into the normal blockchain processing path.

                                                                                    func (*Manager) ConnectBlock

                                                                                    func (m *Manager) ConnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                                                    	stxos []blockchain.SpentTxOut) error

                                                                                      ConnectBlock must be invoked when a block is extending the main chain. It keeps track of the state of each index it is managing, performs some sanity checks, and invokes each indexer.

                                                                                      This is part of the blockchain.IndexManager interface.

                                                                                      func (*Manager) DisconnectBlock

                                                                                      func (m *Manager) DisconnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                                                      	stxo []blockchain.SpentTxOut) error

                                                                                        DisconnectBlock must be invoked when a block is being disconnected from the end of the main chain. It keeps track of the state of each index it is managing, performs some sanity checks, and invokes each indexer to remove the index entries associated with the block.

                                                                                        This is part of the blockchain.IndexManager interface.

                                                                                        func (*Manager) Init

                                                                                        func (m *Manager) Init(chain *blockchain.BlockChain, interrupt <-chan struct{}) error

                                                                                          Init initializes the enabled indexes. This is called during chain initialization and primarily consists of catching up all indexes to the current best chain tip. This is necessary since each index can be disabled and re-enabled at any time and attempting to catch-up indexes at the same time new blocks are being downloaded would lead to an overall longer time to catch up due to the I/O contention.

                                                                                          This is part of the blockchain.IndexManager interface.

                                                                                          type NeedsInputser

                                                                                          type NeedsInputser interface {
                                                                                          	NeedsInputs() bool
                                                                                          }

                                                                                            NeedsInputser provides a generic interface for an indexer to specify the it requires the ability to look up inputs for a transaction.

                                                                                            type TxIndex

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

                                                                                              TxIndex implements a transaction by hash index. That is to say, it supports querying all transactions by their hash.

                                                                                              func NewTxIndex

                                                                                              func NewTxIndex(db database.DB) *TxIndex

                                                                                                NewTxIndex returns a new instance of an indexer that is used to create a mapping of the hashes of all transactions in the blockchain to the respective block, location within the block, and size of the transaction.

                                                                                                It implements the Indexer interface which plugs into the IndexManager that in turn is used by the blockchain package. This allows the index to be seamlessly maintained along with the chain.

                                                                                                func (*TxIndex) ConnectBlock

                                                                                                func (idx *TxIndex) ConnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                                                                	stxos []blockchain.SpentTxOut) error

                                                                                                  ConnectBlock is invoked by the index manager when a new block has been connected to the main chain. This indexer adds a hash-to-transaction mapping for every transaction in the passed block.

                                                                                                  This is part of the Indexer interface.

                                                                                                  func (*TxIndex) Create

                                                                                                  func (idx *TxIndex) Create(dbTx database.Tx) error

                                                                                                    Create is invoked when the indexer manager determines the index needs to be created for the first time. It creates the buckets for the hash-based transaction index and the internal block ID indexes.

                                                                                                    This is part of the Indexer interface.

                                                                                                    func (*TxIndex) DisconnectBlock

                                                                                                    func (idx *TxIndex) DisconnectBlock(dbTx database.Tx, block *bchutil.Block,
                                                                                                    	stxos []blockchain.SpentTxOut) error

                                                                                                      DisconnectBlock is invoked by the index manager when a block has been disconnected from the main chain. This indexer removes the hash-to-transaction mapping for every transaction in the block.

                                                                                                      This is part of the Indexer interface.

                                                                                                      func (*TxIndex) Init

                                                                                                      func (idx *TxIndex) Init() error

                                                                                                        Init initializes the hash-based transaction index. In particular, it finds the highest used block ID and stores it for later use when connecting or disconnecting blocks.

                                                                                                        This is part of the Indexer interface.

                                                                                                        func (*TxIndex) Key

                                                                                                        func (idx *TxIndex) Key() []byte

                                                                                                          Key returns the database key to use for the index as a byte slice.

                                                                                                          This is part of the Indexer interface.

                                                                                                          func (*TxIndex) Migrate

                                                                                                          func (idx *TxIndex) Migrate(db database.DB, interrupt <-chan struct{}) error

                                                                                                            Migrate is only provided to satisfy the Indexer interface as there is nothing to migrate this index.

                                                                                                            This is part of the Indexer interface.

                                                                                                            func (*TxIndex) Name

                                                                                                            func (idx *TxIndex) Name() string

                                                                                                              Name returns the human-readable name of the index.

                                                                                                              This is part of the Indexer interface.

                                                                                                              func (*TxIndex) TxBlockRegion

                                                                                                              func (idx *TxIndex) TxBlockRegion(hash *chainhash.Hash) (*database.BlockRegion, error)

                                                                                                                TxBlockRegion returns the block region for the provided transaction hash from the transaction index. The block region can in turn be used to load the raw transaction bytes. When there is no entry for the provided hash, nil will be returned for the both the entry and the error.

                                                                                                                This function is safe for concurrent access.