def create_log_filter(self,
from_block=None,
to_block=None,
address=None,
topics=None):
self.validator.validate_inbound_filter_params(
from_block=from_block,
to_block=to_block,
address=address,
topics=topics,
)
(
raw_from_block,
raw_to_block,
raw_address,
raw_topics,
) = self.normalizer.normalize_inbound_filter_params(
from_block=from_block,
to_block=to_block,
address=address,
topics=topics,
)
raw_filter_id = next(self._filter_counter)
raw_filter_params = {
'from_block': raw_from_block,
'to_block': raw_to_block,
'addresses': raw_address,
'topics': raw_topics,
}
filter_fn = partial(check_if_log_matches, **raw_filter_params)
new_filter = Filter(
filter_params=raw_filter_params,
filter_fn=filter_fn,
)
self._log_filters[raw_filter_id] = new_filter
if is_integer(raw_from_block):
if is_integer(raw_to_block):
upper_bound = raw_to_block + 1
else:
upper_bound = self.get_block_by_number('pending')['number']
for block_number in range(raw_from_block, upper_bound):
block = self.get_block_by_number(block_number)
self._add_log_entries_to_filter(block, new_filter)
filter_id = self.normalizer.normalize_outbound_filter_id(raw_filter_id)
return filter_id
def get_logs(self, from_block=None, to_block=None, address=None, topics=None):
self.validator.validate_inbound_filter_params(
from_block=from_block,
to_block=to_block,
address=address,
topics=topics,
)
(
raw_from_block,
raw_to_block,
raw_address,
raw_topics,
) = self.normalizer.normalize_inbound_filter_params(
from_block=from_block,
to_block=to_block,
address=address,
topics=topics,
)
# Setup the filter object
raw_filter_params = {
'from_block': raw_from_block,
'to_block': raw_to_block,
'addresses': raw_address,
'topics': raw_topics,
}
filter_fn = partial(
check_if_log_matches,
**raw_filter_params,
)
log_filter = Filter(
filter_params=raw_filter_params,
filter_fn=filter_fn,
)
# Set from/to block defaults
if raw_from_block is None:
raw_from_block = 'latest'
if raw_to_block is None:
raw_to_block = 'latest'
# Determine lower bound for block range.
if isinstance(raw_from_block, int):
lower_bound = raw_from_block
else:
lower_bound = self.get_block_by_number(raw_from_block)['number']
# Determine upper bound for block range.
if isinstance(raw_to_block, int):
upper_bound = raw_to_block
else:
upper_bound = self.get_block_by_number(raw_to_block)['number']
# Enumerate the blocks in the block range to find all log entries which match.
for block_number in range(lower_bound, upper_bound + 1):
block = self.get_block_by_number(block_number)
for transaction_hash in block['transactions']:
receipt = self.get_transaction_receipt(transaction_hash)
for log_entry in receipt['logs']:
raw_log_entry = self.normalizer.normalize_inbound_log_entry(log_entry)
log_filter.add(raw_log_entry)
# Return the matching log entries
for item in log_filter.get_all():
yield self.normalizer.normalize_outbound_log_entry(item)
def create_pending_transaction_filter(self):
raw_filter_id = next(self._filter_counter)
self._pending_transaction_filters[raw_filter_id] = Filter(filter_params=None)
filter_id = self.normalizer.normalize_outbound_filter_id(raw_filter_id)
return filter_id
def create_block_filter(self):
raw_filter_id = next(self._filter_counter)
self._block_filters[raw_filter_id] = Filter(filter_params=None)
filter_id = self.normalizer.normalize_outbound_filter_id(raw_filter_id)
return filter_id
def f():
_f = Filter(None)
return _f