def test_is_transaction_effect_satisfied(
chain_state,
token_network_state,
token_network_id,
netting_channel_state,
):
transaction = ContractSendChannelBatchUnlock(
token_address=token_network_state.token_address,
token_network_identifier=token_network_id,
channel_identifier=netting_channel_state.identifier,
participant=HOP2,
)
state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=UNIT_SECRETHASH,
token_network_identifier=token_network_id,
participant=HOP1,
partner=HOP2,
locksroot=EMPTY_MERKLE_ROOT,
unlocked_amount=0,
returned_tokens=0,
block_number=1,
)
# unlock for a channel in which this node is not a participant must return False
assert not is_transaction_effect_satisfied(chain_state, transaction, state_change)
# now call normally with us being the partner and not the participant
state_change.partner = netting_channel_state.our_state.address
state_change.participant = netting_channel_state.partner_state.address
assert not is_transaction_effect_satisfied(chain_state, transaction, state_change)
# finally call with us being the participant and not the partner which should check out
state_change.participant = netting_channel_state.our_state.address
state_change.partner = netting_channel_state.partner_state.address
assert is_transaction_effect_satisfied(chain_state, transaction, state_change)
def test_handle_contract_send_channelunlock_already_unlocked():
"""This is a test for the scenario where the onchain unlock has
already happened when we get to handle our own send unlock
transaction.
Regression test for https://github.com/raiden-network/raiden/issues/3152
"""
channel_identifier = 1
token_network_identifier = make_address()
token_address = make_address()
participant = make_address()
raiden = MockRaidenService()
def detail_participants(participant1, participant2, block_identifier,
channel_identifier):
transferred_amount = 1
locked_amount = 1
locksroot = make_32bytes()
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
our_details = ParticipantDetails(
address=raiden.address,
deposit=5,
withdrawn=0,
is_closer=False,
balance_hash=balance_hash,
nonce=1,
locksroot=locksroot,
locked_amount=locked_amount,
)
transferred_amount = 1
locked_amount = 1
# Let's mock here that partner locksroot is 0x0
locksroot = EMPTY_HASH
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
partner_details = ParticipantDetails(
address=participant,
deposit=5,
withdrawn=0,
is_closer=True,
balance_hash=balance_hash,
nonce=1,
locksroot=locksroot,
locked_amount=locked_amount,
)
return ParticipantsDetails(our_details, partner_details)
# make sure detail_participants returns partner data with a locksroot of 0x0
raiden.chain.token_network.detail_participants = detail_participants
event = ContractSendChannelBatchUnlock(
token_address=token_address,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
participant=participant,
)
# This should not throw an unrecoverable error
RaidenEventHandler().on_raiden_event(raiden=raiden, event=event)
def test_is_transaction_effect_satisfied(chain_state, token_network_id, netting_channel_state):
canonical_identifier = netting_channel_state.canonical_identifier
assert token_network_id == canonical_identifier.token_network_address
transaction = ContractSendChannelBatchUnlock(
canonical_identifier=canonical_identifier,
participant=netting_channel_state.partner_state.address,
triggered_by_block_hash=make_block_hash(),
)
state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=UNIT_SECRETHASH,
canonical_identifier=canonical_identifier,
participant=HOP1,
partner=HOP2,
locksroot=EMPTY_MERKLE_ROOT,
unlocked_amount=0,
returned_tokens=0,
block_number=1,
block_hash=make_block_hash(),
)
# unlock for a channel in which this node is not a participant must return False
assert not is_transaction_effect_satisfied(chain_state, transaction, state_change)
# now call normally with us being the partner and not the participant
state_change.partner = netting_channel_state.partner_state.address
state_change.participant = netting_channel_state.our_state.address
assert not is_transaction_effect_satisfied(chain_state, transaction, state_change)
# finally call with us being the participant and not the partner which should check out
state_change.participant = netting_channel_state.partner_state.address
state_change.partner = netting_channel_state.our_state.address
# ContractSendChannelBatchUnlock would only be satisfied if both sides are unlocked
# and if the channel was cleared
assert not is_transaction_effect_satisfied(chain_state, transaction, state_change)
channel_settled = ContractReceiveChannelSettled(
transaction_hash=bytes(32),
canonical_identifier=canonical_identifier,
our_onchain_locksroot=EMPTY_MERKLE_ROOT,
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
block_number=1,
block_hash=make_block_hash(),
)
iteration = state_transition(chain_state=chain_state, state_change=channel_settled)
assert is_transaction_effect_satisfied(iteration.new_state, transaction, state_change)
def events_for_unlock_if_closed(
channelidentifiers_to_channels,
transfers_pair,
secret,
secrethash,
):
""" Unlock on chain if the payer channel is closed and the secret is known.
If a channel is closed because of another task a balance proof will not be
received, so there is no reason to wait for the unsafe region before
calling close.
This may break the reverse reveal order:
Path: A -- B -- C -- B -- D
B learned the secret from D and has revealed to C.
C has not confirmed yet.
channel(A, B).closed is True.
B will unlock on channel(A, B) before C's confirmation.
A may learn the secret faster than other nodes.
"""
events = list()
pending_transfers_pairs = get_pending_transfer_pairs(transfers_pair)
for pair in pending_transfers_pairs:
payer_channel = get_payer_channel(channelidentifiers_to_channels, pair)
payer_channel_open = channel.get_status(
payer_channel) == CHANNEL_STATE_OPENED
# The unlock is done by the channel
if not payer_channel_open:
pair.payer_state = 'payer_waiting_unlock'
partner_state = payer_channel.partner_state
lock = channel.get_lock(partner_state, secrethash)
unlock_proof = channel.compute_proof_for_lock(
partner_state,
secret,
lock,
)
unlock = ContractSendChannelBatchUnlock(
payer_channel.token_network_identifier,
payer_channel.identifier,
[unlock_proof],
)
events.append(unlock)
return events
def test_handle_contract_send_channelunlock_already_unlocked():
"""This is a test for the scenario where the onchain unlock has
already happened when we get to handle our own send unlock
transaction.
Regression test for https://github.com/raiden-network/raiden/issues/3152
"""
channel_identifier = 1
payment_network_identifier = make_address()
token_network_identifier = make_address()
participant = make_address()
raiden = make_raiden_service_mock(
payment_network_identifier=payment_network_identifier,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
partner=participant,
)
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=state_from_raiden(raiden),
token_network_id=token_network_identifier,
partner_address=participant,
)
channel_state.our_state.onchain_locksroot = EMPTY_MERKLE_ROOT
channel_state.partner_state.onchain_locksroot = EMPTY_MERKLE_ROOT
def detail_participants( # pylint: disable=unused-argument
participant1, participant2, block_identifier, channel_identifier):
transferred_amount = 1
locked_amount = 1
locksroot = make_32bytes()
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
our_details = ParticipantDetails(
address=raiden.address,
deposit=5,
withdrawn=0,
is_closer=False,
balance_hash=balance_hash,
nonce=1,
locksroot=locksroot,
locked_amount=locked_amount,
)
transferred_amount = 1
locked_amount = 1
# Let's mock here that partner locksroot is 0x0
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
partner_details = ParticipantDetails(
address=participant,
deposit=5,
withdrawn=0,
is_closer=True,
balance_hash=balance_hash,
nonce=1,
locksroot=EMPTY_HASH,
locked_amount=locked_amount,
)
return ParticipantsDetails(our_details, partner_details)
# make sure detail_participants returns partner data with a locksroot of 0x0
raiden.chain.token_network.detail_participants = detail_participants
event = ContractSendChannelBatchUnlock(
canonical_identifier=make_canonical_identifier(
token_network_address=token_network_identifier,
channel_identifier=channel_identifier),
participant=participant,
triggered_by_block_hash=make_block_hash(),
)
# This should not throw an unrecoverable error
RaidenEventHandler().on_raiden_event(
raiden=raiden,
chain_state=raiden.wal.state_manager.current_state,
event=event)
def test_handle_contract_send_channelunlock_already_unlocked():
"""This is a test for the scenario where the onchain unlock has
already happened when we get to handle our own send unlock
transaction.
Regression test for https://github.com/raiden-network/raiden/issues/3152
"""
channel_identifier = ChannelID(1)
token_network_registry_address = make_token_network_registry_address()
token_network_address = make_token_network_address()
participant = make_address()
raiden = make_raiden_service_mock(
token_network_registry_address=token_network_registry_address,
token_network_address=token_network_address,
channel_identifier=channel_identifier,
partner=participant,
)
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=state_from_raiden(raiden),
token_network_address=token_network_address,
partner_address=participant,
)
assert channel_state
channel_state.our_state.onchain_locksroot = LOCKSROOT_OF_NO_LOCKS
channel_state.partner_state.onchain_locksroot = LOCKSROOT_OF_NO_LOCKS
def detail_participants(_participant1, _participant2, _block_identifier,
_channel_identifier):
transferred_amount = TokenAmount(1)
locked_amount = LockedAmount(1)
locksroot = make_locksroot()
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
our_details = ParticipantDetails(
address=raiden.address,
deposit=TokenAmount(5),
withdrawn=WithdrawAmount(0),
is_closer=False,
balance_hash=balance_hash,
nonce=Nonce(1),
locksroot=locksroot,
locked_amount=locked_amount,
)
transferred_amount = TokenAmount(1)
locked_amount = LockedAmount(1)
# Let's mock here that partner locksroot is 0x0
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
partner_details = ParticipantDetails(
address=participant,
deposit=TokenAmount(5),
withdrawn=WithdrawAmount(0),
is_closer=True,
balance_hash=balance_hash,
nonce=Nonce(1),
locksroot=LOCKSROOT_OF_NO_LOCKS,
locked_amount=locked_amount,
)
return ParticipantsDetails(our_details, partner_details)
# make sure detail_participants returns partner data with a locksroot of 0x0
raiden.proxy_manager.token_network.detail_participants = detail_participants
event = ContractSendChannelBatchUnlock(
canonical_identifier=make_canonical_identifier(
token_network_address=token_network_address,
channel_identifier=channel_identifier),
sender=participant,
triggered_by_block_hash=make_block_hash(),
)
# This should not throw an unrecoverable error
RaidenEventHandler().on_raiden_events(
raiden=raiden,
chain_state=raiden.wal.state_manager.current_state,
events=[event])