def handle_send_secretreveal(
raiden: "RaidenService", reveal_secret_event: SendSecretReveal
) -> None: # pragma: no unittest
reveal_secret_message = message_from_sendevent(reveal_secret_event)
raiden.sign(reveal_secret_message)
raiden.transport.send_async(reveal_secret_event.queue_identifier,
reveal_secret_message)
def handle_send_balanceproof(
raiden: "RaidenService", balance_proof_event: SendBalanceProof
) -> None: # pragma: no unittest
unlock_message = message_from_sendevent(balance_proof_event)
raiden.sign(unlock_message)
raiden.transport.send_async(balance_proof_event.queue_identifier,
unlock_message)
def handle_send_lockexpired(
raiden: "RaidenService",
send_lock_expired: SendLockExpired) -> None: # pragma: no unittest
lock_expired_message = message_from_sendevent(send_lock_expired)
raiden.sign(lock_expired_message)
raiden.transport.send_async(send_lock_expired.queue_identifier,
lock_expired_message)
def handle_send_processed(
raiden: "RaidenService",
processed_event: SendProcessed,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
processed_message = message_from_sendevent(processed_event)
raiden.sign(processed_message)
message_queues[processed_event.queue_identifier].append(processed_message)
def handle_send_refundtransfer(
raiden: "RaidenService",
refund_transfer_event: SendRefundTransfer,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
refund_transfer_message = message_from_sendevent(refund_transfer_event)
raiden.sign(refund_transfer_message)
message_queues[refund_transfer_event.queue_identifier].append(refund_transfer_message)
def handle_send_withdrawexpired(
raiden: "RaidenService",
withdraw_expired_event: SendWithdrawExpired,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None:
withdraw_expired_message = message_from_sendevent(withdraw_expired_event)
raiden.sign(withdraw_expired_message)
message_queues[withdraw_expired_event.queue_identifier].append(withdraw_expired_message)
def handle_send_balanceproof(
raiden: "RaidenService",
balance_proof_event: SendUnlock,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
unlock_message = message_from_sendevent(balance_proof_event)
raiden.sign(unlock_message)
message_queues[balance_proof_event.queue_identifier].append(unlock_message)
def handle_send_secretreveal(
raiden: "RaidenService",
reveal_secret_event: SendSecretReveal,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
reveal_secret_message = message_from_sendevent(reveal_secret_event)
raiden.sign(reveal_secret_message)
message_queues[reveal_secret_event.queue_identifier].append(reveal_secret_message)
def handle_send_lockedtransfer(
raiden: "RaidenService",
send_locked_transfer: SendLockedTransfer,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
mediated_transfer_message = message_from_sendevent(send_locked_transfer)
raiden.sign(mediated_transfer_message)
message_queues[send_locked_transfer.queue_identifier].append(mediated_transfer_message)
def handle_send_lockexpired(
raiden: "RaidenService",
send_lock_expired: SendLockExpired,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
lock_expired_message = message_from_sendevent(send_lock_expired)
raiden.sign(lock_expired_message)
message_queues[send_lock_expired.queue_identifier].append(lock_expired_message)
def handle_send_secretrequest(
raiden: "RaidenService",
chain_state: ChainState,
secret_request_event: SendSecretRequest,
message_queues: Dict[QueueIdentifier, List[Message]],
) -> None: # pragma: no unittest
if reveal_secret_with_resolver(raiden, chain_state, secret_request_event):
return
secret_request_message = message_from_sendevent(secret_request_event)
raiden.sign(secret_request_message)
message_queues[secret_request_event.queue_identifier].append(secret_request_message)
def test_regression_onchain_secret_reveal_must_update_channel_state():
""" If a secret is learned off-chain and then on-chain, the state of the
lock must be updated in the channel.
"""
pseudo_random_generator = random.Random()
setup = factories.make_transfers_pair(2, block_number=10)
mediator_state = MediatorTransferState(secrethash=UNIT_SECRETHASH,
routes=setup.channels.get_routes())
mediator_state.transfers_pair = setup.transfers_pair
secret = UNIT_SECRET
secrethash = UNIT_SECRETHASH
payer_channel = mediator.get_payer_channel(setup.channel_map,
setup.transfers_pair[0])
payee_channel = mediator.get_payee_channel(setup.channel_map,
setup.transfers_pair[0])
lock = payer_channel.partner_state.secrethashes_to_lockedlocks[secrethash]
mediator.state_transition(
mediator_state=mediator_state,
state_change=ReceiveSecretReveal(
secret=secret, sender=payee_channel.partner_state.address),
channelidentifiers_to_channels=setup.channel_map,
nodeaddresses_to_networkstates=setup.channels.
nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=setup.block_number,
block_hash=setup.block_hash,
)
assert secrethash in payer_channel.partner_state.secrethashes_to_unlockedlocks
secret_registry_address = factories.make_address()
transaction_hash = factories.make_address()
mediator.state_transition(
mediator_state=mediator_state,
state_change=ContractReceiveSecretReveal(
transaction_hash=transaction_hash,
secret_registry_address=secret_registry_address,
secrethash=secrethash,
secret=secret,
block_number=setup.block_number,
block_hash=setup.block_hash,
),
channelidentifiers_to_channels=setup.channel_map,
nodeaddresses_to_networkstates=setup.channels.
nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=setup.block_number,
block_hash=setup.block_hash,
)
assert secrethash in payer_channel.partner_state.secrethashes_to_onchain_unlockedlocks
# Creates a transfer as it was from the *partner*
send_lock_expired, _ = channel.create_sendexpiredlock(
sender_end_state=payer_channel.partner_state,
locked_lock=lock,
pseudo_random_generator=pseudo_random_generator,
chain_id=payer_channel.chain_id,
token_network_address=payer_channel.token_network_address,
channel_identifier=payer_channel.identifier,
recipient=payer_channel.our_state.address,
)
assert send_lock_expired
expired_message = message_from_sendevent(send_lock_expired)
expired_message.sign(LocalSigner(setup.channels.partner_privatekeys[0]))
balance_proof = balanceproof_from_envelope(expired_message)
message_identifier = message_identifier_from_prng(pseudo_random_generator)
expired_block_number = channel.get_sender_expiration_threshold(
lock.expiration)
mediator.state_transition(
mediator_state=mediator_state,
state_change=ReceiveLockExpired(
sender=balance_proof.sender, # pylint: disable=no-member
balance_proof=balance_proof,
secrethash=secrethash,
message_identifier=message_identifier,
),
channelidentifiers_to_channels=setup.channel_map,
nodeaddresses_to_networkstates=setup.channels.
nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=expired_block_number,
block_hash=factories.make_block_hash(),
)
assert secrethash in payer_channel.partner_state.secrethashes_to_onchain_unlockedlocks
def test_regression_mediator_task_no_routes():
""" The mediator must only be cleared after the waiting transfer's lock has
been handled.
If a node receives a transfer to mediate, but there is no route available
(because there is no sufficient capacity or the partner nodes are offline),
and a refund is not possible, the mediator task must not be cleared,
otherwise followup remove expired lock messages wont be processed and the
nodes will get out of sync.
"""
pseudo_random_generator = random.Random()
channels = make_channel_set([
NettingChannelStateProperties(
our_state=NettingChannelEndStateProperties(balance=0),
partner_state=NettingChannelEndStateProperties(
balance=UNIT_TRANSFER_AMOUNT,
address=HOP2,
privatekey=HOP2_KEY),
)
])
payer_transfer = factories.make_signed_transfer_for(
channels[0],
factories.LockedTransferSignedStateProperties(sender=HOP2,
pkey=HOP2_KEY,
expiration=30),
)
init_state_change = ActionInitMediator(
from_hop=channels.get_hop(0),
route_states=channels.get_routes(),
from_transfer=payer_transfer,
balance_proof=payer_transfer.balance_proof,
sender=payer_transfer.balance_proof.sender, # pylint: disable=no-member
)
init_iteration = mediator.state_transition(
mediator_state=None,
state_change=init_state_change,
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=5,
block_hash=factories.make_block_hash(),
)
msg = "The task must not be cleared, even if there is no route to forward the transfer"
assert init_iteration.new_state is not None, msg
assert init_iteration.new_state.waiting_transfer.transfer == payer_transfer
assert search_for_item(init_iteration.events, SendLockedTransfer,
{}) is None
assert search_for_item(init_iteration.events, SendRefundTransfer,
{}) is None
secrethash = UNIT_SECRETHASH
lock = channels[0].partner_state.secrethashes_to_lockedlocks[secrethash]
# Creates a transfer as it was from the *partner*
send_lock_expired, _ = channel.create_sendexpiredlock(
sender_end_state=channels[0].partner_state,
locked_lock=lock,
pseudo_random_generator=pseudo_random_generator,
chain_id=channels[0].chain_id,
token_network_address=channels[0].token_network_address,
channel_identifier=channels[0].identifier,
recipient=channels[0].our_state.address,
)
assert send_lock_expired
lock_expired_message = message_from_sendevent(send_lock_expired)
lock_expired_message.sign(LocalSigner(channels.partner_privatekeys[0]))
balance_proof = balanceproof_from_envelope(lock_expired_message)
message_identifier = message_identifier_from_prng(pseudo_random_generator)
# Regression: The mediator must still be able to process the block which
# expires the lock
expired_block_number = channel.get_sender_expiration_threshold(
lock.expiration)
block_hash = factories.make_block_hash()
expire_block_iteration = mediator.state_transition(
mediator_state=init_iteration.new_state,
state_change=Block(block_number=expired_block_number,
gas_limit=0,
block_hash=block_hash),
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=expired_block_number,
block_hash=block_hash,
)
assert expire_block_iteration.new_state is not None
receive_expired_iteration = mediator.state_transition(
mediator_state=expire_block_iteration.new_state,
state_change=ReceiveLockExpired(
sender=balance_proof.sender, # pylint: disable=no-member
balance_proof=balance_proof,
secrethash=secrethash,
message_identifier=message_identifier,
),
channelidentifiers_to_channels=channels.channel_map,
nodeaddresses_to_networkstates=channels.nodeaddresses_to_networkstates,
pseudo_random_generator=pseudo_random_generator,
block_number=expired_block_number,
block_hash=block_hash,
)
msg = "The only used channel had the lock cleared, the task must be cleared"
assert receive_expired_iteration.new_state is None, msg
assert secrethash not in channels[
0].partner_state.secrethashes_to_lockedlocks
