go-ethereum: github.com/ethereum/go-ethereum/eth/filters Index | Files

package filters

import "github.com/ethereum/go-ethereum/eth/filters"

Package filters implements an ethereum filtering system for block, transactions and log events.

Index

Package Files

api.go filter.go filter_system.go

type Backend Uses

type Backend interface {
    ChainDb() ethdb.Database
    HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)
    HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error)
    GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error)
    GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error)

    SubscribeNewTxsEvent(chan<- core.NewTxsEvent) event.Subscription
    SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription
    SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription
    SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription
    SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription

    BloomStatus() (uint64, uint64)
    ServiceFilter(ctx context.Context, session *bloombits.MatcherSession)
}

type EventSystem Uses

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

EventSystem creates subscriptions, processes events and broadcasts them to the subscription which match the subscription criteria.

func NewEventSystem Uses

func NewEventSystem(backend Backend, lightMode bool) *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 Uses

func (es *EventSystem) SubscribeLogs(crit ethereum.FilterQuery, logs chan []*types.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 Uses

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

SubscribeNewHeads creates a subscription that writes the header of a block that is imported in the chain.

func (*EventSystem) SubscribePendingTxs Uses

func (es *EventSystem) SubscribePendingTxs(hashes chan []common.Hash) *Subscription

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

type Filter Uses

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

Filter can be used to retrieve and filter logs.

func NewBlockFilter Uses

func NewBlockFilter(backend Backend, block common.Hash, addresses []common.Address, topics [][]common.Hash) *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 Uses

func NewRangeFilter(backend Backend, 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 Uses

func (f *Filter) Logs(ctx context.Context) ([]*types.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 FilterCriteria Uses

type FilterCriteria ethereum.FilterQuery

FilterCriteria represents a request to create a new filter. Same as ethereum.FilterQuery but with UnmarshalJSON() method.

func (*FilterCriteria) UnmarshalJSON Uses

func (args *FilterCriteria) UnmarshalJSON(data []byte) error

UnmarshalJSON sets *args fields with given data.

type PublicFilterAPI Uses

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 als blocks, transactions and logs.

func NewPublicFilterAPI Uses

func NewPublicFilterAPI(backend Backend, lightMode bool) *PublicFilterAPI

NewPublicFilterAPI returns a new PublicFilterAPI instance.

func (*PublicFilterAPI) GetFilterChanges Uses

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 Uses

func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*types.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 Uses

func (api *PublicFilterAPI) GetLogs(ctx context.Context, crit FilterCriteria) ([]*types.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 Uses

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

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

func (*PublicFilterAPI) NewBlockFilter Uses

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 Uses

func (api *PublicFilterAPI) NewFilter(crit 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 Uses

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 Uses

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

NewPendingTransactionFilter creates a filter that fetches pending transaction hashes 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.

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

func (*PublicFilterAPI) NewPendingTransactions Uses

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

NewPendingTransactions creates a subscription that is triggered each time a transaction enters the transaction pool and was signed from one of the transactions this nodes manages.

func (*PublicFilterAPI) UninstallFilter Uses

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 Uses

type Subscription struct {
    ID rpc.ID
    // contains filtered or unexported fields
}

Subscription is created when the client registers itself for a particular event.

func (*Subscription) Err Uses

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

Err returns a channel that is closed when unsubscribed.

func (*Subscription) Unsubscribe Uses

func (sub *Subscription) Unsubscribe()

Unsubscribe uninstalls the subscription from the event broadcast loop.

type Type Uses

type Type byte

Type determines the kind of filter and is used to put the filter in to the correct bucket when added.

const (
    // UnknownSubscription indicates an unknown subscription type
    UnknownSubscription Type = iota
    // LogsSubscription queries for new or removed (chain reorg) logs
    LogsSubscription
    // PendingLogsSubscription queries for logs in pending blocks
    PendingLogsSubscription
    // MinedAndPendingLogsSubscription queries for logs in mined and pending blocks.
    MinedAndPendingLogsSubscription
    // PendingTransactionsSubscription queries tx hashes for pending
    // transactions entering the pending state
    PendingTransactionsSubscription
    // BlocksSubscription queries hashes for blocks that are imported
    BlocksSubscription
    // LastSubscription keeps track of the last index
    LastIndexSubscription
)

Package filters imports 18 packages (graph) and is imported by 466 packages. Updated 2020-04-15. Refresh now. Tools for package owners.