def get_network_events(self, registry_address, from_block, to_block):
return get_token_network_registry_events(
self.raiden.chain,
registry_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
def get_network_events(self, registry_address, from_block, to_block):
return sorted(get_token_network_registry_events(
self.raiden.chain,
registry_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
), key=lambda evt: evt.get('block_number'), reverse=True)
def get_network_events(self, registry_address, from_block, to_block):
return sorted(get_token_network_registry_events(
self.raiden.chain,
registry_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
),
key=lambda evt: evt.get('block_number'),
reverse=True)
def get_network_events(
self, registry_address: typing.PaymentNetworkID,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
return sorted(get_token_network_registry_events(
self.raiden.chain,
registry_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
), key=lambda evt: evt.get('block_number'), reverse=True)
def get_blockchain_events_network(
self,
registry_address: PaymentNetworkID,
from_block: BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: BlockSpecification = "latest",
):
events = blockchain_events.get_token_network_registry_events(
chain=self.raiden.chain,
token_network_registry_address=registry_address,
contract_manager=self.raiden.contract_manager,
events=blockchain_events.ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
return sorted(events, key=lambda evt: evt.get("block_number"), reverse=True)
def get_blockchain_events_network(
self,
registry_address: typing.PaymentNetworkID,
from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: typing.BlockSpecification = 'latest',
):
events = blockchain_events.get_token_network_registry_events(
chain=self.raiden.chain,
token_network_registry_address=registry_address,
contract_manager=self.raiden.contract_manager,
events=blockchain_events.ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
return sorted(
events,
key=lambda evt: evt.get('block_number'),
reverse=True,
)
def get_blockchain_events_network(
self,
registry_address: typing.PaymentNetworkID,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
events = blockchain_events.get_token_network_registry_events(
chain=self.raiden.chain,
token_network_registry_address=registry_address,
contract_manager=self.raiden.contract_manager,
events=blockchain_events.ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
return sorted(
events,
key=lambda evt: evt.get('block_number'),
reverse=True,
)
def test_query_events(raiden_chain, token_addresses, deposit, settle_timeout,
retry_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.token_network_by_token(
token_address)
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
events = get_token_network_registry_events(
app0.raiden.chain,
registry_address,
events=ALL_EVENTS,
)
assert must_have_event(
events,
{
'event': EVENT_TOKEN_NETWORK_CREATED,
'args': {
'token_network_address': to_checksum_address(manager0.address),
'token_address': to_checksum_address(token_address),
},
},
)
events = get_token_network_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
events = get_token_network_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
)
_event = must_have_event(
events,
{
'event': EVENT_CHANNEL_OPENED,
'args': {
'participant1': to_checksum_address(app0.raiden.address),
'participant2': to_checksum_address(app1.raiden.address),
'settle_timeout': settle_timeout,
},
},
)
assert _event
channel_id = _event['args']['channel_identifier']
events = get_token_network_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,
)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
token_network_identifier,
channel_id,
)
deposit_events = get_netting_channel_deposit_events(
app0.raiden.chain,
token_network_identifier,
channel_id,
)
total_deposit_event = {
'event': EVENT_CHANNEL_DEPOSIT,
'args': {
'participant': to_checksum_address(app0.raiden.address),
'total_deposit': deposit,
'channel_identifier': channel_id,
},
}
assert must_have_event(deposit_events, total_deposit_event)
assert must_have_event(all_netting_channel_events, total_deposit_event)
RaidenAPI(app0.raiden).channel_close(
registry_address,
token_address,
app1.raiden.address,
)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
token_network_identifier,
channel_id,
)
closed_events = get_netting_channel_closed_events(
app0.raiden.chain,
token_network_identifier,
channel_id,
)
closed_event = {
'event': EVENT_CHANNEL_CLOSED,
'args': {
'channel_identifier': channel_id,
'closing_participant': to_checksum_address(app0.raiden.address),
},
}
assert must_have_event(closed_events, closed_event)
assert must_have_event(all_netting_channel_events, 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,
token_network_identifier,
channel_id,
)
settled_events = get_netting_channel_settled_events(
app0.raiden.chain,
token_network_identifier,
channel_id,
)
settled_event = {
'event': EVENT_CHANNEL_SETTLED,
'args': {
'channel_identifier': channel_id,
},
}
assert must_have_event(settled_events, settled_event)
assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events(
raiden_chain,
token_addresses,
deposit,
settle_timeout,
retry_timeout,
contract_manager,
blockchain_type,
):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
token_network_address = app0.raiden.default_registry.get_token_network(
token_address, BLOCK_ID_LATEST)
assert token_network_address
manager0 = app0.raiden.proxy_manager.token_network(token_network_address,
BLOCK_ID_LATEST)
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0), registry_address, token_address)
events = get_token_network_registry_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_registry_address=registry_address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
assert must_have_event(
events,
{
"event": EVENT_TOKEN_NETWORK_CREATED,
"args": {
"token_network_address": to_checksum_address(manager0.address),
"token_address": to_checksum_address(token_address),
},
},
)
if blockchain_type == "geth":
# FIXME: This is apparently meant to verify that querying nonexisting blocks
# returns an empty list, which is not true for parity.
events = get_token_network_registry_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_registry_address=app0.raiden.default_registry.
address,
contract_manager=contract_manager,
events=ALL_EVENTS,
from_block=BlockNumber(999999998),
to_block=BlockNumber(999999999),
)
assert not events
RaidenAPI(app0.raiden).channel_open(registry_address, token_address,
app1.raiden.address)
wait_both_channel_open(app0, app1, registry_address, token_address,
retry_timeout)
events = get_token_network_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=manager0.address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
_event = must_have_event(
events,
{
"event": ChannelEvent.OPENED,
"args": {
"participant1": to_checksum_address(app0.raiden.address),
"participant2": to_checksum_address(app1.raiden.address),
"settle_timeout": settle_timeout,
},
},
)
assert _event
channel_id = _event["args"]["channel_identifier"]
if blockchain_type == "geth":
# see above
events = get_token_network_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=manager0.address,
contract_manager=contract_manager,
events=ALL_EVENTS,
from_block=BlockNumber(999999998),
to_block=BlockNumber(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_synced_channel_state(token_network_address, app0, Balance(0), [],
app1, Balance(0), [])
RaidenAPI(app0.raiden).set_total_channel_deposit(registry_address,
token_address,
app1.raiden.address,
deposit)
all_netting_channel_events = get_all_netting_channel_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
deposit_events = get_netting_channel_deposit_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
total_deposit_event = {
"event": ChannelEvent.DEPOSIT,
"args": {
"participant": to_checksum_address(app0.raiden.address),
"total_deposit": deposit,
"channel_identifier": channel_id,
},
}
assert must_have_event(deposit_events, total_deposit_event)
assert must_have_event(all_netting_channel_events, total_deposit_event)
RaidenAPI(app0.raiden).channel_close(registry_address, token_address,
app1.raiden.address)
all_netting_channel_events = get_all_netting_channel_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
closed_events = get_netting_channel_closed_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
closed_event = {
"event": ChannelEvent.CLOSED,
"args": {
"channel_identifier": channel_id,
"closing_participant": to_checksum_address(app0.raiden.address),
},
}
assert must_have_event(closed_events, closed_event)
assert must_have_event(all_netting_channel_events, closed_event)
settle_expiration = app0.raiden.rpc_client.block_number(
) + settle_timeout + 5
app0.raiden.proxy_manager.client.wait_until_block(
target_block_number=settle_expiration)
all_netting_channel_events = get_all_netting_channel_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
settled_events = get_netting_channel_settled_events(
proxy_manager=app0.raiden.proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
settled_event = {
"event": ChannelEvent.SETTLED,
"args": {
"channel_identifier": channel_id
}
}
assert must_have_event(settled_events, settled_event)
assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events(
raiden_chain,
token_addresses,
deposit,
settle_timeout,
retry_timeout,
contract_manager,
blockchain_type,
):
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,
)
token_network_address = app0.raiden.default_registry.get_token_network(
token_address)
manager0 = app0.raiden.chain.token_network(token_network_address)
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
events = get_token_network_registry_events(
chain=app0.raiden.chain,
token_network_registry_address=registry_address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
assert must_have_event(
events,
{
'event': EVENT_TOKEN_NETWORK_CREATED,
'args': {
'token_network_address': to_checksum_address(manager0.address),
'token_address': to_checksum_address(token_address),
},
},
)
if blockchain_type == 'geth':
# FIXME: This is apparently meant to verify that querying nonexisting blocks
# returns an empty list, which is not true for parity.
events = get_token_network_registry_events(
chain=app0.raiden.chain,
token_network_registry_address=app0.raiden.default_registry.
address,
contract_manager=contract_manager,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
wait_both_channel_open(app0, app1, registry_address, token_address,
retry_timeout)
events = get_token_network_events(
chain=app0.raiden.chain,
token_network_address=manager0.address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
_event = must_have_event(
events,
{
'event': ChannelEvent.OPENED,
'args': {
'participant1': to_checksum_address(app0.raiden.address),
'participant2': to_checksum_address(app1.raiden.address),
'settle_timeout': settle_timeout,
},
},
)
assert _event
channel_id = _event['args']['channel_identifier']
if blockchain_type == 'geth':
# see above
events = get_token_network_events(
chain=app0.raiden.chain,
token_network_address=manager0.address,
contract_manager=contract_manager,
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_synced_channel_state(
token_network_identifier,
app0,
0,
[],
app1,
0,
[],
)
RaidenAPI(app0.raiden).set_total_channel_deposit(
registry_address,
token_address,
app1.raiden.address,
deposit,
)
all_netting_channel_events = get_all_netting_channel_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
deposit_events = get_netting_channel_deposit_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
total_deposit_event = {
'event': ChannelEvent.DEPOSIT,
'args': {
'participant': to_checksum_address(app0.raiden.address),
'total_deposit': deposit,
'channel_identifier': channel_id,
},
}
assert must_have_event(deposit_events, total_deposit_event)
assert must_have_event(all_netting_channel_events, total_deposit_event)
RaidenAPI(app0.raiden).channel_close(
registry_address,
token_address,
app1.raiden.address,
)
all_netting_channel_events = get_all_netting_channel_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
closed_events = get_netting_channel_closed_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
closed_event = {
'event': ChannelEvent.CLOSED,
'args': {
'channel_identifier': channel_id,
'closing_participant': to_checksum_address(app0.raiden.address),
},
}
assert must_have_event(closed_events, closed_event)
assert must_have_event(all_netting_channel_events, closed_event)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 5
app0.raiden.chain.wait_until_block(target_block_number=settle_expiration)
all_netting_channel_events = get_all_netting_channel_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
settled_events = get_netting_channel_settled_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
settled_event = {
'event': ChannelEvent.SETTLED,
'args': {
'channel_identifier': channel_id,
},
}
assert must_have_event(settled_events, settled_event)
assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events(
raiden_chain,
token_addresses,
deposit,
settle_timeout,
retry_timeout,
contract_manager,
):
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,
)
token_network_address = app0.raiden.default_registry.get_token_network(token_address)
manager0 = app0.raiden.chain.token_network(token_network_address)
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
events = get_token_network_registry_events(
chain=app0.raiden.chain,
token_network_registry_address=registry_address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
assert must_have_event(
events,
{
'event': EVENT_TOKEN_NETWORK_CREATED,
'args': {
'token_network_address': to_checksum_address(manager0.address),
'token_address': to_checksum_address(token_address),
},
},
)
events = get_token_network_registry_events(
chain=app0.raiden.chain,
token_network_registry_address=app0.raiden.default_registry.address,
contract_manager=contract_manager,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout)
events = get_token_network_events(
chain=app0.raiden.chain,
token_network_address=manager0.address,
contract_manager=contract_manager,
events=ALL_EVENTS,
)
_event = must_have_event(
events,
{
'event': ChannelEvent.OPENED,
'args': {
'participant1': to_checksum_address(app0.raiden.address),
'participant2': to_checksum_address(app1.raiden.address),
'settle_timeout': settle_timeout,
},
},
)
assert _event
channel_id = _event['args']['channel_identifier']
events = get_token_network_events(
chain=app0.raiden.chain,
token_network_address=manager0.address,
contract_manager=contract_manager,
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_synced_channel_state(
token_network_identifier,
app0, 0, [],
app1, 0, [],
)
RaidenAPI(app0.raiden).set_total_channel_deposit(
registry_address,
token_address,
app1.raiden.address,
deposit,
)
all_netting_channel_events = get_all_netting_channel_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
deposit_events = get_netting_channel_deposit_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
total_deposit_event = {
'event': ChannelEvent.DEPOSIT,
'args': {
'participant': to_checksum_address(app0.raiden.address),
'total_deposit': deposit,
'channel_identifier': channel_id,
},
}
assert must_have_event(deposit_events, total_deposit_event)
assert must_have_event(all_netting_channel_events, total_deposit_event)
RaidenAPI(app0.raiden).channel_close(
registry_address,
token_address,
app1.raiden.address,
)
all_netting_channel_events = get_all_netting_channel_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
closed_events = get_netting_channel_closed_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
closed_event = {
'event': ChannelEvent.CLOSED,
'args': {
'channel_identifier': channel_id,
'closing_participant': to_checksum_address(app0.raiden.address),
},
}
assert must_have_event(closed_events, closed_event)
assert must_have_event(all_netting_channel_events, 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(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=app0.raiden.contract_manager,
)
settled_events = get_netting_channel_settled_events(
chain=app0.raiden.chain,
token_network_address=token_network_identifier,
netting_channel_identifier=channel_id,
contract_manager=contract_manager,
)
settled_event = {
'event': ChannelEvent.SETTLED,
'args': {
'channel_identifier': channel_id,
},
}
assert must_have_event(settled_events, settled_event)
assert must_have_event(all_netting_channel_events, settled_event)
