def open_channel(self, token_address, partner_address, settle_timeout=None, reveal_timeout=None): if settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN: raise InvalidSettleTimeout( 'Configured minimum `settle_timeout` is {} blocks.'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN)) 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') reveal_value = reveal_timeout if reveal_timeout is not None else self.reveal_timeout channel = self.make_channel(token_address=token_address, partner_address=partner_address, settle_timeout=settle_timeout, reveal_timeout=reveal_value) self.channels.append(channel) return channel
def open_channel( self, token_address, partner_address, settle_timeout=None, reveal_timeout=None): invalid_timeout = ( settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX ) if invalid_timeout: raise InvalidSettleTimeout('`settle_timeout` should be in range [{}, {}].'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX )) 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') reveal_value = reveal_timeout if reveal_timeout is not None else self.reveal_timeout channel = self.make_channel( token_address=token_address, partner_address=partner_address, settle_timeout=settle_timeout, reveal_timeout=reveal_value ) self.channels.append(channel) return channel
def __init__( self, config: RaidenConfig, rpc_client: JSONRPCClient, proxy_manager: ProxyManager, query_start_block: BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, default_service_registry: Optional[ServiceRegistry], default_user_deposit: Optional[UserDeposit], default_one_to_n_address: Optional[OneToNAddress], default_msc_address: Optional[MonitoringServiceAddress], transport: MatrixTransport, raiden_event_handler: EventHandler, message_handler: MessageHandler, routing_mode: RoutingMode, api_server: APIServer = None, ): raiden = RaidenService( rpc_client=rpc_client, proxy_manager=proxy_manager, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, default_service_registry=default_service_registry, default_user_deposit=default_user_deposit, default_one_to_n_address=default_one_to_n_address, default_msc_address=default_msc_address, transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, routing_mode=routing_mode, config=config, api_server=api_server, ) # check that the settlement timeout fits the limits of the contract settlement_timeout_min = default_registry.settlement_timeout_min(BLOCK_ID_LATEST) settlement_timeout_max = default_registry.settlement_timeout_max(BLOCK_ID_LATEST) invalid_settle_timeout = ( config.settle_timeout < settlement_timeout_min or config.settle_timeout > settlement_timeout_max or config.settle_timeout < config.reveal_timeout * 2 ) if invalid_settle_timeout: raise InvalidSettleTimeout( ( "Settlement timeout for Registry contract {} must " "be in range [{}, {}], is {}" ).format( to_checksum_address(default_registry.address), settlement_timeout_min, settlement_timeout_max, config.settle_timeout, ) ) self.config = config self.raiden = raiden
def __init__( self, config: typing.Dict, chain: BlockChainService, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, transport, raiden_event_handler, message_handler, discovery: Discovery = None, ): raiden = RaidenService( chain=chain, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, private_key_bin=unhexlify(config['privatekey_hex']), transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, config=config, discovery=discovery, ) # Check if files with older versions of the DB exist, emit a warning db_base_path = os.path.dirname(config['database_path']) if older_db_files_exist(db_base_path): log.warning( 'Older versions of the database exist in ' f'{db_base_path}. Since a newer breaking version is introduced, ' 'it is advised that you leave all token networks before upgrading and ' 'then proceed with the upgrade.', ) # check that the settlement timeout fits the limits of the contract invalid_settle_timeout = ( config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max() or config['settle_timeout'] < config['reveal_timeout'] * 2) if invalid_settle_timeout: raise InvalidSettleTimeout( ('Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}').format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) self.config = config self.discovery = discovery self.raiden = raiden self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def __init__( self, config: typing.Dict, rpc_client: JSONRPCClient, proxy_manager: ProxyManager, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, default_service_registry: typing.Optional[ServiceRegistry], default_one_to_n_address: typing.Optional[Address], default_msc_address: Address, transport: MatrixTransport, raiden_event_handler: EventHandler, message_handler: MessageHandler, routing_mode: RoutingMode, user_deposit: UserDeposit = None, ): raiden = RaidenService( rpc_client=rpc_client, proxy_manager=proxy_manager, query_start_block=query_start_block, default_registry=default_registry, default_one_to_n_address=default_one_to_n_address, default_secret_registry=default_secret_registry, default_service_registry=default_service_registry, default_msc_address=default_msc_address, transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, routing_mode=routing_mode, config=config, user_deposit=user_deposit, ) # check that the settlement timeout fits the limits of the contract settlement_timeout_min = default_registry.settlement_timeout_min("latest") settlement_timeout_max = default_registry.settlement_timeout_max("latest") invalid_settle_timeout = ( config["settle_timeout"] < settlement_timeout_min or config["settle_timeout"] > settlement_timeout_max or config["settle_timeout"] < config["reveal_timeout"] * 2 ) if invalid_settle_timeout: raise InvalidSettleTimeout( ( "Settlement timeout for Registry contract {} must " "be in range [{}, {}], is {}" ).format( to_checksum_address(default_registry.address), settlement_timeout_min, settlement_timeout_max, config["settle_timeout"], ) ) self.config = config self.user_deposit = user_deposit self.raiden = raiden
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 __init__( self, config: typing.Dict, chain: BlockChainService, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, default_service_registry: typing.Optional[ServiceRegistry], transport, raiden_event_handler, message_handler, discovery: Discovery = None, user_deposit: UserDeposit = None, ): raiden = RaidenService( chain=chain, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, default_service_registry=default_service_registry, transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, config=config, discovery=discovery, user_deposit=user_deposit, ) # check that the settlement timeout fits the limits of the contract invalid_settle_timeout = ( config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max() or config['settle_timeout'] < config['reveal_timeout'] * 2 ) if invalid_settle_timeout: raise InvalidSettleTimeout( ( 'Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}' ).format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) self.config = config self.discovery = discovery self.user_deposit = user_deposit self.raiden = raiden self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def __init__( self, config: Dict, chain: BlockChainService, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, transport, discovery: Discovery = None, ): self.config = config self.discovery = discovery # check that the settlement timeout fits the limits of the contract invalid_timeout = (config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max()) if invalid_timeout: raise InvalidSettleTimeout( ('Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}').format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) try: self.raiden = RaidenService( chain, default_registry, default_secret_registry, unhexlify(config['privatekey_hex']), transport, config, discovery, ) except filelock.Timeout: pubkey = to_normalized_address( privatekey_to_address(unhexlify( self.config['privatekey_hex'])), ) print( f'FATAL: Another Raiden instance already running for account {pubkey} on ' f'network id {chain.network_id}', ) sys.exit(1) self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def can_open_channel(registry_address: PaymentNetworkID, token_address: TokenAddress, creator_address: Address, partner_address: Address, settle_timeout: BlockTimeout, raiden) -> TokenNetwork: if settle_timeout < 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") if not is_binary_address(creator_address): raise InvalidAddress( "Expected binary address format for creator in channel open") chain_state = views.state_from_raiden(raiden) channel_state = views.get_channelstate_for( chain_state=chain_state, payment_network_id=registry_address, creator_address=creator_address, token_address=token_address, partner_address=partner_address, ) if channel_state: raise DuplicatedChannelError( "Channel with given partner address already exists") registry: TokenNetworkRegistry = raiden.chain.token_network_registry( registry_address) token_network = raiden.chain.token_network( registry.get_token_network(token_address)) if token_network is None: raise TokenNotRegistered( "Token network for token %s does not exist" % to_checksum_address(token_address)) return token_network
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 __init__( self, config: typing.Dict, chain: BlockChainService, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, transport, discovery: Discovery = None, ): self.config = config self.discovery = discovery # check that the settlement timeout fits the limits of the contract invalid_timeout = (config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max()) if invalid_timeout: raise InvalidSettleTimeout( ('Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}').format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) try: self.raiden = RaidenService( chain=chain, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, private_key_bin=unhexlify(config['privatekey_hex']), transport=transport, config=config, discovery=discovery, ) except filelock.Timeout: pubkey = to_normalized_address( privatekey_to_address(unhexlify( self.config['privatekey_hex'])), ) print( f'FATAL: Another Raiden instance already running for account {pubkey} on ' f'network id {chain.network_id}', ) sys.exit(1)
def __init__( self, config: typing.Dict, chain: BlockChainService, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, transport, discovery: Discovery = None, ): raiden = RaidenService( chain=chain, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, private_key_bin=unhexlify(config['privatekey_hex']), transport=transport, config=config, discovery=discovery, ) # check that the settlement timeout fits the limits of the contract invalid_timeout = (config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max()) if invalid_timeout: raise InvalidSettleTimeout( ('Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}').format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) self.config = config self.discovery = discovery self.raiden = raiden self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def open(self, token_address, partner_address, settle_timeout=None, reveal_timeout=None): """ 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) assert token_address in self.raiden.token_to_channelgraph netcontract_address = channel_manager.new_netting_channel( self.raiden.address, partner_address, settle_timeout, ) while netcontract_address not in self.raiden.chain.address_to_nettingchannel: gevent.sleep(self.raiden.alarm.wait_time) graph = self.raiden.token_to_channelgraph[token_address] while partner_address not in graph.partneraddress_to_channel: gevent.sleep(self.raiden.alarm.wait_time) channel = graph.partneraddress_to_channel[partner_address] return channel
def open( self, token_address, partner_address, settle_timeout=None, reveal_timeout=None): """ 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 < self.raiden.config['settle_timeout']: raise InvalidSettleTimeout('Configured minimum `settle_timeout` is {} blocks.'.format( self.raiden.config['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.chain.manager_by_token(token_address) assert token_address in self.raiden.channelgraphs netcontract_address = channel_manager.new_netting_channel( self.raiden.address, partner_address, settle_timeout, ) while netcontract_address not in self.raiden.chain.address_contract: gevent.sleep(self.raiden.alarm.wait_time) graph = self.raiden.channelgraphs[token_address] while partner_address not in graph.partneraddress_channel: gevent.sleep(self.raiden.alarm.wait_time) channel = graph.partneraddress_channel[partner_address] return channel
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 new_netting_channel( self, partner: typing.Address, settle_timeout: int, ) -> typing.ChannelID: """ Creates a new channel in the TokenNetwork contract. Args: partner: The peer to open the channel with. settle_timeout: The settle timout to use for this channel. Returns: The ChannelID of the new netting channel. """ if not is_binary_address(partner): raise InvalidAddress( 'Expected binary address format for channel partner') invalid_timeout = (settle_timeout < self.settlement_timeout_min() or settle_timeout > self.settlement_timeout_max()) if invalid_timeout: raise InvalidSettleTimeout( 'settle_timeout must be in range [{}, {}], is {}'.format( self.settlement_timeout_min(), self.settlement_timeout_max(), settle_timeout, )) if self.node_address == partner: raise SamePeerAddress( 'The other peer must not have the same address as the client.') log_details = { 'peer1': pex(self.node_address), 'peer2': pex(partner), } log.debug('new_netting_channel called', **log_details) # Prevent concurrent attempts to open a channel with the same token and # partner address. if partner not in self.open_channel_transactions: new_open_channel_transaction = AsyncResult() self.open_channel_transactions[ partner] = new_open_channel_transaction try: transaction_hash = self._new_netting_channel( partner, settle_timeout) except Exception as e: log.critical('new_netting_channel failed', **log_details) new_open_channel_transaction.set_exception(e) raise else: new_open_channel_transaction.set(transaction_hash) finally: self.open_channel_transactions.pop(partner, None) else: # All other concurrent threads should block on the result of opening this channel self.open_channel_transactions[partner].get() channel_created = self.channel_exists_and_not_settled( self.node_address, partner) if channel_created is False: log.critical('new_netting_channel failed', **log_details) raise RaidenUnrecoverableError('creating new channel failed') channel_identifier = self.detail_channel(self.node_address, partner).channel_identifier log_details['channel_identifier'] = channel_identifier log.info('new_netting_channel succesful', **log_details) return channel_identifier
def new_netting_channel(self, other_peer: Address, settle_timeout: int) -> Address: """ Creates and deploys a new netting channel contract. Args: other_peer: The peer to open the channel with. settle_timeout: The settle timout to use for this channel. Returns: The address of the new netting channel. """ if not isaddress(other_peer): raise ValueError('The other_peer must be a valid address') invalid_timeout = ( settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX ) if invalid_timeout: raise InvalidSettleTimeout('settle_timeout must be in range [{}, {}]'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX )) local_address = privatekey_to_address(self.client.privkey) if local_address == other_peer: raise SamePeerAddress('The other peer must not have the same address as the client.') # Prevent concurrent attempts to open a channel with the same token and # partner address. if other_peer not in self.open_channel_transactions: new_open_channel_transaction = AsyncResult() self.open_channel_transactions[other_peer] = new_open_channel_transaction try: transaction_hash = self._new_netting_channel(other_peer, settle_timeout) except Exception as e: new_open_channel_transaction.set_exception(e) raise else: new_open_channel_transaction.set(transaction_hash) finally: self.open_channel_transactions.pop(other_peer, None) else: # All other concurrent threads should block on the result of opening this channel transaction_hash = self.open_channel_transactions[other_peer].get() netting_channel_results_encoded = self.proxy.call( 'getChannelWith', other_peer, ) # address is at index 0 netting_channel_address_encoded = netting_channel_results_encoded if not netting_channel_address_encoded: log.error( 'netting_channel_address failed', peer1=pex(local_address), peer2=pex(other_peer) ) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder(netting_channel_address_encoded) log.info( 'new_netting_channel called', peer1=pex(local_address), peer2=pex(other_peer), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
def __init__( self, config: typing.Dict, chain: BlockChainService, query_start_block: typing.BlockNumber, default_registry: TokenNetworkRegistry, default_secret_registry: SecretRegistry, transport, raiden_event_handler, message_handler, discovery: Discovery = None, ): raiden = RaidenService( chain=chain, query_start_block=query_start_block, default_registry=default_registry, default_secret_registry=default_secret_registry, private_key_bin=decode_hex(config['privatekey_hex']), transport=transport, raiden_event_handler=raiden_event_handler, message_handler=message_handler, config=config, discovery=discovery, ) # Check if files with older versions of the DB exist, emit a warning db_base_path = os.path.dirname(config['database_path']) old_version_path = older_db_file(db_base_path) if old_version_path: old_version_file = os.path.basename(old_version_path) raise RuntimeError( f'A database file for a previous version of Raiden exists ' f'{old_version_path}. Because the new version of Raiden ' f'introduces changes which break compatibility with the old ' f'database, a new database is necessary. The new database ' f'file will be created automatically for you, but as a side effect all ' f'previous data will be unavailable. The only way to proceed ' f'without the risk of losing funds is to leave all token networks ' f'and *make a backup* of the existing database. Please, *after* all the ' f'existing channels have been settled, make sure to make a backup by ' f'renaming {old_version_file} to {old_version_file}_backup. Then the new ' f'version of Raiden can be used.', ) # check that the settlement timeout fits the limits of the contract invalid_settle_timeout = ( config['settle_timeout'] < default_registry.settlement_timeout_min() or config['settle_timeout'] > default_registry.settlement_timeout_max() or config['settle_timeout'] < config['reveal_timeout'] * 2) if invalid_settle_timeout: raise InvalidSettleTimeout( ('Settlement timeout for Registry contract {} must ' 'be in range [{}, {}], is {}').format( to_checksum_address(default_registry.address), default_registry.settlement_timeout_min(), default_registry.settlement_timeout_max(), config['settle_timeout'], ), ) self.config = config self.discovery = discovery self.raiden = raiden self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def new_netting_channel( self, partner: typing.Address, settle_timeout: int, ) -> typing.ChannelID: """ Creates a new channel in the TokenNetwork contract. Args: partner: The peer to open the channel with. settle_timeout: The settle timout to use for this channel. Returns: The address of the new netting channel. """ if not is_binary_address(partner): raise InvalidAddress('Expected binary address format for channel partner') invalid_timeout = ( settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX ) if invalid_timeout: raise InvalidSettleTimeout('settle_timeout must be in range [{}, {}]'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX, )) if self.node_address == partner: raise SamePeerAddress('The other peer must not have the same address as the client.') # Prevent concurrent attempts to open a channel with the same token and # partner address. if partner not in self.open_channel_transactions: new_open_channel_transaction = AsyncResult() self.open_channel_transactions[partner] = new_open_channel_transaction try: transaction_hash = self._new_netting_channel(partner, settle_timeout) except Exception as e: new_open_channel_transaction.set_exception(e) raise else: new_open_channel_transaction.set(transaction_hash) finally: self.open_channel_transactions.pop(partner, None) else: # All other concurrent threads should block on the result of opening this channel transaction_hash = self.open_channel_transactions[partner].get() channel_created = self.channel_exists(partner) if channel_created is False: log.error( 'creating new channel failed', peer1=pex(self.node_address), peer2=pex(partner), ) raise RuntimeError('creating new channel failed') channel_identifier = self.detail_channel(partner)['channel_identifier'] log.info( 'new_netting_channel called', peer1=pex(self.node_address), peer2=pex(partner), channel_identifier=channel_identifier, ) return channel_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 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 new_netting_channel(self, other_peer: Address, settle_timeout: int) -> Address: """ Creates and deploys a new netting channel contract. Args: other_peer: The peer to open the channel with. settle_timeout: The settle timout to use for this channel. Returns: The address of the new netting channel. """ if not isaddress(other_peer): raise ValueError('The other_peer must be a valid address') invalid_timeout = (settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX) if invalid_timeout: raise InvalidSettleTimeout( 'settle_timeout must be in range [{}, {}]'.format( NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)) local_address = privatekey_to_address(self.client.privkey) if local_address == other_peer: raise SamePeerAddress( 'The other peer must not have the same address as the client.') transaction_hash = estimate_and_transact( self.proxy, 'newChannel', other_peer, settle_timeout, ) self.client.poll(unhexlify(transaction_hash), timeout=self.poll_timeout) if check_transaction_threw(self.client, transaction_hash): raise DuplicatedChannelError('Duplicated channel') netting_channel_results_encoded = self.proxy.call( 'getChannelWith', other_peer, ) # address is at index 0 netting_channel_address_encoded = netting_channel_results_encoded if not netting_channel_address_encoded: log.error('netting_channel_address failed', peer1=pex(local_address), peer2=pex(other_peer)) raise RuntimeError('netting_channel_address failed') netting_channel_address_bin = address_decoder( netting_channel_address_encoded) if log.isEnabledFor(logging.INFO): log.info( 'new_netting_channel called', peer1=pex(local_address), peer2=pex(other_peer), netting_channel=pex(netting_channel_address_bin), ) return netting_channel_address_bin
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 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