def get_channel_events(
self,
token_network_address,
channel_identifier,
from_block,
to_block='latest',
):
returned_events = get_all_netting_channel_events(
self.raiden.chain,
token_network_address,
channel_identifier,
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_channel_events(self,
channel_address,
from_block,
to_block='latest'):
if not isaddress(channel_address):
raise InvalidAddress(
'Expected binary address format for channel in get_channel_events'
)
returned_events = get_all_netting_channel_events(
self.raiden.chain,
channel_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': type(event).__name__.encode(),
}
new_event.update(event.__dict__)
returned_events.append(new_event)
return returned_events
def get_blockchain_events_channel(
self,
token_address: typing.TokenAddress,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: typing.BlockSpecification = 'latest',
):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_blockchain_events_channel',
)
token_network_address = self.raiden.default_registry.get_token_network(
token_address,
)
if token_network_address is None:
raise UnknownTokenAddress('Token address is not known.')
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(blockchain_events.get_all_netting_channel_events(
chain=self.raiden.chain,
token_network_address=token_network_address,
netting_channel_identifier=channel.identifier,
contract_manager=self.raiden.contract_manager,
from_block=from_block,
to_block=to_block,
))
returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True)
return returned_events
def get_blockchain_events_channel(
self,
token_address: TokenAddress,
partner_address: Address = None,
from_block: BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: BlockSpecification = "latest",
):
if not is_binary_address(token_address):
raise InvalidAddress(
"Expected binary address format for token in get_blockchain_events_channel"
)
token_network_address = self.raiden.default_registry.get_token_network(token_address)
if token_network_address is None:
raise UnknownTokenAddress("Token address is not known.")
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(
blockchain_events.get_all_netting_channel_events(
chain=self.raiden.chain,
token_network_address=token_network_address,
netting_channel_identifier=channel.identifier,
contract_manager=self.raiden.contract_manager,
from_block=from_block,
to_block=to_block,
)
)
returned_events.sort(key=lambda evt: evt.get("block_number"), reverse=True)
return returned_events
def get_channel_events(self, channel_address, from_block, to_block=None):
if not isaddress(channel_address):
raise InvalidAddress(
'Expected binary address format for channel in get_channel_events'
)
returned_events = get_all_netting_channel_events(
self.raiden.chain,
channel_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
raiden_events = self.raiden.transaction_log.get_events_in_block_range(
from_block=from_block,
to_block=to_block
)
# Here choose which raiden internal events we want to expose to the end user
for event in raiden_events:
is_user_transfer_event = isinstance(event.event_object, (
EventTransferSentSuccess,
EventTransferSentFailed,
EventTransferReceivedSuccess
))
if is_user_transfer_event:
new_event = {
'block_number': event.block_number,
'_event_type': type(event.event_object).__name__,
}
new_event.update(event.event_object.__dict__)
returned_events.append(new_event)
return returned_events
def get_blockchain_events_channel(
self,
token_address: typing.TokenAddress,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_blockchain_events_channel',
)
token_network_address = self.raiden.default_registry.get_token_network(
token_address, )
if token_network_address is None:
raise UnknownTokenAddress('Token address is not known.')
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(
blockchain_events.get_all_netting_channel_events(
chain=self.raiden.chain,
token_network_address=token_network_address,
netting_channel_identifier=channel.identifier,
from_block=from_block,
to_block=to_block,
))
returned_events.sort(key=lambda evt: evt.get('block_number'),
reverse=True)
return returned_events
def get_channel_events(self, channel_address, from_block, to_block=None):
if not isaddress(channel_address):
raise InvalidAddress(
'Expected binary address format for channel in get_channel_events'
)
returned_events = get_all_netting_channel_events(
self.raiden.chain,
channel_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
raiden_events = self.raiden.transaction_log.get_events_in_block_range(
from_block=from_block, to_block=to_block)
# Here choose which raiden internal events we want to expose to the end user
for event in raiden_events:
is_user_transfer_event = isinstance(
event.event_object,
(EventTransferSentSuccess, EventTransferSentFailed,
EventTransferReceivedSuccess))
if is_user_transfer_event:
new_event = {
'block_number': event.block_number,
'_event_type': type(event.event_object).__name__,
}
new_event.update(event.event_object.__dict__)
returned_events.append(new_event)
return returned_events
def get_channel_events(self, channel_address, from_block, to_block):
if not isaddress(channel_address):
raise InvalidAddress(
'Expected binary address format for channel in get_channel_events'
)
return get_all_netting_channel_events(
self.raiden.chain,
channel_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
def get_channel_events(
self,
token_address: typing.Address,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
token_network_address = self.raiden.default_registry.get_token_network(
token_address, )
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(
get_all_netting_channel_events(
self.raiden.chain,
token_network_address,
channel.identifier,
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)
returned_events.sort(key=lambda evt: evt.get('block_number'),
reverse=True)
return returned_events
def get_channel_events(
self,
token_address: typing.Address,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
token_network_address = self.raiden.default_registry.get_token_network(
token_address,
)
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(get_all_netting_channel_events(
self.raiden.chain,
token_network_address,
channel.identifier,
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)
returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True)
return returned_events
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, 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,
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)
def test_payment_channel_proxy_basics(
token_network_registry_address: TokenNetworkRegistryAddress,
token_network_proxy: TokenNetwork,
token_proxy: Token,
chain_id: ChainID,
private_keys: List[PrivateKey],
web3: Web3,
contract_manager: ContractManager,
reveal_timeout: BlockTimeout,
) -> None:
token_network_address = token_network_proxy.address
partner = privatekey_to_address(private_keys[0])
rpc_client = JSONRPCClient(web3, private_keys[1])
proxy_manager = ProxyManager(
rpc_client=rpc_client,
contract_manager=contract_manager,
metadata=ProxyManagerMetadata(
token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER,
filters_start_at=GENESIS_BLOCK_NUMBER,
),
)
token_network_proxy = proxy_manager.token_network(
address=token_network_address, block_identifier=BLOCK_ID_LATEST
)
start_block = web3.eth.blockNumber
channel_details = token_network_proxy.new_netting_channel(
partner=partner,
settle_timeout=TEST_SETTLE_TIMEOUT_MIN,
given_block_identifier=BLOCK_ID_LATEST,
)
channel_identifier = channel_details.channel_identifier
assert channel_identifier is not None
channel_state = NettingChannelState(
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_id,
token_network_address=token_network_address,
channel_identifier=channel_identifier,
),
token_address=token_network_proxy.token_address(),
token_network_registry_address=token_network_registry_address,
reveal_timeout=reveal_timeout,
settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN),
fee_schedule=FeeScheduleState(),
our_state=NettingChannelEndState(
address=token_network_proxy.client.address, contract_balance=Balance(0)
),
partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)),
open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)),
)
channel_proxy_1 = proxy_manager.payment_channel(
channel_state=channel_state, block_identifier=BLOCK_ID_LATEST
)
assert channel_proxy_1.channel_identifier == channel_identifier
assert channel_proxy_1.opened(BLOCK_ID_LATEST) is True
# Test deposit
initial_token_balance = 100
token_proxy.transfer(rpc_client.address, TokenAmount(initial_token_balance))
assert token_proxy.balance_of(rpc_client.address) == initial_token_balance
assert token_proxy.balance_of(partner) == 0
channel_proxy_1.approve_and_set_total_deposit(
total_deposit=TokenAmount(10), block_identifier=BLOCK_ID_LATEST
)
# ChannelOpened, ChannelNewDeposit
channel_events = get_all_netting_channel_events(
proxy_manager=proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_proxy_1.channel_identifier,
contract_manager=contract_manager,
from_block=start_block,
to_block=web3.eth.blockNumber,
)
assert len(channel_events) == 2
block_before_close = web3.eth.blockNumber
empty_balance_proof = BalanceProof(
channel_identifier=channel_proxy_1.channel_identifier,
token_network_address=token_network_address,
balance_hash=EMPTY_BALANCE_HASH,
nonce=0,
chain_id=chain_id,
transferred_amount=TokenAmount(0),
)
closing_data = (
empty_balance_proof.serialize_bin(msg_type=MessageTypeId.BALANCE_PROOF) + EMPTY_SIGNATURE
)
channel_proxy_1.close(
nonce=Nonce(0),
balance_hash=EMPTY_BALANCE_HASH,
additional_hash=EMPTY_MESSAGE_HASH,
non_closing_signature=EMPTY_SIGNATURE,
closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data),
block_identifier=BLOCK_ID_LATEST,
)
assert channel_proxy_1.closed(BLOCK_ID_LATEST) is True
# ChannelOpened, ChannelNewDeposit, ChannelClosed
channel_events = get_all_netting_channel_events(
proxy_manager=proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_proxy_1.channel_identifier,
contract_manager=contract_manager,
from_block=start_block,
to_block=web3.eth.blockNumber,
)
assert len(channel_events) == 3
# check the settlement timeouts again
assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN
# update transfer -- we need to wait on +1 since we use the latest block on parity for
# estimate gas and at the time the latest block is the settle timeout block.
# More info: https://github.com/raiden-network/raiden/pull/3699#discussion_r270477227
rpc_client.wait_until_block(
target_block_number=BlockNumber(rpc_client.block_number() + TEST_SETTLE_TIMEOUT_MIN + 1)
)
transaction_hash = channel_proxy_1.settle(
transferred_amount=TokenAmount(0),
locked_amount=LockedAmount(0),
locksroot=LOCKSROOT_OF_NO_LOCKS,
partner_transferred_amount=TokenAmount(0),
partner_locked_amount=LockedAmount(0),
partner_locksroot=LOCKSROOT_OF_NO_LOCKS,
block_identifier=BLOCK_ID_LATEST,
)
assert is_tx_hash_bytes(transaction_hash)
assert channel_proxy_1.settled(BLOCK_ID_LATEST) is True
# ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled
channel_events = get_all_netting_channel_events(
proxy_manager=proxy_manager,
token_network_address=token_network_address,
netting_channel_identifier=channel_proxy_1.channel_identifier,
contract_manager=contract_manager,
from_block=start_block,
to_block=web3.eth.blockNumber,
)
assert len(channel_events) == 4
channel_details = token_network_proxy.new_netting_channel(
partner=partner,
settle_timeout=TEST_SETTLE_TIMEOUT_MIN,
given_block_identifier=BLOCK_ID_LATEST,
)
new_channel_identifier = channel_details.channel_identifier
assert new_channel_identifier is not None
channel_state = NettingChannelState(
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_id,
token_network_address=token_network_address,
channel_identifier=new_channel_identifier,
),
token_address=token_network_proxy.token_address(),
token_network_registry_address=token_network_registry_address,
reveal_timeout=reveal_timeout,
settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN),
fee_schedule=FeeScheduleState(),
our_state=NettingChannelEndState(
address=token_network_proxy.client.address, contract_balance=Balance(0)
),
partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)),
open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)),
)
channel_proxy_2 = proxy_manager.payment_channel(
channel_state=channel_state, block_identifier=BLOCK_ID_LATEST
)
assert channel_proxy_2.channel_identifier == new_channel_identifier
assert channel_proxy_2.opened(BLOCK_ID_LATEST) is True
msg = "The channel was already closed, the second call must fail"
with pytest.raises(RaidenRecoverableError):
channel_proxy_1.close(
nonce=Nonce(0),
balance_hash=EMPTY_BALANCE_HASH,
additional_hash=EMPTY_MESSAGE_HASH,
non_closing_signature=EMPTY_SIGNATURE,
closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data),
block_identifier=block_before_close,
)
pytest.fail(msg)
msg = "The channel is not open at latest, this must raise"
with pytest.raises(RaidenUnrecoverableError):
channel_proxy_1.close(
nonce=Nonce(0),
balance_hash=EMPTY_BALANCE_HASH,
additional_hash=EMPTY_MESSAGE_HASH,
non_closing_signature=EMPTY_SIGNATURE,
closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data),
block_identifier=BLOCK_ID_LATEST,
)
pytest.fail(msg)
msg = (
"The channel was not opened at the provided block (latest). "
"This call should never have been attempted."
)
with pytest.raises(BrokenPreconditionError):
channel_proxy_1.approve_and_set_total_deposit(
total_deposit=TokenAmount(20), block_identifier=BLOCK_ID_LATEST
)
pytest.fail(msg)
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)
