def test_handle_offchain_secretreveal(): """ The target node needs to inform the secret to the previous node to receive an updated balance proof. """ setup = make_target_state() state_change = ReceiveSecretReveal(UNIT_SECRET, setup.initiator) iteration = target.handle_offchain_secretreveal( target_state=setup.new_state, state_change=state_change, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=setup.block_number, ) assert len(iteration.events) == 1 reveal = iteration.events[0] assert isinstance(reveal, SendSecretReveal) assert iteration.new_state.state == 'reveal_secret' assert reveal.secret == UNIT_SECRET assert reveal.recipient == setup.new_state.route.node_address # if we get an empty hash secret make sure it's rejected secret = EMPTY_HASH state_change = ReceiveSecretReveal(secret, setup.initiator) iteration = target.handle_offchain_secretreveal( target_state=setup.new_state, state_change=state_change, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=setup.block_number, ) assert len(iteration.events) == 0
def wrong_address_receive_secret_reveal(self, previous_action_with_address, invalid_sender): previous_action, client, our_address = self._unwrap(previous_action_with_address) secret = self.secrethash_to_secret[previous_action.from_transfer.lock.secrethash] invalid_action = ReceiveSecretReveal(secret, invalid_sender) result = node.state_transition(client.chain_state, invalid_action) assert not result.events valid_sender = previous_action.from_transfer.target valid_action = ReceiveSecretReveal(secret, valid_sender) return WithOurAddress(our_address=our_address, data=valid_action)
def make_mediated_transfer(registry_address, from_channel, partner_channel, initiator, target, lock, pkey, secret=None): """ Helper to create and register a mediated transfer from `from_channel` to `partner_channel`.""" payment_identifier = channel.get_next_nonce(from_channel.our_state) message_identifier = random.randint(0, UINT64_MAX) lockedtransfer = channel.send_lockedtransfer( registry_address, from_channel, initiator, target, lock.amount, message_identifier, payment_identifier, lock.expiration, lock.secrethash, ) mediated_transfer_msg = LockedTransfer.from_event(lockedtransfer) address = privatekey_to_address(pkey) sign_key = PrivateKey(pkey) mediated_transfer_msg.sign(sign_key, address) # compute the signature balance_proof = balanceproof_from_envelope(mediated_transfer_msg) lockedtransfer.balance_proof = balance_proof # if this fails it's not the right key for the current `from_channel` assert mediated_transfer_msg.sender == from_channel.our_state.address receive_lockedtransfer = lockedtransfersigned_from_message( mediated_transfer_msg) channel.handle_receive_lockedtransfer( partner_channel, receive_lockedtransfer, ) if secret is not None: random_sender = make_address() from_secretreveal = ReceiveSecretReveal(secret, random_sender) channel.handle_receive_secretreveal(from_channel, from_secretreveal) partner_secretreveal = ReceiveSecretReveal(secret, random_sender) channel.handle_receive_secretreveal(partner_channel, partner_secretreveal) return mediated_transfer_msg
def wrong_address_receive_secret_reveal(self, previous_action, invalid_sender): secret = self.secrethash_to_secret[ previous_action.from_transfer.lock.secrethash] invalid_action = ReceiveSecretReveal(secret, invalid_sender) result = node.state_transition(self.chain_state, invalid_action) assert not result.events valid_sender = previous_action.from_transfer.target valid_action = ReceiveSecretReveal(secret, valid_sender) return valid_action
def test_state_wait_unlock_valid(): setup = setup_initiator_tests() # setup the state for the wait unlock setup.current_state.initiator.revealsecret = SendSecretReveal( recipient=UNIT_TRANSFER_TARGET, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, message_identifier=UNIT_TRANSFER_IDENTIFIER, secret=UNIT_SECRET, ) state_change = ReceiveSecretReveal( secret=UNIT_SECRET, sender=setup.channel.partner_state.address, ) iteration = initiator_manager.state_transition( setup.current_state, state_change, setup.channel_map, setup.prng, setup.block_number, ) assert len(iteration.events) == 3 assert any(isinstance(e, SendBalanceProof) for e in iteration.events) assert any(isinstance(e, EventPaymentSentSuccess) for e in iteration.events) assert any(isinstance(e, EventUnlockSuccess) for e in iteration.events) balance_proof = next(e for e in iteration.events if isinstance(e, SendBalanceProof)) complete = next(e for e in iteration.events if isinstance(e, EventPaymentSentSuccess)) assert balance_proof.recipient == setup.channel.partner_state.address assert complete.identifier == UNIT_TRANSFER_IDENTIFIER assert iteration.new_state is None, 'state must be cleaned'
def message_secret(self, message): self.balance_proof(message) hashlock = message.hashlock identifier = message.identifier secret = message.secret self.raiden.register_secret(secret) channel = None try: channel = self.raiden.find_channel_by_address(message.channel) except ValueError: log.info('Message for unknown channel: {}'.format( pex(message.channel))) else: self.raiden.handle_secret( identifier, channel.token_address, secret, message, hashlock, ) self.raiden.greenlet_task_dispatcher.dispatch_message( message, hashlock) state_change = ReceiveSecretReveal( secret, message.sender, ) self.raiden.state_machine_event_handler.log_and_dispatch_by_identifier( identifier, state_change, )
def test_target_lock_is_expired_if_secret_is_not_registered_onchain(): lock_amount = 7 block_number = 1 initiator = factories.HOP6 pseudo_random_generator = random.Random() our_balance = 100 our_address = factories.make_address() partner_balance = 130 from_channel = factories.make_channel( our_address=our_address, our_balance=our_balance, partner_address=UNIT_TRANSFER_SENDER, partner_balance=partner_balance, ) from_route = factories.route_from_channel(from_channel) expiration = block_number + from_channel.settle_timeout - from_channel.reveal_timeout from_transfer = factories.make_signed_transfer_for( from_channel, lock_amount, initiator, our_address, expiration, UNIT_SECRET, ) init = ActionInitTarget( from_route, from_transfer, ) init_transition = target.state_transition( None, init, from_channel, pseudo_random_generator, block_number, ) assert init_transition.new_state is not None secret_reveal_iteration = target.state_transition( target_state=init_transition.new_state, state_change=ReceiveSecretReveal(UNIT_SECRET, from_channel.partner_state.address), channel_state=from_channel, pseudo_random_generator=pseudo_random_generator, block_number=block_number, ) expired_block_number = from_transfer.lock.expiration + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS iteration = target.state_transition( target_state=secret_reveal_iteration.new_state, state_change=Block(expired_block_number, None, None), channel_state=from_channel, pseudo_random_generator=pseudo_random_generator, block_number=expired_block_number, ) assert must_contain_entry(iteration.events, EventUnlockClaimFailed, {})
def test_state_wait_unlock_invalid(): setup = setup_initiator_tests() identifier = setup.channel.identifier target_address = factories.HOP2 # setup the state for the wait unlock setup.current_state.initiator.revealsecret = SendSecretReveal( recipient=target_address, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, message_identifier=identifier, secret=UNIT_SECRET, ) before_state = deepcopy(setup.current_state) state_change = ReceiveSecretReveal( secret=UNIT_SECRET, sender=factories.ADDR, ) iteration = initiator_manager.state_transition( setup.current_state, state_change, setup.channel_map, setup.prng, setup.block_number, ) assert not iteration.events assert iteration.new_state == before_state
def test_handle_secretreveal(): """ The target node needs to inform the secret to the previous node to receive an updated balance proof. """ amount = 3 block_number = 1 expiration = block_number + factories.UNIT_REVEAL_TIMEOUT initiator = factories.HOP1 our_address = factories.ADDR secret = factories.UNIT_SECRET pseudo_random_generator = random.Random() channel_state, state = make_target_state( our_address, amount, block_number, initiator, expiration, ) state_change = ReceiveSecretReveal(secret, initiator) iteration = target.handle_secretreveal( state, state_change, channel_state, pseudo_random_generator, ) assert len(iteration.events) == 1 reveal = iteration.events[0] assert isinstance(reveal, SendRevealSecret) assert iteration.new_state.state == 'reveal_secret' assert reveal.secret == secret assert reveal.recipient == state.route.node_address
def handle_message_revealsecret(raiden: 'RaidenService', message: RevealSecret): state_change = ReceiveSecretReveal( message.secret, message.sender, ) raiden.handle_state_change(state_change)
def handle_channel_unlock(node_state, state_change): token_address = state_change.token_address payment_network_state, token_network_state = get_networks( node_state, state_change.payment_network_identifier, state_change.token_address, ) # first dispatch the unlock claim to update the channel events = [] if token_network_state: pseudo_random_generator = node_state.pseudo_random_generator sub_iteration = token_network.subdispatch_to_channel_by_id( token_network_state, state_change, pseudo_random_generator, node_state.block_number, ) events.extend(sub_iteration.events) if sub_iteration.new_state is None: del payment_network_state.tokenaddresses_to_tokennetworks[token_address] # second emulate a secret reveal, to register the secret with all the other # channels and proceed with the protocol state_change = ReceiveSecretReveal(state_change.secret, None) sub_iteration_secret_reveal = handle_secret_reveal( node_state, state_change, ) events.extend(sub_iteration_secret_reveal.events) return TransitionResult(node_state, events)
def wrong_secret_receive_secret_reveal(self, previous_action_with_address, secret): previous_action, client, _ = self._unwrap(previous_action_with_address) sender = previous_action.from_transfer.target action = ReceiveSecretReveal(secret, sender) result = node.state_transition(client.chain_state, action) assert not result.events
def test_handle_onchain_secretreveal(): """ The target node must update the lock state when the secret is registered in the blockchain. """ setup = make_target_state( block_number=1, expiration=1 + factories.UNIT_REVEAL_TIMEOUT, ) assert factories.UNIT_SECRETHASH in setup.channel.partner_state.secrethashes_to_lockedlocks offchain_secret_reveal_iteration = target.state_transition( target_state=setup.new_state, state_change=ReceiveSecretReveal(UNIT_SECRET, setup.initiator), channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=setup.block_number, ) assert UNIT_SECRETHASH in setup.channel.partner_state.secrethashes_to_unlockedlocks assert UNIT_SECRETHASH not in setup.channel.partner_state.secrethashes_to_lockedlocks # Make sure that an emptyhash on chain reveal is rejected. block_number_prior_the_expiration = setup.expiration - 2 onchain_reveal = ContractReceiveSecretReveal( transaction_hash=factories.make_address(), secret_registry_address=factories.make_address(), secrethash=EMPTY_HASH_KECCAK, secret=EMPTY_HASH, block_number=block_number_prior_the_expiration, ) onchain_secret_reveal_iteration = target.state_transition( target_state=offchain_secret_reveal_iteration.new_state, state_change=onchain_reveal, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=block_number_prior_the_expiration, ) unlocked_onchain = setup.channel.partner_state.secrethashes_to_onchain_unlockedlocks assert EMPTY_HASH_KECCAK not in unlocked_onchain # now let's go for the actual secret onchain_reveal.secret = UNIT_SECRET onchain_reveal.secrethash = UNIT_SECRETHASH onchain_secret_reveal_iteration = target.state_transition( target_state=offchain_secret_reveal_iteration.new_state, state_change=onchain_reveal, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=block_number_prior_the_expiration, ) unlocked_onchain = setup.channel.partner_state.secrethashes_to_onchain_unlockedlocks assert UNIT_SECRETHASH in unlocked_onchain # Check that after we register a lock on-chain handling the block again will # not cause us to attempt an onchain re-register extra_block_handle_transition = target.handle_block( target_state=onchain_secret_reveal_iteration.new_state, channel_state=setup.channel, block_number=block_number_prior_the_expiration + 1, ) assert len(extra_block_handle_transition.events) == 0
def test_handle_secretreveal(): """ The target node needs to inform the secret to the previous node to receive an updated balance proof. """ amount = 3 block_number = 1 expire = block_number + factories.UNIT_REVEAL_TIMEOUT initiator = factories.HOP1 our_address = factories.ADDR secret = factories.UNIT_SECRET state = make_target_state( our_address, amount, block_number, initiator, expire, ) state_change = ReceiveSecretReveal(secret, initiator) iteration = target.handle_secretreveal(state, state_change) reveal = [e for e in iteration.events if isinstance(e, SendRevealSecret)] assert iteration.new_state.state == 'reveal_secret' assert reveal[0].identifier == state.from_transfer.identifier assert reveal[0].secret == secret assert reveal[0].receiver == state.from_route.node_address assert reveal[0].sender == our_address
def valid_receive_secret_reveal(self, previous_action): secret = self.secrethash_to_secret[ previous_action.from_transfer.lock.secrethash] sender = previous_action.from_transfer.target recipient = previous_action.from_transfer.initiator action = ReceiveSecretReveal(secret=secret, sender=sender) result = node.state_transition(self.chain_state, action) expiration = previous_action.from_transfer.lock.expiration in_time = self.block_number < expiration - DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS still_waiting = self.block_number < expiration + DEFAULT_WAIT_BEFORE_LOCK_REMOVAL if in_time and self.channel_opened(sender) and self.channel_opened( recipient): assert event_types_match(result.events, SendSecretReveal, SendBalanceProof, EventUnlockSuccess) self.event("Unlock successful.") self.waiting_for_unlock[secret] = recipient elif still_waiting and self.channel_opened(recipient): assert event_types_match(result.events, SendSecretReveal) self.event("Unlock failed, secret revealed too late.") else: assert not result.events self.event( "ReceiveSecretRevealed after removal of lock - dropped.") return action
def replay_receive_secret_reveal_scrambled_sender( self, previous_action_with_address, invalid_sender ): previous_action, client, _ = self._unwrap(previous_action_with_address) action = ReceiveSecretReveal(previous_action.secret, invalid_sender) result = node.state_transition(client.chain_state, action) assert not result.events
def handle_message_revealsecret( raiden: "RaidenService", message: RevealSecret # pylint: disable=unused-argument ) -> List[StateChange]: assert message.sender, "message must be signed" secret_reveal = ReceiveSecretReveal(secret=message.secret, sender=message.sender) return [secret_reveal]
def message_revealsecret(self, message): secret = message.secret sender = message.sender self.raiden.register_secret(secret) state_change = ReceiveSecretReveal(secret, sender) self.raiden.state_machine_event_handler.log_and_dispatch_to_all_tasks( state_change)
def test_state_wait_unlock_valid(): identifier = 1 amount = factories.UNIT_TRANSFER_AMOUNT block_number = 1 mediator_address = factories.HOP1 target_address = factories.HOP2 our_address = factories.ADDR secret_generator = SequenceGenerator() token = factories.UNIT_TOKEN_ADDRESS routes = [factories.make_route(mediator_address, available_balance=amount)] current_state = make_initiator_state( routes, target_address, block_number=block_number, our_address=our_address, secret_generator=secret_generator, identifier=identifier, token=token, ) secret = secret_generator.secrets[0] assert secret is not None # setup the state for the wait unlock current_state.revealsecret = SendRevealSecret( identifier, secret, token, target_address, our_address, ) initiator_state_machine = StateManager( initiator.state_transition, current_state, ) state_change = ReceiveSecretReveal( secret=secret, sender=mediator_address, ) events = initiator_state_machine.dispatch(state_change) assert len(events) == 3 assert any(isinstance(e, SendBalanceProof) for e in events) assert any(isinstance(e, EventTransferSentSuccess) for e in events) assert any(isinstance(e, EventUnlockSuccess) for e in events) balance_proof = next(e for e in events if isinstance(e, SendBalanceProof)) complete = next(e for e in events if isinstance(e, EventTransferSentSuccess)) assert balance_proof.receiver == mediator_address assert complete.identifier == identifier assert initiator_state_machine.current_state is None, 'state must be cleaned'
def test_handle_onchain_secretreveal(): """ The target node must update the lock state when the secret is registered in the blockchain. """ amount = 3 block_number = 1 expiration = block_number + factories.UNIT_REVEAL_TIMEOUT initiator = factories.HOP1 our_address = factories.ADDR secret = factories.UNIT_SECRET pseudo_random_generator = random.Random() channel_state, state = make_target_state( our_address, amount, block_number, initiator, expiration, ) assert factories.UNIT_SECRETHASH in channel_state.partner_state.secrethashes_to_lockedlocks offchain_secret_reveal_iteration = target.state_transition( state, ReceiveSecretReveal(secret, initiator), channel_state, pseudo_random_generator, block_number, ) assert factories.UNIT_SECRETHASH in channel_state.partner_state.secrethashes_to_unlockedlocks assert factories.UNIT_SECRETHASH not in channel_state.partner_state.secrethashes_to_lockedlocks block_number_prior_the_expiration = expiration - 2 onchain_secret_reveal_iteration = target.state_transition( offchain_secret_reveal_iteration.new_state, ContractReceiveSecretReveal( transaction_hash=factories.make_address(), secret_registry_address=factories.make_address(), secrethash=UNIT_SECRETHASH, secret=UNIT_SECRET, block_number=block_number_prior_the_expiration, ), channel_state, pseudo_random_generator, block_number_prior_the_expiration, ) unlocked_onchain = channel_state.partner_state.secrethashes_to_onchain_unlockedlocks assert factories.UNIT_SECRETHASH in unlocked_onchain # Check that after we register a lock on-chain handling the block again will # not cause us to attempt an onchain re-register extra_block_handle_transition = target.handle_block( onchain_secret_reveal_iteration.new_state, channel_state, block_number_prior_the_expiration + 1, ) assert len(extra_block_handle_transition.events) == 0
def test_state_transition(): """ Happy case testing. """ amount = 7 block_number = 1 initiator = factories.HOP6 expire = block_number + factories.UNIT_REVEAL_TIMEOUT from_route, from_transfer = factories.make_from( amount, factories.ADDR, expire, initiator, ) init = ActionInitTarget( factories.ADDR, from_route, from_transfer, block_number, ) init_transition = target.state_transition(None, init) assert init_transition.new_state is not None assert init_transition.new_state.from_route == from_route assert init_transition.new_state.from_transfer == from_transfer first_new_block = Block(block_number + 1) first_block_iteration = target.state_transition(init_transition.new_state, first_new_block) assert first_block_iteration.new_state.block_number == block_number + 1 secret_reveal = ReceiveSecretReveal(factories.UNIT_SECRET, initiator) reveal_iteration = target.state_transition(first_block_iteration.new_state, secret_reveal) assert reveal_iteration.new_state.from_transfer.secret == factories.UNIT_SECRET second_new_block = Block(block_number + 2) second_block_iteration = target.state_transition(init_transition.new_state, second_new_block) assert second_block_iteration.new_state.block_number == block_number + 2 nonce = 11 transferred_amount = 13 locksroot = '' message_hash = '' balance_proof = ReceiveBalanceProof( from_transfer.identifier, from_route.node_address, nonce, transferred_amount, locksroot, from_route.channel_address, message_hash, ) proof_iteration = target.state_transition(init_transition.new_state, balance_proof) assert proof_iteration.new_state is None
def handle_message_revealsecret(raiden: RaidenService, message: RevealSecret, is_light_client=False) -> None: if is_light_client: state_change = ReceiveSecretRevealLight(message.secret, message.sender, message) raiden.handle_and_track_state_change(state_change) else: state_change = ReceiveSecretReveal(message.secret, message.sender) raiden.handle_and_track_state_change(state_change)
def test_state_wait_unlock_valid(): block_number = 1 pseudo_random_generator = random.Random() channel1 = factories.make_channel( our_balance=UNIT_TRANSFER_AMOUNT, token_address=UNIT_TOKEN_ADDRESS, token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS, ) channelmap = {channel1.identifier: channel1} available_routes = [factories.route_from_channel(channel1)] current_state = make_initiator_state( available_routes, factories.UNIT_TRANSFER_DESCRIPTION, channelmap, pseudo_random_generator, block_number, ) # setup the state for the wait unlock current_state.initiator.revealsecret = SendRevealSecret( UNIT_TRANSFER_TARGET, 'global', UNIT_TRANSFER_IDENTIFIER, UNIT_SECRET, ) state_change = ReceiveSecretReveal( secret=UNIT_SECRET, sender=channel1.partner_state.address, ) iteration = initiator_manager.state_transition( current_state, state_change, channelmap, pseudo_random_generator, block_number, ) assert len(iteration.events) == 3 assert any(isinstance(e, SendBalanceProof) for e in iteration.events) assert any( isinstance(e, EventTransferSentSuccess) for e in iteration.events) assert any(isinstance(e, EventUnlockSuccess) for e in iteration.events) balance_proof = next(e for e in iteration.events if isinstance(e, SendBalanceProof)) complete = next(e for e in iteration.events if isinstance(e, EventTransferSentSuccess)) assert balance_proof.recipient == channel1.partner_state.address assert complete.identifier == UNIT_TRANSFER_IDENTIFIER assert iteration.new_state is None, 'state must be cleaned'
def message_revealsecret(self, message): secret = message.secret sender = message.sender self.raiden.greenlet_task_dispatcher.dispatch_message( message, message.hashlock, ) self.raiden.register_secret(secret) state_change = ReceiveSecretReveal(secret, sender) self.raiden.state_machine_event_handler.dispatch_to_all_tasks(state_change)
def test_handle_offchain_secretreveal_after_lock_expired(): """Test that getting the secret revealed after lock expiration for the target does not end up continuously emitting EventUnlockClaimFailed Target part for https://github.com/raiden-network/raiden/issues/3086 """ setup = make_target_state() lock_expiration = setup.new_state.transfer.lock.expiration lock_expiration_block_number = lock_expiration + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS * 2 lock_expiration_block = Block( block_number=lock_expiration_block_number, gas_limit=1, block_hash=factories.make_transaction_hash(), ) iteration = target.state_transition( target_state=setup.new_state, state_change=lock_expiration_block, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number, ) state = iteration.new_state msg = 'At the expiration block we should get an EventUnlockClaimFailed' assert must_contain_entry(iteration.events, EventUnlockClaimFailed, {}), msg iteration = target.state_transition( target_state=state, state_change=ReceiveSecretReveal(UNIT_SECRET, setup.initiator), channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number + 1, ) state = iteration.new_state next_block = Block( block_number=lock_expiration_block_number + 1, gas_limit=1, block_hash=factories.make_transaction_hash(), ) iteration = target.state_transition( target_state=state, state_change=next_block, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number + 1, ) msg = 'At the next block we should not get the same event' assert not must_contain_entry(iteration.events, EventUnlockClaimFailed, {}), msg
def test_handle_offchain_secretreveal_after_lock_expired(): """Test that getting the secret revealed after lock expiration for the target does not end up continuously emitting EventUnlockClaimFailed Target part for https://github.com/raiden-network/raiden/issues/3086 """ setup = make_target_state() lock_expiration_block_number = channel.get_sender_expiration_threshold( setup.new_state.transfer.lock) lock_expiration_block = Block( block_number=lock_expiration_block_number, gas_limit=1, block_hash=factories.make_transaction_hash(), ) iteration = target.state_transition( target_state=setup.new_state, state_change=lock_expiration_block, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number, storage=None) state = iteration.new_state msg = "At the expiration block we should get an EventUnlockClaimFailed" assert search_for_item(iteration.events, EventUnlockClaimFailed, {}), msg iteration = target.state_transition( target_state=state, state_change=ReceiveSecretReveal(UNIT_SECRET, setup.initiator), channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number + 1, storage=None) state = iteration.new_state next_block = Block( block_number=lock_expiration_block_number + 1, gas_limit=1, block_hash=factories.make_transaction_hash(), ) iteration = target.state_transition( target_state=state, state_change=next_block, channel_state=setup.channel, pseudo_random_generator=setup.pseudo_random_generator, block_number=lock_expiration_block_number + 1, storage=None) msg = "At the next block we should not get the same event" assert not search_for_item(iteration.events, EventUnlockClaimFailed, {}), msg
def test_state_wait_unlock_invalid(): identifier = identifier = 1 amount = factories.UNIT_TRANSFER_AMOUNT block_number = 1 mediator_address = factories.HOP1 target_address = factories.HOP2 our_address = factories.ADDR secret_generator = SequenceGenerator() token = factories.UNIT_TOKEN_ADDRESS routes = [factories.make_route(mediator_address, available_balance=amount)] current_state = make_initiator_state( routes, target_address, block_number=block_number, our_address=our_address, secret_generator=secret_generator, token=token, ) secret = secret_generator.secrets[0] assert secret is not None current_state.revealsecret = SendRevealSecret( identifier, secret, token, target_address, our_address, ) before_state = deepcopy(current_state) initiator_state_machine = StateManager( initiator.state_transition, current_state, ) state_change = ReceiveSecretReveal( secret=secret, sender=factories.ADDR, ) events = initiator_state_machine.dispatch(state_change) assert len(events) == 0 assert initiator_state_machine.current_state.revealsecret is not None assert_state_equal(initiator_state_machine.current_state, current_state) assert_state_equal(current_state, before_state)
def test_handle_offchain_emptyhash_secret(): setup = setup_initiator_tests(block_number=10) secret_reveal = ReceiveSecretReveal( secret=EMPTY_HASH, sender=setup.channel.partner_state.address, ) iteration = initiator.handle_offchain_secretreveal( initiator_state=setup.current_state.initiator, state_change=secret_reveal, channel_state=setup.channel, pseudo_random_generator=setup.prng, ) secrethash = factories.UNIT_TRANSFER_DESCRIPTION.secrethash assert len(iteration.events) == 0 # make sure the lock has not moved assert secrethash in setup.channel.our_state.secrethashes_to_lockedlocks
def test_state_wait_unlock_invalid(): identifier = 1 block_number = 1 target_address = factories.HOP2 token = factories.UNIT_TOKEN_ADDRESS pseudo_random_generator = random.Random() channel1 = factories.make_channel( our_balance=UNIT_TRANSFER_AMOUNT, token_address=UNIT_TOKEN_ADDRESS, ) channelmap = {channel1.identifier: channel1} available_routes = [factories.route_from_channel(channel1)] current_state = make_initiator_state( available_routes, factories.UNIT_TRANSFER_DESCRIPTION, channelmap, pseudo_random_generator, block_number, ) # setup the state for the wait unlock current_state.initiator.revealsecret = SendRevealSecret( target_address, 'global', identifier, UNIT_SECRET, token, ) before_state = deepcopy(current_state) state_change = ReceiveSecretReveal( secret=UNIT_SECRET, sender=factories.ADDR, ) iteration = initiator_manager.state_transition( current_state, state_change, channelmap, pseudo_random_generator, block_number, ) assert not iteration.events assert iteration.new_state == before_state
def test_state_wait_unlock_invalid(): identifier = 1 block_number = 1 target_address = factories.HOP2 pseudo_random_generator = random.Random() channel1 = factories.make_channel( our_balance=UNIT_TRANSFER_AMOUNT, token_address=UNIT_TOKEN_ADDRESS, token_network_identifier=UNIT_TOKEN_NETWORK_ADDRESS, ) channel_map = {channel1.identifier: channel1} available_routes = [factories.route_from_channel(channel1)] current_state = make_initiator_manager_state( available_routes, factories.UNIT_TRANSFER_DESCRIPTION, channel_map, pseudo_random_generator, block_number, ) # setup the state for the wait unlock current_state.initiator.revealsecret = SendSecretReveal( recipient=target_address, channel_identifier=CHANNEL_IDENTIFIER_GLOBAL_QUEUE, message_identifier=identifier, secret=UNIT_SECRET, ) before_state = deepcopy(current_state) state_change = ReceiveSecretReveal( secret=UNIT_SECRET, sender=factories.ADDR, ) iteration = initiator_manager.state_transition( current_state, state_change, channel_map, pseudo_random_generator, block_number, ) assert not iteration.events assert iteration.new_state == before_state