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