def channel_open( self, registry_address, token_address, partner_address, settle_timeout=None, reveal_timeout=None, poll_timeout=DEFAULT_POLL_TIMEOUT, retry_timeout=DEFAULT_RETRY_TIMEOUT, ): """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout <= reveal_timeout: raise InvalidSettleTimeout( 'reveal_timeout can not be larger-or-equal to settle_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress( 'Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress( 'Expected binary address format for partner in channel open') registry = self.raiden.chain.token_network_registry(registry_address) token_network = registry.token_network_by_token(token_address) channel_identifier = token_network.new_netting_channel( partner_address, settle_timeout, ) msg = 'After {} seconds the channel was not properly created.'.format( poll_timeout, ) with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)): waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, retry_timeout, ) return channel_identifier
def channel_open(self, token_address, partner_address, settle_timeout=None, reveal_timeout=None, poll_timeout=DEFAULT_POLL_TIMEOUT): """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout <= reveal_timeout: raise InvalidSettleTimeout( 'reveal_timeout can not be larger-or-equal to settle_timeout') if not isaddress(token_address): raise InvalidAddress( 'Expected binary address format for token in channel open') if not isaddress(partner_address): raise InvalidAddress( 'Expected binary address format for partner in channel open') channel_manager = self.raiden.default_registry.manager_by_token( token_address) netcontract_address = channel_manager.new_netting_channel( partner_address, settle_timeout, ) msg = 'After {} seconds the channel was not properly created.'.format( poll_timeout) registry_address = self.raiden.default_registry.address with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)): waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, self.raiden.alarm.wait_time, ) return netcontract_address
def wait_for_usable_channel( raiden: RaidenService, partner_address: Address, token_network_registry_address: TokenNetworkRegistryAddress, token_address: TokenAddress, our_deposit: TokenAmount, partner_deposit: TokenAmount, retry_timeout: float = DEFAULT_RETRY_TIMEOUT, ) -> None: """ Wait until the channel from app0 to app1 is usable. The channel and the deposits are registered, and the partner network state is reachable. """ waiting.wait_for_newchannel( raiden=raiden, token_network_registry_address=token_network_registry_address, token_address=token_address, partner_address=partner_address, retry_timeout=retry_timeout, ) # wait for our deposit waiting.wait_for_participant_deposit( raiden=raiden, token_network_registry_address=token_network_registry_address, token_address=token_address, partner_address=partner_address, target_address=raiden.address, target_balance=our_deposit, retry_timeout=retry_timeout, ) # wait for the partner deposit waiting.wait_for_participant_deposit( raiden=raiden, token_network_registry_address=token_network_registry_address, token_address=token_address, partner_address=partner_address, target_address=partner_address, target_balance=partner_deposit, retry_timeout=retry_timeout, ) waiting.wait_for_healthy(raiden=raiden, node_address=partner_address, retry_timeout=retry_timeout)
def wait_for_usable_channel( app0, app1, registry_address, token_address, our_deposit, partner_deposit, retry_timeout=DEFAULT_RETRY_TIMEOUT, ): """ Wait until the channel from app0 to app1 is usable. The channel and the deposits are registered, and the partner network state is reachable. """ waiting.wait_for_newchannel( app0.raiden, registry_address, token_address, app1.raiden.address, retry_timeout, ) waiting.wait_for_participant_newbalance( app0.raiden, registry_address, token_address, app1.raiden.address, app0.raiden.address, our_deposit, retry_timeout, ) waiting.wait_for_participant_newbalance( app0.raiden, registry_address, token_address, app1.raiden.address, app1.raiden.address, partner_deposit, retry_timeout, ) waiting.wait_for_healthy( app0.raiden, app1.raiden.address, retry_timeout, )
def wait_for_usable_channel( app0, app1, registry_address, token_address, our_deposit, partner_deposit, events_poll_timeout=0.5, ): """ Wait until the channel from app0 to app1 is usable. The channel and the deposits are registered, and the partner network state is reachable. """ waiting.wait_for_newchannel( app0.raiden, registry_address, token_address, app1.raiden.address, events_poll_timeout, ) waiting.wait_for_participant_newbalance( app0.raiden, registry_address, token_address, app1.raiden.address, app0.raiden.address, our_deposit, events_poll_timeout, ) waiting.wait_for_participant_newbalance( app0.raiden, registry_address, token_address, app1.raiden.address, app1.raiden.address, partner_deposit, events_poll_timeout, ) waiting.wait_for_healthy( app0.raiden, app1.raiden.address, events_poll_timeout, )
def wait_both_channel_open( app0, app1, registry_address, token_address, retry_timeout, ): waiting.wait_for_newchannel( app1.raiden, registry_address, token_address, app0.raiden.address, retry_timeout, ) waiting.wait_for_newchannel( app0.raiden, registry_address, token_address, app1.raiden.address, retry_timeout, )
def channel_open( self, registry_address: typing.PaymentNetworkID, token_address: typing.TokenAddress, partner_address: typing.Address, settle_timeout: typing.BlockTimeout = None, retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT, ) -> typing.ChannelID: """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout < self.raiden.config['reveal_timeout'] * 2: raise InvalidSettleTimeout( 'settle_timeout can not be smaller than double the reveal_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress('Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress('Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress('Expected binary address format for partner in channel open') chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, ) if channel_state: raise DuplicatedChannelError('Channel with given partner address already exists') registry = self.raiden.chain.token_network_registry(registry_address) token_network_address = registry.get_token_network(token_address) if token_network_address is None: raise TokenNotRegistered( 'Token network for token %s does not exist' % to_checksum_address(token_address), ) token_network = self.raiden.chain.token_network( registry.get_token_network(token_address), ) with self.raiden.gas_reserve_lock: has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve( self.raiden, channels_to_open=1, ) if not has_enough_reserve: raise InsufficientGasReserve(( 'The account balance is below the estimated amount necessary to ' 'finish the lifecycles of all active channels. A balance of at ' f'least {estimated_required_reserve} wei is required.' )) try: token_network.new_netting_channel( partner=partner_address, settle_timeout=settle_timeout, ) except DuplicatedChannelError: log.info('partner opened channel first') waiting.wait_for_newchannel( raiden=self.raiden, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, retry_timeout=retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, ) return channel_state.identifier
def channel_open( self, registry_address, token_address, partner_address, settle_timeout=None, reveal_timeout=None, poll_timeout=DEFAULT_POLL_TIMEOUT, retry_timeout=DEFAULT_RETRY_TIMEOUT, ): """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout <= reveal_timeout: raise InvalidSettleTimeout( 'reveal_timeout can not be larger-or-equal to settle_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress( 'Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress( 'Expected binary address format for partner in channel open') chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) if channel_state: raise DuplicatedChannelError( 'Channel with given partner address already exists') registry = self.raiden.chain.token_network_registry(registry_address) token_network = self.raiden.chain.token_network( registry.get_token_network(token_address), ) try: token_network.new_netting_channel( partner_address, settle_timeout, ) except DuplicatedChannelError: log.info('partner opened channel first') msg = 'After {} seconds the channel was not properly created.'.format( poll_timeout, ) with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)): waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) return channel_state.identifier
def channel_open( self, registry_address: PaymentNetworkID, token_address: TokenAddress, partner_address: Address, settle_timeout: BlockTimeout = None, retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT, ) -> ChannelID: """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if settle_timeout is None: settle_timeout = self.raiden.config["settle_timeout"] if settle_timeout < self.raiden.config["reveal_timeout"] * 2: raise InvalidSettleTimeout( "settle_timeout can not be smaller than double the reveal_timeout" ) if not is_binary_address(registry_address): raise InvalidAddress("Expected binary address format for registry in channel open") if not is_binary_address(token_address): raise InvalidAddress("Expected binary address format for token in channel open") if not is_binary_address(partner_address): raise InvalidAddress("Expected binary address format for partner in channel open") chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, ) if channel_state: raise DuplicatedChannelError("Channel with given partner address already exists") registry = self.raiden.chain.token_network_registry(registry_address) token_network_address = registry.get_token_network(token_address) if token_network_address is None: raise TokenNotRegistered( "Token network for token %s does not exist" % to_checksum_address(token_address) ) token_network = self.raiden.chain.token_network(registry.get_token_network(token_address)) with self.raiden.gas_reserve_lock: has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve( self.raiden, channels_to_open=1 ) if not has_enough_reserve: raise InsufficientGasReserve( ( "The account balance is below the estimated amount necessary to " "finish the lifecycles of all active channels. A balance of at " f"least {estimated_required_reserve} wei is required." ) ) try: token_network.new_netting_channel( partner=partner_address, settle_timeout=settle_timeout, given_block_identifier=views.state_from_raiden(self.raiden).block_hash, ) except DuplicatedChannelError: log.info("partner opened channel first") waiting.wait_for_newchannel( raiden=self.raiden, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, retry_timeout=retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, payment_network_id=registry_address, token_address=token_address, partner_address=partner_address, ) assert channel_state, f"channel {channel_state} is gone" return channel_state.identifier
def channel_open( self, registry_address: TokenNetworkRegistryAddress, token_address: TokenAddress, partner_address: Address, settle_timeout: BlockTimeout = None, reveal_timeout: BlockTimeout = None, retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT, ) -> ChannelID: """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if settle_timeout is None: settle_timeout = self.raiden.config.settle_timeout if reveal_timeout is None: reveal_timeout = self.raiden.config.reveal_timeout if reveal_timeout <= 0: raise InvalidRevealTimeout( "reveal_timeout should be larger than zero") if settle_timeout < reveal_timeout * 2: raise InvalidSettleTimeout( "`settle_timeout` can not be smaller than double the " "`reveal_timeout`.\n " "\n " "The setting `reveal_timeout` determines the maximum number of " "blocks it should take a transaction to be mined when the " "blockchain is under congestion. This setting determines the " "when a node must go on-chain to register a secret, and it is " "therefore the lower bound of the lock expiration. The " "`settle_timeout` determines when a channel can be settled " "on-chain, for this operation to be safe all locks must have " "been resolved, for this reason the `settle_timeout` has to be " "larger than `reveal_timeout`.") if not is_binary_address(registry_address): raise InvalidBinaryAddress( "Expected binary address format for registry in channel open") if not is_binary_address(token_address): raise InvalidBinaryAddress( "Expected binary address format for token in channel open") if not is_binary_address(partner_address): raise InvalidBinaryAddress( "Expected binary address format for partner in channel open") confirmed_block_identifier = views.get_confirmed_blockhash(self.raiden) registry = self.raiden.proxy_manager.token_network_registry( registry_address, block_identifier=confirmed_block_identifier) settlement_timeout_min = registry.settlement_timeout_min( block_identifier=confirmed_block_identifier) settlement_timeout_max = registry.settlement_timeout_max( block_identifier=confirmed_block_identifier) if settle_timeout < settlement_timeout_min: raise InvalidSettleTimeout( f"Settlement timeout should be at least {settlement_timeout_min}" ) if settle_timeout > settlement_timeout_max: raise InvalidSettleTimeout( f"Settlement timeout exceeds max of {settlement_timeout_max}") token_network_address = registry.get_token_network( token_address=token_address, block_identifier=confirmed_block_identifier) if token_network_address is None: raise TokenNotRegistered( "Token network for token %s does not exist" % to_checksum_address(token_address)) token_network = self.raiden.proxy_manager.token_network( address=token_network_address, block_identifier=confirmed_block_identifier) safety_deprecation_switch = token_network.safety_deprecation_switch( block_identifier=confirmed_block_identifier) if safety_deprecation_switch: msg = ( "This token_network has been deprecated. New channels cannot be " "open for this network, usage of the newly deployed token " "network contract is highly encouraged.") raise TokenNetworkDeprecated(msg) duplicated_channel = self.is_already_existing_channel( token_network_address=token_network_address, partner_address=partner_address, block_identifier=confirmed_block_identifier, ) if duplicated_channel: raise DuplicatedChannelError( f"A channel with {to_checksum_address(partner_address)} for token " f"{to_checksum_address(token_address)} already exists. " f"(At blockhash: {confirmed_block_identifier.hex()})") has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve( self.raiden, channels_to_open=1) if not has_enough_reserve: raise InsufficientGasReserve( "The account balance is below the estimated amount necessary to " "finish the lifecycles of all active channels. A balance of at " f"least {estimated_required_reserve} wei is required.") try: token_network.new_netting_channel( partner=partner_address, settle_timeout=settle_timeout, given_block_identifier=confirmed_block_identifier, ) except DuplicatedChannelError: log.info("partner opened channel first") except RaidenRecoverableError: # The channel may have been created in the pending block. duplicated_channel = self.is_already_existing_channel( token_network_address=token_network_address, partner_address=partner_address) if duplicated_channel: log.info("Channel has already been opened") else: raise waiting.wait_for_newchannel( raiden=self.raiden, token_network_registry_address=registry_address, token_address=token_address, partner_address=partner_address, retry_timeout=retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, token_network_registry_address=registry_address, token_address=token_address, partner_address=partner_address, ) assert channel_state, f"channel {channel_state} is gone" self.raiden.set_channel_reveal_timeout( canonical_identifier=channel_state.canonical_identifier, reveal_timeout=reveal_timeout) return channel_state.identifier
def test_new_netting_contract(raiden_network, token_amount, settle_timeout): # pylint: disable=line-too-long,too-many-statements,too-many-locals app0, app1, app2 = raiden_network peer0_address = app0.raiden.address peer1_address = app1.raiden.address peer2_address = app2.raiden.address blockchain_service0 = app0.raiden.chain registry = app0.raiden.default_registry registry_address = app0.raiden.default_registry.address humantoken_path = get_contract_path('HumanStandardToken.sol') token_address = blockchain_service0.deploy_and_register_token( registry, contract_name='HumanStandardToken', contract_path=humantoken_path, constructor_parameters=(token_amount, 'raiden', 2, 'Rd'), ) token0 = blockchain_service0.token(token_address) for transfer_to in raiden_network[1:]: token0.transfer( privatekey_to_address(transfer_to.raiden.privkey), token_amount // len(raiden_network), ) manager0 = registry.manager_by_token(token_address) # sanity assert manager0.channels_addresses() == [] assert manager0.channels_by_participant(peer0_address) == [] assert manager0.channels_by_participant(peer1_address) == [] assert manager0.channels_by_participant(peer2_address) == [] # create one channel netting_address_01 = manager0.new_netting_channel( peer1_address, settle_timeout, ) exception = RuntimeError("Timeout while waiting for a new channel") with gevent.Timeout(seconds=10, exception=exception): waiting.wait_for_newchannel( app1.raiden, registry_address, token_address, app0.raiden.address, app1.raiden.alarm.wait_time, ) # check contract state netting_channel_01 = blockchain_service0.netting_channel(netting_address_01) assert netting_channel_01.can_transfer() is False # check channels channel_list = manager0.channels_addresses() assert sorted(channel_list[0]) == sorted([peer0_address, peer1_address]) assert manager0.channels_by_participant(peer0_address) == [netting_address_01] assert manager0.channels_by_participant(peer1_address) == [netting_address_01] assert manager0.channels_by_participant(peer2_address) == [] # create a duplicated channel with same participants while previous channel # is still open should throw an exception with pytest.raises(Exception): manager0.new_netting_channel( peer1_address, settle_timeout, ) # create other channel netting_address_02 = manager0.new_netting_channel( peer2_address, settle_timeout, ) netting_channel_02 = blockchain_service0.netting_channel(netting_address_02) assert netting_channel_02.can_transfer() is False channel_list = manager0.channels_addresses() expected_channels = [ sorted([peer0_address, peer1_address]), sorted([peer0_address, peer2_address]), ] for channel in channel_list: assert sorted(channel) in expected_channels result0 = sorted(manager0.channels_by_participant(peer0_address)) result1 = sorted([netting_address_01, netting_address_02]) assert result0 == result1 assert manager0.channels_by_participant(peer1_address) == [netting_address_01] assert manager0.channels_by_participant(peer2_address) == [netting_address_02] # deposit without approve should fail netting_channel_01.set_total_deposit(100) assert netting_channel_01.can_transfer() is False assert netting_channel_02.can_transfer() is False assert netting_channel_01.detail()['our_balance'] == 0 assert netting_channel_02.detail()['our_balance'] == 0 # single-funded channel app0.raiden.chain.token(token_address).approve(netting_address_01, 100) netting_channel_01.set_total_deposit(100) assert netting_channel_01.can_transfer() is True assert netting_channel_02.can_transfer() is False assert netting_channel_01.detail()['our_balance'] == 100 assert netting_channel_02.detail()['our_balance'] == 0 # double-funded channel app0.raiden.chain.token(token_address).approve(netting_address_02, 70) netting_channel_02.set_total_deposit(70) assert netting_channel_01.can_transfer() is True assert netting_channel_02.can_transfer() is True assert netting_channel_02.detail()['our_balance'] == 70 assert netting_channel_02.detail()['partner_balance'] == 0 app2.raiden.chain.token(token_address).approve(netting_address_02, 130) app2.raiden.chain.netting_channel(netting_address_02).set_total_deposit(130) assert netting_channel_01.can_transfer() is True assert netting_channel_02.can_transfer() is True assert netting_channel_02.detail()['our_balance'] == 70 assert netting_channel_02.detail()['partner_balance'] == 130 wait_until_block(app0.raiden.chain, app0.raiden.chain.block_number() + 2) RaidenAPI(app1.raiden).channel_close(registry_address, token_address, app0.raiden.address) waiting.wait_for_settle( app1.raiden, registry_address, token_address, [netting_address_01], app1.raiden.alarm.wait_time, ) with pytest.raises(AddressWithoutCode): netting_channel_01.closed() with pytest.raises(AddressWithoutCode): netting_channel_01.opened() # open channel with same peer again netting_address_01_reopened = manager0.new_netting_channel( peer1_address, settle_timeout, ) netting_channel_01_reopened = blockchain_service0.netting_channel(netting_address_01_reopened) assert netting_channel_01_reopened.opened() != 0 assert netting_address_01_reopened in manager0.channels_by_participant(peer0_address) assert netting_address_01 not in manager0.channels_by_participant(peer0_address) app0.raiden.chain.token(token_address).approve(netting_address_01_reopened, 100) netting_channel_01_reopened.set_total_deposit(100) assert netting_channel_01_reopened.opened() != 0
def test_send_queued_messages( raiden_network, number_of_nodes, deposit, token_addresses, network_wait, skip_if_not_matrix, ): """Test re-sending of undelivered messages on node restart""" app0, app1 = raiden_network token_address = token_addresses[0] chain_state = views.state_from_app(app0) payment_network_id = app0.raiden.default_registry.address token_network_identifier = views.get_token_network_identifier_by_token_address( chain_state, payment_network_id, token_address, ) with dont_handle_node_change_network_state(): # stop app1 - transfer must be left unconfirmed app1.stop() # make a few transfers from app0 to app1 amount = 1 spent_amount = 7 identifier = 1 for _ in range(spent_amount): app0.raiden.mediated_transfer_async( token_network_identifier=token_network_identifier, amount=amount, target=app1.raiden.address, identifier=identifier, ) identifier += 1 # restart app0 app0.raiden.stop() new_transport = MatrixTransport( app0.raiden.config['transport']['matrix'], ) raiden_event_handler = RaidenEventHandler() message_handler = MessageHandler() app0_restart = App( config=app0.config, chain=app0.raiden.chain, query_start_block=0, default_registry=app0.raiden.default_registry, default_secret_registry=app0.raiden.default_secret_registry, transport=new_transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, discovery=app0.raiden.discovery, ) app0.stop() del app0 # from here on the app0_restart should be used app1.start() app0_restart.start() waiting.wait_for_healthy( app0_restart.raiden, app1.raiden.address, network_wait, ) waiting.wait_for_healthy( app1.raiden, app0_restart.raiden.address, network_wait, ) exception = RuntimeError('Timeout while waiting for new channel') with gevent.Timeout(5, exception=exception): waiting.wait_for_newchannel( raiden=app0_restart.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app1.raiden.address, retry_timeout=network_wait, ) exception = RuntimeError('Timeout while waiting for balance update for app0') with gevent.Timeout(30, exception=exception): waiting.wait_for_payment_balance( raiden=app0_restart.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app1.raiden.address, target_address=app1.raiden.address, target_balance=spent_amount, retry_timeout=network_wait, ) waiting.wait_for_payment_balance( raiden=app1.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app0_restart.raiden.address, target_address=app1.raiden.address, target_balance=spent_amount, retry_timeout=network_wait, ) assert_synced_channel_state( token_network_identifier, app0_restart, deposit - spent_amount, [], app1, deposit + spent_amount, [], )
def test_send_queued_messages( raiden_network, number_of_nodes, deposit, token_addresses, network_wait, skip_if_not_matrix, ): """Test re-sending of undelivered messages on node restart""" app0, app1 = raiden_network token_address = token_addresses[0] chain_state = views.state_from_app(app0) payment_network_id = app0.raiden.default_registry.address token_network_identifier = views.get_token_network_identifier_by_token_address( chain_state, payment_network_id, token_address, ) # stop app1 - direct transfer must be left unconfirmed app1.stop() # make a few transfers from app0 to app2 amount = 1 spent_amount = 7 for _ in range(spent_amount): direct_transfer( app0, app1, token_network_identifier, amount, timeout=network_wait * number_of_nodes, ) # restart app0 app0.raiden.stop() new_transport = MatrixTransport( app0.raiden.config['transport']['matrix'], ) app0_restart = App( config=app0.config, chain=app0.raiden.chain, query_start_block=0, default_registry=app0.raiden.default_registry, default_secret_registry=app0.raiden.default_secret_registry, transport=new_transport, discovery=app0.raiden.discovery, ) app0.stop() del app0 # from here on the app0_restart should be used app1.start() app0_restart.start() waiting.wait_for_healthy( app0_restart.raiden, app1.raiden.address, network_wait, ) waiting.wait_for_healthy( app1.raiden, app0_restart.raiden.address, network_wait, ) exception = RuntimeError('Timeout while waiting for new channel') with gevent.Timeout(5, exception=exception): waiting.wait_for_newchannel( app0_restart.raiden, payment_network_id, token_address, app1.raiden.address, network_wait, ) exception = RuntimeError('Timeout while waiting for balance update for app0') with gevent.Timeout(30, exception=exception): waiting.wait_for_payment_balance( app0_restart.raiden, payment_network_id, token_address, app1.raiden.address, app1.raiden.address, spent_amount, network_wait, ) waiting.wait_for_payment_balance( app1.raiden, payment_network_id, token_address, app0_restart.raiden.address, app1.raiden.address, spent_amount, network_wait, ) assert_synced_channel_state( token_network_identifier, app0_restart, deposit - spent_amount, [], app1, deposit + spent_amount, [], )
def channel_open( self, registry_address: typing.PaymentNetworkID, token_address: typing.TokenAddress, partner_address: typing.Address, settle_timeout: typing.BlockTimeout = None, reveal_timeout: typing.BlockTimeout = None, retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT, ) -> typing.ChannelID: """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout <= reveal_timeout: raise InvalidSettleTimeout( 'reveal_timeout can not be larger-or-equal to settle_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress('Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress('Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress('Expected binary address format for partner in channel open') chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) if channel_state: raise DuplicatedChannelError('Channel with given partner address already exists') registry = self.raiden.chain.token_network_registry(registry_address) token_network_address = registry.get_token_network(token_address) if token_network_address is None: raise TokenNotRegistered( 'Token network for token %s does not exist' % to_checksum_address(token_address), ) token_network = self.raiden.chain.token_network( registry.get_token_network(token_address), ) try: token_network.new_netting_channel( partner_address, settle_timeout, ) except DuplicatedChannelError: log.info('partner opened channel first') waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) return channel_state.identifier
def channel_open( self, registry_address: typing.PaymentNetworkID, token_address: typing.TokenAddress, partner_address: typing.Address, settle_timeout: typing.BlockTimeout = None, retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT, ) -> typing.ChannelID: """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout < self.raiden.config['reveal_timeout'] * 2: raise InvalidSettleTimeout( 'settle_timeout can not be smaller than double the reveal_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress( 'Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress( 'Expected binary address format for partner in channel open') chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) if channel_state: raise DuplicatedChannelError( 'Channel with given partner address already exists') registry = self.raiden.chain.token_network_registry(registry_address) token_network_address = registry.get_token_network(token_address) if token_network_address is None: raise TokenNotRegistered( 'Token network for token %s does not exist' % to_checksum_address(token_address), ) token_network = self.raiden.chain.token_network( registry.get_token_network(token_address), ) has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve( self.raiden, channels_to_open=1, ) if not has_enough_reserve: raise InsufficientGasReserve(( 'The account balance is below the estimated amount necessary to ' 'finish the lifecycles of all active channels. A balance of at ' f'least {estimated_required_reserve} wei is required.')) try: token_network.new_netting_channel( partner_address, settle_timeout, ) except DuplicatedChannelError: log.info('partner opened channel first') waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) return channel_state.identifier
def payment_channel_open_and_deposit( app0: App, app1: App, token_address: TokenAddress, deposit: TokenAmount, settle_timeout: BlockTimeout, ) -> None: """ Open a new channel with app0 and app1 as participants """ assert token_address block_identifier: BlockIdentifier if app0.raiden.wal: block_identifier = views.get_confirmed_blockhash(app0.raiden) else: block_identifier = BLOCK_ID_LATEST token_network_address = app0.raiden.default_registry.get_token_network( token_address=token_address, block_identifier=block_identifier) assert token_network_address, "request a channel for an unregistered token" token_network_proxy = app0.raiden.proxy_manager.token_network( token_network_address, block_identifier=BLOCK_ID_LATEST) channel_identifier, _, _ = token_network_proxy.new_netting_channel( partner=app1.raiden.address, settle_timeout=settle_timeout, given_block_identifier=block_identifier, ) assert channel_identifier if deposit != 0: for app, partner in [(app0, app1), (app1, app0)]: waiting.wait_for_newchannel( raiden=app.raiden, token_network_registry_address=app.raiden.default_registry. address, token_address=token_address, partner_address=partner.raiden.address, retry_timeout=0.5, ) chain_state = state_from_raiden(app.raiden) canonical_identifier = CanonicalIdentifier( chain_identifier=chain_state.chain_id, token_network_address=token_network_proxy.address, channel_identifier=channel_identifier, ) channel_state = get_channelstate_by_canonical_identifier( chain_state=chain_state, canonical_identifier=canonical_identifier) assert channel_state, "nodes dont share a channel" # Use each app's own chain because of the private key / local signing token = app.raiden.proxy_manager.token(token_address, BLOCK_ID_LATEST) payment_channel_proxy = app.raiden.proxy_manager.payment_channel( channel_state=channel_state, block_identifier=BLOCK_ID_LATEST) # This check can succeed and the deposit still fail, if channels are # openned in parallel previous_balance = token.balance_of(app.raiden.address) assert previous_balance >= deposit # the payment channel proxy will call approve # token.approve(token_network_proxy.address, deposit) payment_channel_proxy.approve_and_set_total_deposit( total_deposit=deposit, block_identifier=BLOCK_ID_LATEST) # Balance must decrease by at least but not exactly `deposit` amount, # because channels can be openned in parallel new_balance = token.balance_of(app.raiden.address) assert new_balance <= previous_balance - deposit check_channel(app0, app1, token_network_proxy.address, settle_timeout, deposit)
def run_test_send_queued_messages( raiden_network, deposit, token_addresses, network_wait, ): app0, app1 = raiden_network token_address = token_addresses[0] chain_state = views.state_from_app(app0) payment_network_id = app0.raiden.default_registry.address token_network_identifier = views.get_token_network_identifier_by_token_address( chain_state, payment_network_id, token_address, ) with dont_handle_node_change_network_state(): # stop app1 - transfer must be left unconfirmed app1.stop() # make a few transfers from app0 to app1 amount = 1 spent_amount = 7 identifier = 1 for _ in range(spent_amount): app0.raiden.mediated_transfer_async( token_network_identifier=token_network_identifier, amount=amount, target=app1.raiden.address, identifier=identifier, ) identifier += 1 # restart app0 app0.raiden.stop() new_transport = MatrixTransport( app0.raiden.config['transport']['matrix'], ) raiden_event_handler = RaidenEventHandler() message_handler = MessageHandler() app0_restart = App( config=app0.config, chain=app0.raiden.chain, query_start_block=0, default_registry=app0.raiden.default_registry, default_secret_registry=app0.raiden.default_secret_registry, default_service_registry=app0.raiden.default_service_registry, transport=new_transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, discovery=app0.raiden.discovery, ) app0.stop() del app0 # from here on the app0_restart should be used app1.start() app0_restart.start() waiting.wait_for_healthy( app0_restart.raiden, app1.raiden.address, network_wait, ) waiting.wait_for_healthy( app1.raiden, app0_restart.raiden.address, network_wait, ) exception = RuntimeError('Timeout while waiting for new channel') with gevent.Timeout(5, exception=exception): waiting.wait_for_newchannel( raiden=app0_restart.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app1.raiden.address, retry_timeout=network_wait, ) exception = RuntimeError( 'Timeout while waiting for balance update for app0') with gevent.Timeout(30, exception=exception): waiting.wait_for_payment_balance( raiden=app0_restart.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app1.raiden.address, target_address=app1.raiden.address, target_balance=spent_amount, retry_timeout=network_wait, ) waiting.wait_for_payment_balance( raiden=app1.raiden, payment_network_id=payment_network_id, token_address=token_address, partner_address=app0_restart.raiden.address, target_address=app1.raiden.address, target_balance=spent_amount, retry_timeout=network_wait, ) assert_synced_channel_state( token_network_identifier, app0_restart, deposit - spent_amount, [], app1, deposit + spent_amount, [], )
def channel_open( self, registry_address, token_address, partner_address, settle_timeout=None, reveal_timeout=None, poll_timeout=DEFAULT_POLL_TIMEOUT, retry_timeout=DEFAULT_RETRY_TIMEOUT, ): """ Open a channel with the peer at `partner_address` with the given `token_address`. """ if reveal_timeout is None: reveal_timeout = self.raiden.config['reveal_timeout'] if settle_timeout is None: settle_timeout = self.raiden.config['settle_timeout'] if settle_timeout <= reveal_timeout: raise InvalidSettleTimeout( 'reveal_timeout can not be larger-or-equal to settle_timeout', ) if not is_binary_address(registry_address): raise InvalidAddress('Expected binary address format for registry in channel open') if not is_binary_address(token_address): raise InvalidAddress('Expected binary address format for token in channel open') if not is_binary_address(partner_address): raise InvalidAddress('Expected binary address format for partner in channel open') chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) if channel_state: raise DuplicatedChannelError('Channel with given partner address already exists') registry = self.raiden.chain.token_network_registry(registry_address) token_network = self.raiden.chain.token_network( registry.get_token_network(token_address), ) try: token_network.new_netting_channel( partner_address, settle_timeout, ) except DuplicatedChannelError: log.info('partner opened channel first') msg = 'After {} seconds the channel was not properly created.'.format( poll_timeout, ) with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)): waiting.wait_for_newchannel( self.raiden, registry_address, token_address, partner_address, retry_timeout, ) chain_state = views.state_from_raiden(self.raiden) channel_state = views.get_channelstate_for( chain_state, registry_address, token_address, partner_address, ) return channel_state.identifier