2016-04-14 09:18:24 -07:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 09:48:40 -07:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-06 17:54:22 -07:00
|
|
|
//
|
2015-07-23 09:35:11 -07:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-06 17:54:22 -07:00
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2015-07-22 09:48:40 -07:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-06 17:54:22 -07:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2015-08-30 01:04:59 -07:00
|
|
|
package filters
|
2014-08-11 07:23:17 -07:00
|
|
|
|
|
|
|
import (
|
2017-03-22 10:20:33 -07:00
|
|
|
"context"
|
2016-11-28 05:59:06 -08:00
|
|
|
"math/big"
|
2017-08-18 12:52:20 -07:00
|
|
|
"time"
|
2016-11-28 05:59:06 -08:00
|
|
|
|
2015-03-17 03:19:23 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2015-08-30 01:04:59 -07:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2017-08-18 12:52:20 -07:00
|
|
|
"github.com/ethereum/go-ethereum/core/bloombits"
|
2015-03-26 04:06:14 -07:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2015-08-31 08:09:50 -07:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2016-01-13 10:35:48 -08:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2014-08-11 07:23:17 -07:00
|
|
|
)
|
|
|
|
|
2016-01-13 10:35:48 -08:00
|
|
|
type Backend interface {
|
|
|
|
ChainDb() ethdb.Database
|
|
|
|
EventMux() *event.TypeMux
|
|
|
|
HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)
|
|
|
|
GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error)
|
2017-08-29 04:13:11 -07:00
|
|
|
|
2017-08-18 03:58:36 -07:00
|
|
|
SubscribeTxPreEvent(chan<- core.TxPreEvent) event.Subscription
|
|
|
|
SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription
|
|
|
|
SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription
|
|
|
|
SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription
|
2017-08-18 12:52:20 -07:00
|
|
|
|
2017-08-29 04:13:11 -07:00
|
|
|
BloomStatus() (uint64, uint64)
|
|
|
|
ServiceFilter(ctx context.Context, session *bloombits.MatcherSession)
|
2016-01-13 10:35:48 -08:00
|
|
|
}
|
|
|
|
|
2016-12-04 10:07:24 -08:00
|
|
|
// Filter can be used to retrieve and filter logs.
|
2014-08-11 07:23:17 -07:00
|
|
|
type Filter struct {
|
2017-08-29 04:13:11 -07:00
|
|
|
backend Backend
|
2016-01-13 10:35:48 -08:00
|
|
|
|
2015-10-12 08:58:51 -07:00
|
|
|
db ethdb.Database
|
|
|
|
begin, end int64
|
|
|
|
addresses []common.Address
|
|
|
|
topics [][]common.Hash
|
2017-08-18 12:52:20 -07:00
|
|
|
|
2017-08-29 04:13:11 -07:00
|
|
|
matcher *bloombits.Matcher
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
|
|
|
|
2016-07-27 08:47:46 -07:00
|
|
|
// New creates a new filter which uses a bloom filter on blocks to figure out whether
|
|
|
|
// a particular block is interesting or not.
|
2017-08-18 12:52:20 -07:00
|
|
|
func New(backend Backend, begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter {
|
2017-09-27 03:14:52 -07:00
|
|
|
// Flatten the address and topic filter clauses into a single bloombits filter
|
|
|
|
// system. Since the bloombits are not positional, nil topics are permitted,
|
|
|
|
// which get flattened into a nil byte slice.
|
2017-09-05 17:33:10 -07:00
|
|
|
var filters [][][]byte
|
|
|
|
if len(addresses) > 0 {
|
|
|
|
filter := make([][]byte, len(addresses))
|
|
|
|
for i, address := range addresses {
|
|
|
|
filter[i] = address.Bytes()
|
|
|
|
}
|
|
|
|
filters = append(filters, filter)
|
|
|
|
}
|
|
|
|
for _, topicList := range topics {
|
|
|
|
filter := make([][]byte, len(topicList))
|
|
|
|
for i, topic := range topicList {
|
|
|
|
filter[i] = topic.Bytes()
|
|
|
|
}
|
|
|
|
filters = append(filters, filter)
|
|
|
|
}
|
|
|
|
// Assemble and return the filter
|
2017-08-29 04:13:11 -07:00
|
|
|
size, _ := backend.BloomStatus()
|
|
|
|
|
2016-01-13 10:35:48 -08:00
|
|
|
return &Filter{
|
2017-08-29 04:13:11 -07:00
|
|
|
backend: backend,
|
|
|
|
begin: begin,
|
|
|
|
end: end,
|
|
|
|
addresses: addresses,
|
|
|
|
topics: topics,
|
|
|
|
db: backend.ChainDb(),
|
2017-09-05 17:33:10 -07:00
|
|
|
matcher: bloombits.NewMatcher(size, filters),
|
2016-01-13 10:35:48 -08:00
|
|
|
}
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
|
|
|
|
2017-08-29 04:13:11 -07:00
|
|
|
// Logs searches the blockchain for matching log entries, returning all from the
|
|
|
|
// first block that contains matches, updating the start of the filter accordingly.
|
|
|
|
func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) {
|
|
|
|
// Figure out the limits of the filter range
|
|
|
|
header, _ := f.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
|
|
|
|
if header == nil {
|
2016-01-13 10:35:48 -08:00
|
|
|
return nil, nil
|
2016-07-26 07:37:04 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
head := header.Number.Uint64()
|
2016-07-27 08:47:46 -07:00
|
|
|
|
|
|
|
if f.begin == -1 {
|
2017-08-29 04:13:11 -07:00
|
|
|
f.begin = int64(head)
|
2014-09-26 04:32:54 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
end := uint64(f.end)
|
2016-07-27 08:47:46 -07:00
|
|
|
if f.end == -1 {
|
2017-08-29 04:13:11 -07:00
|
|
|
end = head
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
// Gather all indexed logs, and finish with non indexed ones
|
|
|
|
var (
|
|
|
|
logs []*types.Log
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
size, sections := f.backend.BloomStatus()
|
|
|
|
if indexed := sections * size; indexed > uint64(f.begin) {
|
|
|
|
if indexed > end {
|
|
|
|
logs, err = f.indexedLogs(ctx, end)
|
|
|
|
} else {
|
|
|
|
logs, err = f.indexedLogs(ctx, indexed-1)
|
|
|
|
}
|
|
|
|
if err != nil {
|
2016-12-19 17:00:03 -08:00
|
|
|
return logs, err
|
|
|
|
}
|
2015-08-31 08:09:50 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
rest, err := f.unindexedLogs(ctx, end)
|
|
|
|
logs = append(logs, rest...)
|
|
|
|
return logs, err
|
2015-10-12 08:58:51 -07:00
|
|
|
}
|
2015-06-09 04:22:16 -07:00
|
|
|
|
2017-08-29 04:13:11 -07:00
|
|
|
// indexedLogs returns the logs matching the filter criteria based on the bloom
|
|
|
|
// bits indexed available locally or via the network.
|
|
|
|
func (f *Filter) indexedLogs(ctx context.Context, end uint64) ([]*types.Log, error) {
|
|
|
|
// Create a matcher session and request servicing from the backend
|
|
|
|
matches := make(chan uint64, 64)
|
|
|
|
|
|
|
|
session, err := f.matcher.Start(uint64(f.begin), end, matches)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2017-08-18 12:52:20 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
defer session.Close(time.Second)
|
|
|
|
|
|
|
|
f.backend.ServiceFilter(ctx, session)
|
|
|
|
|
|
|
|
// Iterate over the matches until exhausted or context closed
|
|
|
|
var logs []*types.Log
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case number, ok := <-matches:
|
|
|
|
// Abort if all matches have been fulfilled
|
|
|
|
if !ok {
|
|
|
|
f.begin = int64(end) + 1
|
|
|
|
return logs, nil
|
|
|
|
}
|
|
|
|
// Retrieve the suggested block and pull any truly matching logs
|
|
|
|
header, err := f.backend.HeaderByNumber(ctx, rpc.BlockNumber(number))
|
|
|
|
if header == nil || err != nil {
|
|
|
|
return logs, err
|
|
|
|
}
|
|
|
|
found, err := f.checkMatches(ctx, header)
|
|
|
|
if err != nil {
|
|
|
|
return logs, err
|
|
|
|
}
|
|
|
|
logs = append(logs, found...)
|
|
|
|
|
|
|
|
case <-ctx.Done():
|
|
|
|
return logs, ctx.Err()
|
|
|
|
}
|
2017-08-18 12:52:20 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-29 04:13:11 -07:00
|
|
|
// indexedLogs returns the logs matching the filter criteria based on raw block
|
|
|
|
// iteration and bloom matching.
|
|
|
|
func (f *Filter) unindexedLogs(ctx context.Context, end uint64) ([]*types.Log, error) {
|
|
|
|
var logs []*types.Log
|
|
|
|
|
|
|
|
for ; f.begin <= int64(end); f.begin++ {
|
|
|
|
header, err := f.backend.HeaderByNumber(ctx, rpc.BlockNumber(f.begin))
|
|
|
|
if header == nil || err != nil {
|
|
|
|
return logs, err
|
|
|
|
}
|
|
|
|
if bloomFilter(header.Bloom, f.addresses, f.topics) {
|
|
|
|
found, err := f.checkMatches(ctx, header)
|
|
|
|
if err != nil {
|
|
|
|
return logs, err
|
2015-10-12 08:58:51 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
logs = append(logs, found...)
|
|
|
|
}
|
2015-10-12 08:58:51 -07:00
|
|
|
}
|
2017-08-29 04:13:11 -07:00
|
|
|
return logs, nil
|
2017-08-18 12:52:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// checkMatches checks if the receipts belonging to the given header contain any log events that
|
|
|
|
// match the filter criteria. This function is called when the bloom filter signals a potential match.
|
|
|
|
func (f *Filter) checkMatches(ctx context.Context, header *types.Header) (logs []*types.Log, err error) {
|
|
|
|
// Get the logs of the block
|
|
|
|
receipts, err := f.backend.GetReceipts(ctx, header.Hash())
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
var unfiltered []*types.Log
|
|
|
|
for _, receipt := range receipts {
|
|
|
|
unfiltered = append(unfiltered, ([]*types.Log)(receipt.Logs)...)
|
|
|
|
}
|
|
|
|
logs = filterLogs(unfiltered, nil, nil, f.addresses, f.topics)
|
|
|
|
if len(logs) > 0 {
|
|
|
|
return logs, nil
|
|
|
|
}
|
|
|
|
return nil, nil
|
2015-10-12 08:58:51 -07:00
|
|
|
}
|
|
|
|
|
2015-03-17 03:19:23 -07:00
|
|
|
func includes(addresses []common.Address, a common.Address) bool {
|
2014-08-15 07:19:10 -07:00
|
|
|
for _, addr := range addresses {
|
2015-09-01 00:19:45 -07:00
|
|
|
if addr == a {
|
|
|
|
return true
|
2014-08-15 07:19:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-01 00:19:45 -07:00
|
|
|
return false
|
2014-08-15 07:19:10 -07:00
|
|
|
}
|
|
|
|
|
2016-12-04 10:07:24 -08:00
|
|
|
// filterLogs creates a slice of logs matching the given criteria.
|
2017-01-05 05:03:50 -08:00
|
|
|
func filterLogs(logs []*types.Log, fromBlock, toBlock *big.Int, addresses []common.Address, topics [][]common.Hash) []*types.Log {
|
|
|
|
var ret []*types.Log
|
2015-02-04 17:28:54 -08:00
|
|
|
Logs:
|
2015-01-28 01:23:18 -08:00
|
|
|
for _, log := range logs {
|
2016-12-04 10:07:24 -08:00
|
|
|
if fromBlock != nil && fromBlock.Int64() >= 0 && fromBlock.Uint64() > log.BlockNumber {
|
2016-11-28 05:59:06 -08:00
|
|
|
continue
|
|
|
|
}
|
2016-12-04 10:07:24 -08:00
|
|
|
if toBlock != nil && toBlock.Int64() >= 0 && toBlock.Uint64() < log.BlockNumber {
|
2016-11-28 05:59:06 -08:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2016-07-27 08:47:46 -07:00
|
|
|
if len(addresses) > 0 && !includes(addresses, log.Address) {
|
2014-08-14 15:24:37 -07:00
|
|
|
continue
|
|
|
|
}
|
2016-07-27 08:47:46 -07:00
|
|
|
// If the to filtered topics is greater than the amount of topics in logs, skip.
|
|
|
|
if len(topics) > len(log.Topics) {
|
2015-04-24 04:36:34 -07:00
|
|
|
continue Logs
|
|
|
|
}
|
2016-07-27 08:47:46 -07:00
|
|
|
for i, topics := range topics {
|
2017-09-27 03:14:52 -07:00
|
|
|
match := len(topics) == 0 // empty rule set == wildcard
|
2015-03-01 10:08:26 -08:00
|
|
|
for _, topic := range topics {
|
2017-09-27 03:14:52 -07:00
|
|
|
if log.Topics[i] == topic {
|
2015-03-01 10:08:26 -08:00
|
|
|
match = true
|
2015-04-24 04:36:34 -07:00
|
|
|
break
|
2015-03-01 10:08:26 -08:00
|
|
|
}
|
2014-08-15 07:19:10 -07:00
|
|
|
}
|
2015-04-24 04:36:34 -07:00
|
|
|
if !match {
|
|
|
|
continue Logs
|
|
|
|
}
|
2014-08-15 07:19:10 -07:00
|
|
|
}
|
2015-01-28 01:23:18 -08:00
|
|
|
ret = append(ret, log)
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
2015-01-28 01:23:18 -08:00
|
|
|
return ret
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
|
|
|
|
2016-10-13 20:51:29 -07:00
|
|
|
func bloomFilter(bloom types.Bloom, addresses []common.Address, topics [][]common.Hash) bool {
|
|
|
|
if len(addresses) > 0 {
|
2015-02-17 07:12:55 -08:00
|
|
|
var included bool
|
2016-10-13 20:51:29 -07:00
|
|
|
for _, addr := range addresses {
|
|
|
|
if types.BloomLookup(bloom, addr) {
|
2015-02-17 07:12:55 -08:00
|
|
|
included = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !included {
|
|
|
|
return false
|
|
|
|
}
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
|
|
|
|
2016-10-13 20:51:29 -07:00
|
|
|
for _, sub := range topics {
|
2017-09-27 03:14:52 -07:00
|
|
|
included := len(sub) == 0 // empty rule set == wildcard
|
2015-03-01 10:08:26 -08:00
|
|
|
for _, topic := range sub {
|
2017-09-27 03:14:52 -07:00
|
|
|
if types.BloomLookup(bloom, topic) {
|
2015-03-01 10:08:26 -08:00
|
|
|
included = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !included {
|
2015-01-28 01:23:18 -08:00
|
|
|
return false
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|
|
|
|
}
|
2015-01-28 01:23:18 -08:00
|
|
|
return true
|
2014-08-11 07:23:17 -07:00
|
|
|
}
|