def test_channel_closed_event_handler_closes_existing_channel(context: Context):
context = setup_state_with_open_channel(context)
current_block = get_posix_utc_time_now() // 15
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(current_block + 1),
)
channel_closed_event_handler(event, context)
assert context.database.channel_count() == 1
assert_channel_state(context, ChannelState.CLOSED)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(current_block),
)
channel_closed_event_handler(event, context)
# ActionMonitoringTriggeredEvent has been triggered
assert context.database.scheduled_event_count() == 1
assert context.database.channel_count() == 1
assert_channel_state(context, ChannelState.CLOSED)
def test_token_channel_closed(pathfinding_service_mock, token_network_model):
setup_channel(pathfinding_service_mock, token_network_model)
token_network_address = make_token_network_address()
# Test invalid token network address
close_event = ReceiveChannelClosedEvent(
token_network_address=token_network_address,
channel_identifier=ChannelID(1),
closing_participant=PARTICIPANT1,
block_number=BlockNumber(2),
)
pathfinding_service_mock.handle_event(close_event)
assert len(pathfinding_service_mock.token_networks) == 1
assert len(token_network_model.channel_id_to_addresses) == 1
# Test proper token network address
close_event.token_network_address = token_network_model.address
pathfinding_service_mock.handle_event(close_event)
assert len(pathfinding_service_mock.token_networks) == 1
assert len(token_network_model.channel_id_to_addresses) == 0
# Test non-existent channel
close_event.channel_identifier = ChannelID(123)
pathfinding_service_mock.handle_event(close_event)
assert len(pathfinding_service_mock.token_networks) == 1
assert len(token_network_model.channel_id_to_addresses) == 0
def parse_token_network_event(event: dict) -> Optional[Event]:
event_name = event["event"]
common_infos = dict(
token_network_address=decode_hex(event["address"]),
channel_identifier=event["args"]["channel_identifier"],
block_number=event["blockNumber"],
)
if event_name == ChannelEvent.OPENED:
return ReceiveChannelOpenedEvent(
participant1=to_canonical_address(event["args"]["participant1"]),
participant2=to_canonical_address(event["args"]["participant2"]),
settle_timeout=event["args"]["settle_timeout"],
**common_infos,
)
if event_name == ChannelEvent.CLOSED:
return ReceiveChannelClosedEvent(
closing_participant=to_canonical_address(event["args"]["closing_participant"]),
**common_infos,
)
if event_name == ChannelEvent.BALANCE_PROOF_UPDATED:
return ReceiveNonClosingBalanceProofUpdatedEvent(
closing_participant=to_canonical_address(event["args"]["closing_participant"]),
nonce=event["args"]["nonce"],
**common_infos,
)
if event_name == ChannelEvent.SETTLED:
return ReceiveChannelSettledEvent(**common_infos)
return None
def test_channel_closed_event_handler_trigger_action_monitor_event_without_monitor_request(
context: Context, ):
context = setup_state_with_open_channel(context)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
channel_closed_event_handler(event, context)
assert context.db.scheduled_event_count() == 1
def test_channel_closed_event_handler_leaves_existing_channel(context: Context):
context = setup_state_with_open_channel(context)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=ChannelID(4),
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
channel_closed_event_handler(event, context)
assert context.database.channel_count() == 1
assert_channel_state(context, ChannelState.OPENED)
def setup_state_with_closed_channel(context: Context) -> Context:
context = setup_state_with_open_channel(context)
event2 = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
channel_closed_event_handler(event2, context)
assert context.db.channel_count() == 1
assert_channel_state(context, ChannelState.CLOSED)
return context
def test_channel_closed_event_handler_closes_existing_channel(context: Context):
context = setup_state_with_open_channel(context)
context.web3.eth.blockNumber = BlockNumber(60)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
channel_closed_event_handler(event, context)
# ActionMonitoringTriggeredEvent has been triggered
assert context.db.scheduled_event_count() == 1
assert context.db.channel_count() == 1
assert_channel_state(context, ChannelState.CLOSED)
def test_channel_closed_event_handler_trigger_action_monitor_event_with_monitor_request(
context: Context,
):
context = setup_state_with_open_channel(context)
# add MR to DB
context.database.upsert_monitor_request(create_signed_monitor_request())
current_block_number = get_posix_utc_time_now() // 15
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(current_block_number + 1),
)
channel_closed_event_handler(event, context)
assert context.database.scheduled_event_count() == 1
def setup_state_with_closed_channel(context: Context) -> Context:
context = setup_state_with_open_channel(context)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=DEFAULT_CHANNEL_IDENTIFIER,
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
channel_closed_event_handler(event, context)
assert context.database.channel_count() == 1
assert_channel_state(context, ChannelState.CLOSED)
context.web3.eth.get_block = lambda x: Mock(
timestamp=context.web3.eth.block_number * 15 if x == "latest" else x * 15
)
return context
def test_channel_closed_event_handler_channel_not_in_database(
context: Context):
metrics_state = save_metrics_state(metrics.REGISTRY)
# only setup the token network without channels
create_default_token_network(context)
event = ReceiveChannelClosedEvent(
token_network_address=DEFAULT_TOKEN_NETWORK_ADDRESS,
channel_identifier=ChannelID(4),
closing_participant=DEFAULT_PARTICIPANT2,
block_number=BlockNumber(52),
)
assert context.database.channel_count() == 0
channel_closed_event_handler(event, context)
assert context.database.channel_count() == 0
assert (metrics_state.get_delta(
"events_log_errors_total",
labels=metrics.ErrorCategory.STATE.to_label_dict()) == 1.0)
def parse_token_network_event(event: dict) -> Optional[Event]:
event_name = event["event"]
# `DeprecationSwitch` isn't used currently, but needs to be checked so we can have
# `channel_identifier` in `common_infos`
# FIXME: use value from ChannelEvent as soon as PR is merged
# https://github.com/raiden-network/raiden-contracts/pull/1389
if event_name == "DeprecationSwitch":
return None
common_infos = dict(
token_network_address=decode_hex(event["address"]),
channel_identifier=event["args"]["channel_identifier"],
block_number=event["blockNumber"],
)
if event_name == ChannelEvent.OPENED:
return ReceiveChannelOpenedEvent(
participant1=to_canonical_address(event["args"]["participant1"]),
participant2=to_canonical_address(event["args"]["participant2"]),
settle_timeout=event["args"]["settle_timeout"],
**common_infos,
)
if event_name == ChannelEvent.CLOSED:
return ReceiveChannelClosedEvent(
closing_participant=to_canonical_address(
event["args"]["closing_participant"]),
**common_infos,
)
if event_name == ChannelEvent.BALANCE_PROOF_UPDATED:
return ReceiveNonClosingBalanceProofUpdatedEvent(
closing_participant=to_canonical_address(
event["args"]["closing_participant"]),
nonce=event["args"]["nonce"],
**common_infos,
)
if event_name == ChannelEvent.SETTLED:
return ReceiveChannelSettledEvent(**common_infos)
return None
def parse_token_network_event(event: dict) -> Optional[Event]:
event_name = event["event"]
# `DeprecationSwitch` isn't used currently, but needs to be checked so we can have
# `channel_identifier` in `common_infos`
if event_name == ChannelEvent.DEPRECATED:
return None
common_infos = dict(
token_network_address=decode_hex(event["address"]),
channel_identifier=event["args"]["channel_identifier"],
block_number=event["blockNumber"],
)
if event_name == ChannelEvent.OPENED:
return ReceiveChannelOpenedEvent(
participant1=to_canonical_address(event["args"]["participant1"]),
participant2=to_canonical_address(event["args"]["participant2"]),
**common_infos,
)
if event_name == ChannelEvent.CLOSED:
return ReceiveChannelClosedEvent(
closing_participant=to_canonical_address(
event["args"]["closing_participant"]),
**common_infos,
)
if event_name == ChannelEvent.BALANCE_PROOF_UPDATED:
return ReceiveNonClosingBalanceProofUpdatedEvent(
closing_participant=to_canonical_address(
event["args"]["closing_participant"]),
nonce=event["args"]["nonce"],
**common_infos,
)
if event_name == ChannelEvent.SETTLED:
return ReceiveChannelSettledEvent(**common_infos)
return None
def get_blockchain_events(
web3: Web3,
contract_manager: ContractManager,
chain_state: BlockchainState,
to_block: BlockNumber,
query_ms: bool = True,
) -> Tuple[BlockchainState, List[Event]]:
# increment by one, as latest_known_block has been queried last time already
from_block = BlockNumber(chain_state.latest_known_block + 1)
# Check if the current block was already processed
if from_block > to_block:
return chain_state, []
new_chain_state = deepcopy(chain_state)
log.info('Querying new block(s)',
from_block=from_block,
end_block=to_block)
# first check for new token networks and add to state
registry_events = query_blockchain_events(
web3=web3,
contract_manager=contract_manager,
contract_address=new_chain_state.token_network_registry_address,
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
topics=create_registry_event_topics(contract_manager),
from_block=from_block,
to_block=to_block,
)
events: List[Event] = []
for event in registry_events:
token_network_address = event['args']['token_network_address']
token_address = event['args']['token_address']
block_number = event['blockNumber']
events.append(
ReceiveTokenNetworkCreatedEvent(
token_address=token_address,
token_network_address=token_network_address,
block_number=block_number,
))
new_chain_state.token_network_addresses.append(
event['args']['token_network_address'])
# then check all token networks
for token_network_address in new_chain_state.token_network_addresses:
network_events = query_blockchain_events(
web3=web3,
contract_manager=contract_manager,
contract_address=Address(token_network_address),
contract_name=CONTRACT_TOKEN_NETWORK,
topics=[None],
from_block=from_block,
to_block=to_block,
)
for event in network_events:
event_name = event['event']
common_infos = dict(
token_network_address=event['address'],
channel_identifier=event['args']['channel_identifier'],
block_number=event['blockNumber'],
)
if event_name == ChannelEvent.OPENED:
events.append(
ReceiveChannelOpenedEvent(
participant1=event['args']['participant1'],
participant2=event['args']['participant2'],
settle_timeout=event['args']['settle_timeout'],
**common_infos,
))
elif event_name == ChannelEvent.DEPOSIT:
events.append(
ReceiveChannelNewDepositEvent(
participant_address=event['args']['participant'],
total_deposit=event['args']['total_deposit'],
**common_infos,
))
elif event_name == ChannelEvent.CLOSED:
events.append(
ReceiveChannelClosedEvent(closing_participant=event['args']
['closing_participant'],
**common_infos))
elif event_name == ChannelEvent.BALANCE_PROOF_UPDATED:
events.append(
ReceiveNonClosingBalanceProofUpdatedEvent(
closing_participant=event['args']
['closing_participant'],
nonce=event['args']['nonce'],
**common_infos,
))
elif event_name == ChannelEvent.SETTLED:
events.append(ReceiveChannelSettledEvent(**common_infos))
# get events from monitoring service contract
if query_ms:
monitoring_events = get_monitoring_blockchain_events(
web3=web3,
contract_manager=contract_manager,
chain_state=new_chain_state,
from_block=from_block,
to_block=to_block,
)
events.extend(monitoring_events)
# commit new block number
events.append(UpdatedHeadBlockEvent(head_block_number=to_block))
return new_chain_state, events
