filters

Documentation

Index

• func FilterLogs(logs []*ethtypes.Log, fromBlock, toBlock *big.Int, addresses []common.Address, ...) []*ethtypes.Log
• type BloomIV
• type EventSystem
  • func NewEventSystem(clientCtx client.Context, logger log.Logger, eventBus *tmtypes.EventBus, ...) *EventSystem
  • func (es *EventSystem) SubscribeLogs(crit filters.FilterCriteria, logs chan []*ethtypes.Log) (*Subscription, error)
  • func (es *EventSystem) SubscribeNewHeads(headers chan *types.Header) *Subscription
  • func (es *EventSystem) SubscribePendingTxs(txs chan []*types.Transaction) *Subscription
• type Filter
  • func NewBlockFilter(logger log.Logger, b backend.BackendI, criteria filters.FilterCriteria) *Filter
  • func NewRangeFilter(logger log.Logger, b backend.BackendI, begin, end int64, ...) *Filter
  • func (f *Filter) Logs(_ context.Context, logLimit int, blockLimit int64) ([]*ethtypes.Log, error)
• type PublicFilterAPI
  • func NewPublicAPI(logger log.Logger, clientCtx client.Context, eventBus *tmtypes.EventBus, ...) *PublicFilterAPI
  • func (api *PublicFilterAPI) GetFilterChanges(id rpc.ID) (interface{}, error)
  • func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*ethtypes.Log, error)
  • func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCriteria) ([]*ethtypes.Log, error)
  • func (api *PublicFilterAPI) Logs(ctx context.Context, crit filters.FilterCriteria) (*rpc.Subscription, error)
  • func (api *PublicFilterAPI) NewBlockFilter() rpc.ID
  • func (api *PublicFilterAPI) NewFilter(criteria filters.FilterCriteria) (rpc.ID, error)
  • func (api *PublicFilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, error)
  • func (api *PublicFilterAPI) NewPendingTransactionFilter(fullTx *bool) rpc.ID
  • func (api *PublicFilterAPI) NewPendingTransactions(ctx context.Context, fullTx *bool) (*rpc.Subscription, error)
  • func (api *PublicFilterAPI) Syncing() (*rpc.Subscription, error)
  • func (api *PublicFilterAPI) UninstallFilter(id rpc.ID) bool
• type Subscription
  • func (s *Subscription) Err() <-chan error
  • func (s *Subscription) ID() rpc.ID
  • func (s *Subscription) Unsubscribe()

Functions

func FilterLogs

func FilterLogs(logs []*ethtypes.Log, fromBlock, toBlock *big.Int, addresses []common.Address, topics [][]common.Hash) []*ethtypes.Log

FilterLogs creates a slice of logs matching the given criteria. [] -> anything [A] -> A in first position of log topics, anything after [null, B] -> anything in first position, B in second position [A, B] -> A in first position and B in second position [[A, B], [A, B]] -> A or B in first position, A or B in second position

Types

type BloomIV

type BloomIV struct {
	I [3]uint
	V [3]byte
}

BloomIV represents the bit indexes and value inside the bloom filter that belong to some key.

type EventSystem

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

EventSystem creates subscriptions, processes events and broadcasts them to the subscription which match the subscription criteria using the Tendermint's RPC client.

func NewEventSystem

func NewEventSystem(clientCtx client.Context, logger log.Logger, eventBus *tmtypes.EventBus, b backend.BackendI) *EventSystem

NewEventSystem creates a new manager that listens for event on the given mux, parses and filters them. It uses the all map to retrieve filter changes. The work loop holds its own index that is used to forward events to filters.

The returned manager has a loop that needs to be stopped with the Stop function or by stopping the given mux.

func (*EventSystem) SubscribeLogs

func (es *EventSystem) SubscribeLogs(crit filters.FilterCriteria, logs chan []*ethtypes.Log) (*Subscription, error)

SubscribeLogs creates a subscription that will write all logs matching the given criteria to the given logs channel. Default value for the from and to block is "latest". If the fromBlock > toBlock an error is returned.

func (*EventSystem) SubscribeNewHeads

func (es *EventSystem) SubscribeNewHeads(headers chan *types.Header) *Subscription

SubscribeNewHeads subscribes to new block headers events.

func (*EventSystem) SubscribePendingTxs

func (es *EventSystem) SubscribePendingTxs(txs chan []*types.Transaction) *Subscription

SubscribePendingTxs creates a subscription that writes transactions for transactions that enter the transaction pool.

type Filter

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

Filter can be used to retrieve and filter logs.

func NewBlockFilter

func NewBlockFilter(logger log.Logger, b backend.BackendI, criteria filters.FilterCriteria) *Filter

NewBlockFilter creates a new filter which directly inspects the contents of a block to figure out whether it is interesting or not.

func NewRangeFilter

func NewRangeFilter(logger log.Logger, b backend.BackendI, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter

NewRangeFilter creates a new filter which uses a bloom filter on blocks to figure out whether a particular block is interesting or not.

func (*Filter) Logs

func (f *Filter) Logs(_ context.Context, logLimit int, blockLimit int64) ([]*ethtypes.Log, error)

Logs searches the blockchain for matching log entries, returning all from the first block that contains matches, updating the start of the filter accordingly.

type PublicFilterAPI

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

PublicFilterAPI offers support to create and manage filters. This will allow external clients to retrieve various information related to the Ethereum protocol such as blocks, transactions and logs.

func NewPublicAPI

func NewPublicAPI(logger log.Logger, clientCtx client.Context, eventBus *tmtypes.EventBus, b backend.BackendI) *PublicFilterAPI

NewPublicAPI returns a new PublicFilterAPI instance.

func (*PublicFilterAPI) GetFilterChanges

func (api *PublicFilterAPI) GetFilterChanges(id rpc.ID) (interface{}, error)

GetFilterChanges returns the logs for the filter with the given id since last time it was called. This can be used for polling.

For pending transaction and block filters the result is []common.Hash. (pending)Log filters return []Log.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getfilterchanges

func (*PublicFilterAPI) GetFilterLogs

func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*ethtypes.Log, error)

GetFilterLogs returns the logs for the filter with the given id. If the filter could not be found an empty array of logs is returned.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getfilterlogs

func (*PublicFilterAPI) GetLogs

func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit filters.FilterCriteria) ([]*ethtypes.Log, error)

GetLogs returns logs matching the given argument that are stored within the state.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getlogs

func (*PublicFilterAPI) Logs

func (api *PublicFilterAPI) Logs(ctx context.Context, crit filters.FilterCriteria) (*rpc.Subscription, error)

Logs creates a subscription that fires for all new log that match the given filter criteria.

func (*PublicFilterAPI) NewBlockFilter

func (api *PublicFilterAPI) NewBlockFilter() rpc.ID

NewBlockFilter creates a filter that fetches blocks that are imported into the chain. It is part of the filter package since polling goes with eth_getFilterChanges.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newblockfilter

func (*PublicFilterAPI) NewFilter

func (api *PublicFilterAPI) NewFilter(criteria filters.FilterCriteria) (rpc.ID, error)

NewFilter creates a new filter and returns the filter id. It can be used to retrieve logs when the state changes. This method cannot be used to fetch logs that are already stored in the state.

Default criteria for the from and to block are "latest". Using "latest" as block number will return logs for mined blocks. Using "pending" as block number returns logs for not yet mined (pending) blocks. In case logs are removed (chain reorg) previously returned logs are returned again but with the removed property set to true.

In case "fromBlock" > "toBlock" an error is returned.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newfilter

func (*PublicFilterAPI) NewHeads

func (api *PublicFilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, error)

NewHeads send a notification each time a new (header) block is appended to the chain.

func (*PublicFilterAPI) NewPendingTransactionFilter

func (api *PublicFilterAPI) NewPendingTransactionFilter(fullTx *bool) rpc.ID

NewPendingTransactionFilter creates a filter that fetches pending transactions as transactions enter the pending state.

It is part of the filter package because this filter can be used through the `eth_getFilterChanges` polling method that is also used for log filters.

func (*PublicFilterAPI) NewPendingTransactions

func (api *PublicFilterAPI) NewPendingTransactions(ctx context.Context, fullTx *bool) (*rpc.Subscription, error)

NewPendingTransactions creates a subscription that is triggered each time a transaction enters the transaction pool. If fullTx is true the full tx is sent to the client, otherwise the hash is sent.

func (*PublicFilterAPI) Syncing

func (api *PublicFilterAPI) Syncing() (*rpc.Subscription, error)

Syncing provides information when this nodes starts synchronising with the OneLedger network and when it's finished.

func (*PublicFilterAPI) UninstallFilter

func (api *PublicFilterAPI) UninstallFilter(id rpc.ID) bool

UninstallFilter removes the filter with the given filter id.

https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_uninstallfilter

type Subscription

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

Subscription defines a wrapper for the private subscription

func (*Subscription) Err

func (s *Subscription) Err() <-chan error

Err returns the error channel

func (*Subscription) ID

func (s *Subscription) ID() rpc.ID

ID returns the underlying subscription RPC identifier.

func (*Subscription) Unsubscribe

func (s *Subscription) Unsubscribe()

Unsubscribe from the current subscription to Tendermint Websocket. It sends an error to the subscription error channel if unsubscribe fails.