def get_all_pools(self):
bfactory = BFactory(self._addresses.get(BFactory.CONTRACT_NAME))
event_name = 'BPoolRegistered'
event = getattr(bfactory.events, event_name)
latest_block = self._web3.eth.blockNumber
_from = self.bfactory_block
chunk = 10000
pools = []
while _from < latest_block:
event_filter = EventFilter(event_name,
event,
None,
from_block=_from,
to_block=_from + chunk - 1)
try:
logs = event_filter.get_all_entries(max_tries=10)
logs = sorted(logs, key=lambda l: l.blockNumber)
pools.extend([l.args.bpoolAddress for l in logs])
except ValueError as e:
logger.error(
f'get_all_pools BFactory {bfactory.address}, fromBlock {_from}, toBlock{_from+chunk-1}: {e}'
)
_from += chunk
return pools
def make_event_filter(self):
"""Create a new event filter."""
event_filter = EventFilter(self.event_name,
self.event,
self.filters,
from_block=self.from_block,
to_block=self.to_block)
event_filter.set_poll_interval(0.5)
return event_filter
def get_event_logs(
self, event_name, filter_args=None, from_block=0, to_block="latest"
):
event = getattr(self.events, event_name)
filter_params = filter_args or {}
event_filter = EventFilter(
event_name, event, filter_params, from_block=from_block, to_block=to_block
)
logs = event_filter.get_all_entries(max_tries=10)
if not logs:
return []
return logs
def get_token_minter(self, token_address):
event = getattr(self.events, "TokenRegistered")
# TODO: use the filter on tokenAddress when it is set as indexed in the contract event.
filter_params = {} # {'tokenAddress': token_address}
event_filter = EventFilter(
"TokenRegistered", event, filter_params, from_block=0, to_block="latest"
)
logs = event_filter.get_all_entries(max_tries=10)
for log in logs:
# assert log.args.tokenAddress == token_address
if log.args.tokenAddress == token_address:
return log.args.registeredBy
return None
def make_event_filter(self) -> EventFilter:
"""Create a new event filter."""
event_filter = EventFilter(
self.event(),
argument_filters=self.filters,
from_block=self.from_block,
to_block=self.to_block,
)
return event_filter
def get_transfer_event(self, block_number, sender, receiver):
event = getattr(self.events, 'Transfer')
filter_params = {'from': sender, 'to': receiver}
event_filter = EventFilter('Transfer',
event,
filter_params,
from_block=block_number - 1,
to_block=block_number + 10)
logs = event_filter.get_all_entries(max_tries=10)
if not logs:
return None
if len(logs) > 1:
raise AssertionError(
f'Expected a single transfer event at '
f'block {block_number}, but found {len(logs)} events.')
return logs[0]
def get_transfer_event(self, block_number, sender, receiver):
event = getattr(self.events, "Transfer")
filter_params = {"from": sender, "to": receiver}
event_filter = EventFilter(
"Transfer",
event,
filter_params,
from_block=block_number - 1,
to_block=block_number + 10,
)
logs = event_filter.get_all_entries(max_tries=10)
if not logs:
return None
if len(logs) > 1:
raise AssertionError(
f"Expected a single transfer event at "
f"block {block_number}, but found {len(logs)} events.")
return logs[0]
def watch_one_event(
event_filter: EventFilter,
callback: Callable,
timeout_callback: Optional[Callable],
timeout: int,
args: list,
start_time: Optional[int] = None,
) -> None:
"""
Start to watch one event.
:param event_filter:
:param callback:
:param timeout_callback:
:param timeout:
:param args:
:param start_time:
:return:
"""
if timeout and not start_time:
start_time = int(datetime.now().timestamp())
if not args:
args = []
while True:
try:
events = event_filter.get_all_entries()
if events:
callback(events[0], *args)
return
except (ValueError, Exception) as err:
# ignore error, but log it
logger.debug(f"Got error grabbing keeper events: {str(err)}")
time.sleep(0.5)
if timeout:
elapsed = int(datetime.now().timestamp()) - start_time
if elapsed > timeout:
if timeout_callback is not None:
timeout_callback(*args)
elif callback is not None:
callback(None, *args)
break
def test_transfer_event_filter(alice_ocean, alice_wallet, alice_address,
bob_address):
token = alice_ocean.create_data_token("DataToken1",
"DT1",
from_wallet=alice_wallet,
blob="foo_blob")
token.mint(alice_address, to_base_18(100.0), from_wallet=alice_wallet)
token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet)
token.transfer(bob_address, to_base_18(5.0), from_wallet=alice_wallet)
block = alice_ocean.web3.eth.blockNumber
event = getattr(token.events, "Transfer")
event_filter = EventFilter("Transfer", event, None, block, block)
assert event_filter.filter_id
event_filter.uninstall()
event_filter.recreate_filter()
assert event_filter.get_new_entries() == []
def test_transfer_event_filter(alice_ocean, alice_wallet, alice_address,
bob_address):
token = alice_ocean.create_data_token("DataToken1",
"DT1",
from_wallet=alice_wallet,
blob="foo_blob")
token.mint(alice_address, to_wei(100), from_wallet=alice_wallet)
token.approve(bob_address, to_wei(1), from_wallet=alice_wallet)
token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet)
block = alice_ocean.web3.eth.block_number
event_filter = EventFilter(token.events.Transfer(),
from_block=block,
to_block=block)
assert event_filter.filter_id, "Event filter ID is None."
event_filter.uninstall()
event_filter.recreate_filter()
assert (event_filter.get_new_entries() == []
), "There are new entries for EventFilter."
