def get_channel_events_for_token(app, token_address, start_block=0):
""" Collect all events from all channels for a given `token_address` and `app` """
result = list()
api = RaidenAPI(app.raiden)
channels = api.get_channel_list(token_address=token_address)
for channel in channels:
events = api.get_channel_events(channel.identifier, start_block)
result.extend(events)
return result
def get_channel_events_for_token(app, token_address, start_block=0):
""" Collect all events from all channels for a given `token_address` and `app` """
result = list()
api = RaidenAPI(app.raiden)
channels = api.get_channel_list(token_address=token_address)
for channel in channels:
events = api.get_channel_events(channel.channel_address, start_block)
result.extend(events)
return result
def get_channel_events_for_token(app, registry_address, token_address, start_block=0):
""" Collect all events from all channels for a given `token_address` and `app` """
result = list()
api = RaidenAPI(app.raiden)
channels = api.get_channel_list(
registry_address=registry_address,
token_address=token_address,
)
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app),
app.raiden.default_registry.address,
token_address,
)
for channel in channels:
events = api.get_channel_events(token_network_identifier, channel.identifier, start_block)
result.extend(events)
return result
def test_channel_lifecycle(raiden_network, token_addresses, deposit, transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address, api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address, api2.address)
channels = api1.get_channel_list(registry_address, token_address, api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any(
(
event['event'] == EVENT_CHANNEL_OPENED and
is_same_address(
event['args']['participant1'],
to_normalized_address(api1.address),
) and
is_same_address(
event['args']['participant2'],
to_normalized_address(api2.address),
)
)
for event in event_list1
)
token_events = api1.get_token_network_events(
token_address,
channel12.open_transaction.finished_block_number,
)
assert token_events[0]['event'] == EVENT_CHANNEL_OPENED
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
# let's make sure it's idempotent
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state, channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any(
(
event['event'] == EVENT_CHANNEL_DEPOSIT and
is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
) and
event['args']['total_deposit'] == deposit
)
for event in event_list2
)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any(
(
event['event'] == EVENT_CHANNEL_CLOSED and
is_same_address(
event['args']['closing_participant'],
to_normalized_address(api1.address),
)
)
for event in event_list3
)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(raiden_network, token_addresses, deposit,
transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
if transport_config.protocol == TransportProtocol.UDP:
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(
api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(
api1.address) == NODE_NETWORK_UNKNOWN
elif transport_config.protocol == TransportProtocol.MATRIX:
# with Matrix nodes do not need a health check to know each others reachability
assert api1.get_node_network_state(
api2.address) == NODE_NETWORK_UNREACHABLE
assert api2.get_node_network_state(
api1.address) == NODE_NETWORK_UNREACHABLE
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert event_list1 == []
token_events = api1.get_token_network_events(
token_address,
channel12.open_transaction.finished_block_number,
)
assert token_events[0]['event'] == EVENT_CHANNEL_NEW
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert any(
(event['event'] == EVENT_CHANNEL_NEW_BALANCE and is_same_address(
event['args']['registry_address'],
to_normalized_address(registry_address),
) and is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
)) for event in event_list2)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any((event['event'] == EVENT_CHANNEL_CLOSED and is_same_address(
event['args']['registry_address'],
to_normalized_address(registry_address),
) and is_same_address(
event['args']['closing_address'],
to_normalized_address(api1.address),
)) for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(blockchain_type, raiden_network, token_addresses,
deposit):
if blockchain_type == 'tester':
pytest.skip(
'there is not support ATM for retrieving events from tester')
node1, node2 = raiden_network
token_address = token_addresses[0]
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert api1.get_channel_list(token_address, api2.address) == []
# this is a synchronous api
api1.open(token_address, api2.address)
channels = api1.get_channel_list(token_address, api2.address)
assert len(channels) == 1
channel12 = channels[0]
event_list1 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert event_list1 == []
# the channel has no deposit yet
assert channel12.state == CHANNEL_STATE_OPENED
api1.deposit(token_address, api2.address, deposit)
assert channel12.state == CHANNEL_STATE_OPENED
assert channel12.balance == deposit
assert channel12.contract_balance == deposit
assert api1.get_channel_list(token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert any((event['_event_type'] == 'ChannelNewBalance'
and event['participant'] == hexlify(api1.address))
for event in event_list2)
with pytest.raises(InvalidState):
api1.settle(token_address, api2.address)
api1.close(token_address, api2.address)
node1.raiden.poll_blockchain_events()
event_list3 = api1.get_channel_events(
channel12.channel_address,
channel12.external_state.opened_block,
)
assert len(event_list3) > len(event_list2)
assert any((event['_event_type'] == 'ChannelClosed'
and event['closing_address'] == hexlify(api1.address))
for event in event_list3)
assert channel12.state == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.external_state.closed_block + channel12.settle_timeout +
5 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
node1.raiden.poll_blockchain_events()
assert channel12.state == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(raiden_network, token_addresses, deposit):
node1, node2 = raiden_network
token_address = token_addresses[0]
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(token_address, api2.address)
# open is a synchronous api
api1.channel_open(token_address, api2.address)
channels = api1.get_channel_list(token_address, api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_address)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert event_list1 == []
# Load the new state with the deposit
api1.channel_deposit(token_address, api2.address, deposit)
channel12 = get_channelstate(node1, node2, token_address)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(token_address, api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert any((event['_event_type'] == b'ChannelNewBalance'
and event['participant'] == address_encoder(api1.address))
for event in event_list2)
api1.channel_close(token_address, api2.address)
node1.raiden.poll_blockchain_events()
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_address)
event_list3 = api1.get_channel_events(
channel12.identifier,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any((event['_event_type'] == b'ChannelClosed'
and event['closing_address'] == address_encoder(api1.address))
for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
# Load the new state with the channel settled
channel12 = get_channelstate(node1, node2, token_address)
node1.raiden.poll_blockchain_events()
assert channel.get_status(channel12) == CHANNEL_STATE_SETTLED
def test_channel_lifecycle(raiden_network, token_addresses, deposit,
transport_config):
node1, node2 = raiden_network
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(node1),
node1.raiden.default_registry.address,
token_address,
)
api1 = RaidenAPI(node1.raiden)
api2 = RaidenAPI(node2.raiden)
registry_address = node1.raiden.default_registry.address
# nodes don't have a channel, so they are not healthchecking
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_UNKNOWN
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_UNKNOWN
assert not api1.get_channel_list(registry_address, token_address,
api2.address)
# open is a synchronous api
api1.channel_open(node1.raiden.default_registry.address, token_address,
api2.address)
channels = api1.get_channel_list(registry_address, token_address,
api2.address)
assert len(channels) == 1
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
event_list1 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any((event['event'] == EVENT_CHANNEL_OPENED and is_same_address(
event['args']['participant1'],
to_normalized_address(api1.address),
) and is_same_address(
event['args']['participant2'],
to_normalized_address(api2.address),
)) for event in event_list1)
token_events = api1.get_token_network_events(
token_address,
channel12.open_transaction.finished_block_number,
)
assert token_events[0]['event'] == EVENT_CHANNEL_OPENED
registry_address = api1.raiden.default_registry.address
# Load the new state with the deposit
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
# let's make sure it's idempotent
api1.set_total_channel_deposit(
registry_address,
token_address,
api2.address,
deposit,
)
channel12 = get_channelstate(node1, node2, token_network_identifier)
assert channel.get_status(channel12) == CHANNEL_STATE_OPENED
assert channel.get_balance(channel12.our_state,
channel12.partner_state) == deposit
assert channel12.our_state.contract_balance == deposit
assert api1.get_channel_list(registry_address, token_address,
api2.address) == [channel12]
# there is a channel open, they must be healthchecking each other
assert api1.get_node_network_state(api2.address) == NODE_NETWORK_REACHABLE
assert api2.get_node_network_state(api1.address) == NODE_NETWORK_REACHABLE
event_list2 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert any((event['event'] == EVENT_CHANNEL_DEPOSIT and is_same_address(
event['args']['participant'],
to_normalized_address(api1.address),
) and event['args']['total_deposit'] == deposit) for event in event_list2)
api1.channel_close(registry_address, token_address, api2.address)
# Load the new state with the channel closed
channel12 = get_channelstate(node1, node2, token_network_identifier)
event_list3 = api1.get_channel_events(
token_address,
channel12.partner_state.address,
channel12.open_transaction.finished_block_number,
)
assert len(event_list3) > len(event_list2)
assert any((event['event'] == EVENT_CHANNEL_CLOSED and is_same_address(
event['args']['closing_participant'],
to_normalized_address(api1.address),
)) for event in event_list3)
assert channel.get_status(channel12) == CHANNEL_STATE_CLOSED
settlement_block = (
channel12.close_transaction.finished_block_number +
channel12.settle_timeout +
10 # arbitrary number of additional blocks, used to wait for the settle() call
)
wait_until_block(node1.raiden.chain, settlement_block)
state_changes = node1.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
assert must_contain_entry(
state_changes, ContractReceiveChannelSettled, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel12.identifier,
})