def test_total_token_network_channels():
number_of_channels = 3
test_state = factories.make_chain_state(
number_of_channels=number_of_channels)
unknown_token_address = factories.make_address()
unknown_token_network_registry_address = factories.make_address()
assert (views.total_token_network_channels(
chain_state=test_state.chain_state,
token_network_registry_address=unknown_token_network_registry_address,
token_address=unknown_token_address,
) == 0)
assert (views.total_token_network_channels(
chain_state=test_state.chain_state,
token_network_registry_address=unknown_token_network_registry_address,
token_address=test_state.token_address,
) == 0)
assert (views.total_token_network_channels(
chain_state=test_state.chain_state,
token_network_registry_address=test_state.
token_network_registry_address,
token_address=unknown_token_address,
) == 0)
assert (views.total_token_network_channels(
chain_state=test_state.chain_state,
token_network_registry_address=test_state.
token_network_registry_address,
token_address=test_state.token_address,
) == number_of_channels)
def test_channel_new(raiden_chain, retry_timeout, token_addresses):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
gevent.sleep(retry_timeout)
# The channel is created but without funds
channelcount1 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
assert channelcount0 + 1 == channelcount1
def test_channel_new(raiden_chain, retry_timeout, token_addresses):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
channelcount0 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
RaidenAPI(app0.raiden).channel_open(
registry_address,
token_address,
app1.raiden.address,
)
wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout)
# The channel is created but without funds
channelcount1 = views.total_token_network_channels(
views.state_from_app(app0),
registry_address,
token_address,
)
assert channelcount0 + 1 == channelcount1
def test_channel_new(raiden_chain: List[RaidenService], retry_timeout,
token_addresses):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
registry_address = app0.default_registry.address
token_address = token_addresses[0]
channelcount0 = views.total_token_network_channels(
views.state_from_raiden(app0), registry_address, token_address)
RaidenAPI(app0).channel_open(registry_address, token_address, app1.address)
wait_both_channel_open(app0, app1, registry_address, token_address,
retry_timeout)
# The channel is created but without funds
channelcount1 = views.total_token_network_channels(
views.state_from_raiden(app0), registry_address, token_address)
assert channelcount0 + 1 == channelcount1
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,
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,
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)
