def get_token_network_events(self,
token_address,
from_block,
to_block='latest'):
if not isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_token_network_events'
)
channel_manager_address = self.raiden.default_registry.manager_address_by_token(
token_address)
returned_events = get_all_channel_manager_events(
self.raiden.chain,
channel_manager_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
raiden_events = self.raiden.wal.storage.get_events_by_block(
from_block=from_block,
to_block=to_block,
)
# Here choose which raiden internal events we want to expose to the end user
for block_number, event in raiden_events:
if isinstance(event, EVENTS_EXTERNALLY_VISIBLE):
new_event = {
'block_number': block_number,
'event': type(event).__name__,
}
new_event.update(event.__dict__)
returned_events.append(new_event)
return returned_events
def get_token_network_events(self, token_address, from_block, to_block):
if not isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_token_network_events'
)
graph = self.raiden.token_to_channelgraph[token_address]
return get_all_channel_manager_events(
self.raiden.chain,
graph.channelmanager_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
def get_token_network_events(self, token_address, from_block, to_block):
if not isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_token_network_events'
)
graph = self.raiden.token_to_channelgraph[token_address]
return get_all_channel_manager_events(
self.raiden.chain,
graph.channelmanager_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
def get_token_network_events(self, token_address, from_block, to_block):
if not isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_token_network_events'
)
try:
graph = self.raiden.token_to_channelgraph[token_address]
return get_all_channel_manager_events(
self.raiden.chain,
graph.channelmanager_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
except KeyError:
raise UnknownTokenAddress('The token address is not registered.')
def test_query_events(raiden_chain, token_addresses, deposit, settle_timeout,
events_poll_timeout):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0),
registry_address,
token_address,
)
manager0 = app0.raiden.default_registry.manager_by_token(token_address)
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
events = get_all_registry_events(
app0.raiden.chain,
registry_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert events[0]['event'] == EVENT_TOKEN_ADDED
assert event_dicts_are_equal(
events[0]['args'], {
'registry_address': to_normalized_address(registry_address),
'channel_manager_address': to_normalized_address(manager0.address),
'token_address': to_normalized_address(token_address),
'block_number': 'ignore',
})
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
channel_address = RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
gevent.sleep(events_poll_timeout * 2)
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert events[0]['event'] == EVENT_CHANNEL_NEW
assert event_dicts_are_equal(
events[0]['args'], {
'registry_address': to_normalized_address(registry_address),
'settle_timeout': settle_timeout,
'netting_channel': to_normalized_address(channel_address),
'participant1': to_normalized_address(app0.raiden.address),
'participant2': to_normalized_address(app1.raiden.address),
'block_number': 'ignore',
})
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
# channel is created but not opened and without funds
channelcount1 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
assert channelcount0 + 1 == channelcount1
assert_synched_channel_state(
token_network_identifier,
app0,
0,
[],
app1,
0,
[],
)
RaidenAPI(app0.raiden).set_total_channel_deposit(
registry_address,
token_address,
app1.raiden.address,
deposit,
)
gevent.sleep(events_poll_timeout * 2)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
channel_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
channel_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)],
)
assert len(all_netting_channel_events) == 1
assert len(events) == 1
assert events[0]['event'] == EVENT_CHANNEL_NEW_BALANCE
new_balance_event = {
'registry_address': to_normalized_address(registry_address),
'token_address': to_normalized_address(token_address),
'participant': to_normalized_address(app0.raiden.address),
'balance': deposit,
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1]['args'],
new_balance_event)
assert event_dicts_are_equal(events[0]['args'], new_balance_event)
RaidenAPI(app0.raiden).channel_close(
registry_address,
token_address,
app1.raiden.address,
)
gevent.sleep(events_poll_timeout * 2)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=channel_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
channel_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)],
)
assert len(all_netting_channel_events) == 2
assert len(events) == 1
assert events[0]['event'] == EVENT_CHANNEL_CLOSED
closed_event = {
'registry_address': to_normalized_address(registry_address),
'closing_address': to_normalized_address(app0.raiden.address),
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1]['args'],
closed_event)
assert event_dicts_are_equal(events[0]['args'], closed_event)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 5
wait_until_block(app0.raiden.chain, settle_expiration)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=channel_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
channel_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)],
)
assert len(all_netting_channel_events) == 3
assert len(events) == 1
assert events[0]['event'] == EVENT_CHANNEL_SETTLED
settled_event = {
'registry_address': to_normalized_address(registry_address),
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1]['args'],
settled_event)
assert event_dicts_are_equal(events[0]['args'], settled_event)
def test_query_events(raiden_chain, deposit, settle_timeout,
events_poll_timeout):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = app0.raiden.default_registry.token_addresses()[0]
assert len(app0.raiden.token_to_channelgraph[token_address].
address_to_channel) == 0
assert len(app1.raiden.token_to_channelgraph[token_address].
address_to_channel) == 0
token0 = app0.raiden.chain.token(token_address)
manager0 = app0.raiden.default_registry.manager_by_token(token_address)
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(
events[0], {
'_event_type': 'TokenAdded',
'channel_manager_address': address_encoder(manager0.address),
'token_address': address_encoder(token_address),
'block_number': 'ignore',
})
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netcontract_address = manager0.new_netting_channel(
app0.raiden.address,
app1.raiden.address,
settle_timeout,
)
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(
events[0], {
'_event_type': 'ChannelNew',
'settle_timeout': settle_timeout,
'netting_channel': address_encoder(netcontract_address),
'participant1': address_encoder(app0.raiden.address),
'participant2': address_encoder(app1.raiden.address),
'block_number': 'ignore',
})
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address)
gevent.sleep(events_poll_timeout * 2)
# channel is created but not opened and without funds
assert len(app0.raiden.token_to_channelgraph[token_address].
address_to_channel) == 1
assert len(app1.raiden.token_to_channelgraph[token_address].
address_to_channel) == 1
channel0 = app0.raiden.token_to_channelgraph[
token_address].address_to_channel.values()[0]
channel1 = app1.raiden.token_to_channelgraph[
token_address].address_to_channel.values()[0]
assert_synched_channels(
channel0,
0,
[],
channel1,
0,
[],
)
token0.approve(netcontract_address, deposit)
netting_channel0.deposit(deposit)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)],
)
assert len(all_netting_channel_events) == 1
assert len(events) == 1
new_balance_event = {
'_event_type': 'ChannelNewBalance',
'token_address': address_encoder(token_address),
'participant': address_encoder(app0.raiden.address),
'balance': deposit,
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1],
new_balance_event)
assert event_dicts_are_equal(events[0], new_balance_event)
channel0.external_state.close(None)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)],
)
assert len(all_netting_channel_events) == 2
assert len(events) == 1
closed_event = {
'_event_type': 'ChannelClosed',
'closing_address': address_encoder(app0.raiden.address),
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event)
assert event_dicts_are_equal(events[0], closed_event)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1
wait_until_block(app0.raiden.chain, settle_expiration)
channel1.external_state.settle()
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)],
)
assert len(all_netting_channel_events) == 3
assert len(events) == 1
settled_event = {
'_event_type': 'ChannelSettled',
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event)
assert event_dicts_are_equal(events[0], settled_event)
def test_query_events(raiden_chain, deposit, settle_timeout, events_poll_timeout):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = app0.raiden.default_registry.token_addresses()[0]
assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 0
assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 0
token0 = app0.raiden.chain.token(token_address)
manager0 = app0.raiden.default_registry.manager_by_token(token_address)
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(events[0], {
'_event_type': b'TokenAdded',
'channel_manager_address': address_encoder(manager0.address),
'token_address': address_encoder(token_address),
'block_number': 'ignore',
})
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netcontract_address = manager0.new_netting_channel(
app1.raiden.address,
settle_timeout,
)
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(events[0], {
'_event_type': b'ChannelNew',
'settle_timeout': settle_timeout,
'netting_channel': address_encoder(netcontract_address),
'participant1': address_encoder(app0.raiden.address),
'participant2': address_encoder(app1.raiden.address),
'block_number': 'ignore',
})
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address)
gevent.sleep(events_poll_timeout * 2)
# channel is created but not opened and without funds
assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 1
assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 1
channel0 = list(app0.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501
channel1 = list(app1.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501
assert_synched_channels(
channel0, 0, [],
channel1, 0, [],
)
token0.approve(netcontract_address, deposit)
netting_channel0.deposit(deposit)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)],
)
assert len(all_netting_channel_events) == 1
assert len(events) == 1
new_balance_event = {
'_event_type': b'ChannelNewBalance',
'token_address': address_encoder(token_address),
'participant': address_encoder(app0.raiden.address),
'balance': deposit,
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], new_balance_event)
assert event_dicts_are_equal(events[0], new_balance_event)
channel0.external_state.close(None)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)],
)
assert len(all_netting_channel_events) == 2
assert len(events) == 1
closed_event = {
'_event_type': b'ChannelClosed',
'closing_address': address_encoder(app0.raiden.address),
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event)
assert event_dicts_are_equal(events[0], closed_event)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1
wait_until_block(app0.raiden.chain, settle_expiration)
channel1.external_state.settle()
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)],
)
assert len(all_netting_channel_events) == 3
assert len(events) == 1
settled_event = {
'_event_type': b'ChannelSettled',
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event)
assert event_dicts_are_equal(events[0], settled_event)
