def test_get_batch_unlock_gain():
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state = replace(
channel_state.our_state,
secrethashes_to_lockedlocks={
factories.make_keccak_hash(): make_hash_time_lock_state(1),
factories.make_keccak_hash(): make_hash_time_lock_state(2),
},
secrethashes_to_unlockedlocks={
factories.make_keccak_hash(): make_unlock_partial_proof_state(4)
},
secrethashes_to_onchain_unlockedlocks={
factories.make_keccak_hash(): make_unlock_partial_proof_state(8)
},
)
channel_state.partner_state = replace(
channel_state.partner_state,
secrethashes_to_lockedlocks={
factories.make_keccak_hash(): make_hash_time_lock_state(16)
},
secrethashes_to_unlockedlocks={
factories.make_keccak_hash(): make_unlock_partial_proof_state(32)
},
secrethashes_to_onchain_unlockedlocks={
factories.make_keccak_hash(): make_unlock_partial_proof_state(64),
factories.make_keccak_hash(): make_unlock_partial_proof_state(128),
},
)
unlock_gain = get_batch_unlock_gain(channel_state)
assert unlock_gain.from_partner_locks == 192
assert unlock_gain.from_our_locks == 7
def handle_contract_send_channelunlock(
raiden: "RaidenService",
chain_state: ChainState,
channel_unlock_event: ContractSendChannelBatchUnlock,
):
assert raiden.wal, "The Raiden Service must be initialize to handle events"
canonical_identifier = channel_unlock_event.canonical_identifier
token_network_identifier = canonical_identifier.token_network_address
channel_identifier = canonical_identifier.channel_identifier
participant = channel_unlock_event.participant
payment_channel: PaymentChannel = raiden.chain.payment_channel(
canonical_identifier=canonical_identifier
)
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=chain_state,
token_network_id=TokenNetworkID(token_network_identifier),
partner_address=participant,
)
if not channel_state:
# channel was cleaned up already due to an unlock
raise RaidenUnrecoverableError(
f"Failed to find channel state with partner:"
f"{to_checksum_address(participant)}, token_network:pex(token_network_identifier)"
)
our_address = channel_state.our_state.address
our_locksroot = channel_state.our_state.onchain_locksroot
partner_address = channel_state.partner_state.address
partner_locksroot = channel_state.partner_state.onchain_locksroot
# we want to unlock because there are on-chain unlocked locks
search_events = our_locksroot != EMPTY_HASH
# we want to unlock, because there are unlocked/unclaimed locks
search_state_changes = partner_locksroot != EMPTY_HASH
if not search_events and not search_state_changes:
# In the case that someone else sent the unlock we do nothing
# Check https://github.com/raiden-network/raiden/issues/3152
# for more details
log.warning(
"Onchain unlock already mined",
canonical_identifier=canonical_identifier,
channel_identifier=canonical_identifier.channel_identifier,
participant=to_checksum_address(participant),
)
return
if search_state_changes:
state_change_record = get_state_change_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=partner_locksroot,
sender=partner_address,
)
state_change_identifier = state_change_record.state_change_identifier
if not state_change_identifier:
raise RaidenUnrecoverableError(
f"Failed to find state that matches the current channel locksroots. "
f"chain_id:{raiden.chain.network_id} "
f"token_network:{to_checksum_address(token_network_identifier)} "
f"channel:{channel_identifier} "
f"participant:{to_checksum_address(participant)} "
f"our_locksroot:{to_hex(our_locksroot)} "
f"partner_locksroot:{to_hex(partner_locksroot)} "
)
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
canonical_identifier=canonical_identifier,
state_change_identifier=state_change_identifier,
)
assert restored_channel_state is not None
gain = get_batch_unlock_gain(restored_channel_state)
skip_unlock = (
restored_channel_state.partner_state.address == participant
and gain.from_partner_locks == 0
)
if not skip_unlock:
unlock(
raiden=raiden,
payment_channel=payment_channel,
end_state=restored_channel_state.partner_state,
participant=our_address,
partner=partner_address,
)
if search_events:
event_record = get_event_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=our_locksroot,
recipient=partner_address,
)
state_change_identifier = event_record.state_change_identifier
if not state_change_identifier:
raise RaidenUnrecoverableError(
f"Failed to find event that match current channel locksroots. "
f"chain_id:{raiden.chain.network_id} "
f"token_network:{to_checksum_address(token_network_identifier)} "
f"channel:{channel_identifier} "
f"participant:{to_checksum_address(participant)} "
f"our_locksroot:{to_hex(our_locksroot)} "
f"partner_locksroot:{to_hex(partner_locksroot)} "
)
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
canonical_identifier=canonical_identifier,
state_change_identifier=state_change_identifier,
)
assert restored_channel_state is not None
gain = get_batch_unlock_gain(restored_channel_state)
skip_unlock = (
restored_channel_state.our_state.address == participant
and gain.from_our_locks == 0
)
if not skip_unlock:
unlock(
raiden=raiden,
payment_channel=payment_channel,
end_state=restored_channel_state.our_state,
participant=partner_address,
partner=our_address,
)
def handle_contract_send_channelunlock(
raiden: "RaidenService",
chain_state: ChainState,
channel_unlock_event: ContractSendChannelBatchUnlock,
) -> None:
assert raiden.wal, "The Raiden Service must be initialize to handle events"
canonical_identifier = channel_unlock_event.canonical_identifier
token_network_address = canonical_identifier.token_network_address
channel_identifier = canonical_identifier.channel_identifier
participant = channel_unlock_event.sender
channel_state = get_channelstate_by_canonical_identifier(
chain_state=state_from_raiden(raiden),
canonical_identifier=canonical_identifier)
if channel_state is None:
raise RaidenUnrecoverableError(
"ContractSendChannelBatchUnlock for inexesting channel.")
confirmed_block_identifier = state_from_raiden(raiden).block_hash
payment_channel: PaymentChannel = raiden.proxy_manager.payment_channel(
channel_state=channel_state,
block_identifier=confirmed_block_identifier)
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=chain_state,
token_network_address=token_network_address,
partner_address=participant,
)
if not channel_state:
# channel was cleaned up already due to an unlock
raise RaidenUnrecoverableError(
f"Failed to find channel state with partner:"
f"{to_checksum_address(participant)}, "
f"token_network:{to_checksum_address(token_network_address)}")
our_address = channel_state.our_state.address
our_locksroot = channel_state.our_state.onchain_locksroot
partner_address = channel_state.partner_state.address
partner_locksroot = channel_state.partner_state.onchain_locksroot
# we want to unlock because there are on-chain unlocked locks
search_events = our_locksroot != LOCKSROOT_OF_NO_LOCKS
# we want to unlock, because there are unlocked/unclaimed locks
search_state_changes = partner_locksroot != LOCKSROOT_OF_NO_LOCKS
if not search_events and not search_state_changes:
# In the case that someone else sent the unlock we do nothing
# Check https://github.com/raiden-network/raiden/issues/3152
# for more details
log.warning(
"Onchain unlock already mined",
canonical_identifier=canonical_identifier,
channel_identifier=canonical_identifier.channel_identifier,
participant=to_checksum_address(participant),
)
return
if search_state_changes:
state_change_record = get_state_change_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=partner_locksroot,
sender=partner_address,
)
if state_change_record is None:
raise RaidenUnrecoverableError(
f"Failed to find state that matches the current channel locksroots. "
f"chain_id:{raiden.rpc_client.chain_id} "
f"token_network:{to_checksum_address(token_network_address)} "
f"channel:{channel_identifier} "
f"participant:{to_checksum_address(participant)} "
f"our_locksroot:{to_hex(our_locksroot)} "
f"partner_locksroot:{to_hex(partner_locksroot)} ")
state_change_identifier = state_change_record.state_change_identifier
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
canonical_identifier=canonical_identifier,
state_change_identifier=state_change_identifier,
)
gain = get_batch_unlock_gain(restored_channel_state)
skip_unlock = (restored_channel_state.partner_state.address
== participant and gain.from_partner_locks == 0)
if not skip_unlock:
unlock(
payment_channel=payment_channel,
end_state=restored_channel_state.partner_state,
sender=partner_address,
receiver=our_address,
given_block_identifier=channel_unlock_event.
triggered_by_block_hash,
)
if search_events:
event_record = get_event_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=our_locksroot,
recipient=partner_address,
)
if event_record is None:
raise RaidenUnrecoverableError(
f"Failed to find event that match current channel locksroots. "
f"chain_id:{raiden.rpc_client.chain_id} "
f"token_network:{to_checksum_address(token_network_address)} "
f"channel:{channel_identifier} "
f"participant:{to_checksum_address(participant)} "
f"our_locksroot:{to_hex(our_locksroot)} "
f"partner_locksroot:{to_hex(partner_locksroot)} ")
state_change_identifier = event_record.state_change_identifier
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
canonical_identifier=canonical_identifier,
state_change_identifier=state_change_identifier,
)
gain = get_batch_unlock_gain(restored_channel_state)
skip_unlock = (restored_channel_state.our_state.address
== participant and gain.from_our_locks == 0)
if not skip_unlock:
try:
unlock(
payment_channel=payment_channel,
end_state=restored_channel_state.our_state,
sender=our_address,
receiver=partner_address,
given_block_identifier=channel_unlock_event.
triggered_by_block_hash,
)
except InsufficientEth as e:
raise RaidenUnrecoverableError(str(e)) from e
def handle_contract_send_channelunlock(
raiden: 'RaidenService',
channel_unlock_event: ContractSendChannelBatchUnlock,
):
token_network_identifier = channel_unlock_event.token_network_identifier
channel_identifier = channel_unlock_event.channel_identifier
canonical_identifier = CanonicalIdentifier(
chain_identifier=raiden.chain.network_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
)
participant = channel_unlock_event.participant
token_address = channel_unlock_event.token_address
payment_channel: PaymentChannel = raiden.chain.payment_channel(
canonical_identifier=canonical_identifier, )
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=state_from_raiden(raiden),
token_network_id=token_network_identifier,
partner_address=participant,
)
if not channel_state:
# channel was cleaned up already due to an unlock
raise RaidenUnrecoverableError(
f'Failed to find channel state with partner '
f'{participant}, token_network:pex(token_network_identifier)',
)
our_address = channel_state.our_state.address
our_locksroot = channel_state.our_state.onchain_locksroot
partner_address = channel_state.partner_state.address
partner_locksroot = channel_state.partner_state.onchain_locksroot
# we want to unlock because there are on-chain unlocked locks
search_events = our_locksroot != EMPTY_HASH
# we want to unlock, because there are unlocked/unclaimed locks
search_state_changes = partner_locksroot != EMPTY_HASH
if not search_events and not search_state_changes:
# In the case that someone else sent the unlock we do nothing
# Check https://github.com/raiden-network/raiden/issues/3152
# for more details
log.warning(
'Onchain unlock already mined',
token_address=token_address,
channel_identifier=canonical_identifier.channel_identifier,
participant=participant,
)
return
if search_state_changes:
state_change_record = get_state_change_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=partner_locksroot,
sender=partner_address,
)
state_change_identifier = state_change_record.state_change_identifier
if not state_change_identifier:
raise RaidenUnrecoverableError(
f'Failed to find state that matches the current channel locksroots. '
f'chain_id:{raiden.chain.network_id} '
f'token:{to_checksum_address(token_address)} '
f'token_network:{to_checksum_address(token_network_identifier)} '
f'channel:{channel_identifier} '
f'participant:{to_checksum_address(participant)} '
f'our_locksroot:{to_hex(our_locksroot)} '
f'partner_locksroot:{to_hex(partner_locksroot)} ', )
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
payment_network_identifier=raiden.default_registry.address,
token_address=token_address,
channel_identifier=channel_identifier,
state_change_identifier=state_change_identifier,
)
gain = get_batch_unlock_gain(restored_channel_state, )
skip_unlock = (restored_channel_state.partner_state.address
== participant and gain.from_partner_locks == 0)
if not skip_unlock:
unlock(
raiden=raiden,
payment_channel=payment_channel,
end_state=restored_channel_state.partner_state,
participant=our_address,
partner=partner_address,
)
if search_events:
event_record = get_event_with_balance_proof_by_locksroot(
storage=raiden.wal.storage,
canonical_identifier=canonical_identifier,
locksroot=our_locksroot,
recipient=partner_address,
)
state_change_identifier = event_record.state_change_identifier
if not state_change_identifier:
raise RaidenUnrecoverableError(
f'Failed to find event that match current channel locksroots. '
f'chain_id:{raiden.chain.network_id} '
f'token:{to_checksum_address(token_address)} '
f'token_network:{to_checksum_address(token_network_identifier)} '
f'channel:{channel_identifier} '
f'participant:{to_checksum_address(participant)} '
f'our_locksroot:{to_hex(our_locksroot)} '
f'partner_locksroot:{to_hex(partner_locksroot)} ', )
restored_channel_state = channel_state_until_state_change(
raiden=raiden,
payment_network_identifier=raiden.default_registry.address,
token_address=token_address,
channel_identifier=canonical_identifier.channel_identifier,
state_change_identifier=state_change_identifier,
)
gain = get_batch_unlock_gain(restored_channel_state, )
skip_unlock = (restored_channel_state.our_state.address
== participant and gain.from_our_locks == 0)
if not skip_unlock:
unlock(
raiden=raiden,
payment_channel=payment_channel,
end_state=restored_channel_state.our_state,
participant=partner_address,
partner=our_address,
)
