def test_check_json_rpc_geth(): g1, client = is_supported_client( 'Geth/v1.7.3-unstable-e9295163/linux-amd64/go1.9.1') g2, _ = is_supported_client( 'Geth/v1.7.2-unstable-e9295163/linux-amd64/go1.9.1') g3, _ = is_supported_client( 'Geth/v1.8.2-unstable-e9295163/linux-amd64/go1.9.1') g4, _ = is_supported_client( 'Geth/v2.0.3-unstable-e9295163/linux-amd64/go1.9.1') g5, _ = is_supported_client( 'Geth/v11.55.86-unstable-e9295163/linux-amd64/go1.9.1') g6, _ = is_supported_client( 'Geth/v999.999.999-unstable-e9295163/linux-amd64/go1.9.1') assert client == EthClient.GETH assert all([g1, g2, g3, g4, g5, g6]) b1, client = is_supported_client( 'Geth/v1.7.1-unstable-e9295163/linux-amd64/go1.9.1') b2, _ = is_supported_client( 'Geth/v0.7.1-unstable-e9295163/linux-amd64/go1.9.1') b3, _ = is_supported_client( 'Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1') b4, _ = is_supported_client( 'Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1') assert not client assert not any([b1, b2, b3, b4])
def test_check_json_rpc_geth(): g1, client = is_supported_client('Geth/v1.7.3-unstable-e9295163/linux-amd64/go1.9.1') g2, _ = is_supported_client('Geth/v1.7.2-unstable-e9295163/linux-amd64/go1.9.1') g3, _ = is_supported_client('Geth/v1.8.2-unstable-e9295163/linux-amd64/go1.9.1') g4, _ = is_supported_client('Geth/v2.0.3-unstable-e9295163/linux-amd64/go1.9.1') g5, _ = is_supported_client('Geth/v11.55.86-unstable-e9295163/linux-amd64/go1.9.1') g6, _ = is_supported_client('Geth/v999.999.999-unstable-e9295163/linux-amd64/go1.9.1') assert client == EthClient.GETH assert all([g1, g2, g3, g4, g5, g6]) b1, client = is_supported_client('Geth/v1.7.1-unstable-e9295163/linux-amd64/go1.9.1') b2, _ = is_supported_client('Geth/v0.7.1-unstable-e9295163/linux-amd64/go1.9.1') b3, _ = is_supported_client('Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1') b4, _ = is_supported_client('Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1') assert not client assert not any([b1, b2, b3, b4])
def __init__( self, host: str, port: int, privkey: bytes, gasprice: int = None, nonce_update_interval: float = 5.0, nonce_offset: int = 0, web3: Web3 = None, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') endpoint = 'http://{}:{}'.format(host, port) self.port = port self.privkey = privkey self.sender = privatekey_to_address(privkey) # Needs to be initialized to None in the beginning since JSONRPCClient # gets constructed before the RaidenService Object. self.stop_event = None self._nonce_offset = nonce_offset self._nonce_lock = Semaphore() self.given_gas_price = gasprice self._gaslimit_cache = TTLCache(maxsize=16, ttl=RPC_CACHE_TTL) self._gasprice_cache = TTLCache(maxsize=16, ttl=RPC_CACHE_TTL) self._nonce_cache = TTLCache(maxsize=16, ttl=nonce_update_interval) # web3 if web3 is None: self.web3: Web3 = Web3(HTTPProvider(endpoint)) else: self.web3 = web3 try: # we use a PoA chain for smoketest, use this middleware to fix this self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) except ValueError: # `middleware_stack.inject()` raises a value error if the same middleware is # injected twice. This happens with `eth-tester` setup where a single session # scoped web3 instance is used for all clients pass # create the connection test middleware (but only for non-tester chain) if not hasattr(web3, 'testing'): connection_test = make_connection_test_middleware(self) self.web3.middleware_stack.inject(connection_test, layer=0) supported, self.eth_node = is_supported_client(self.web3.version.node) if not supported: print( 'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2' ) sys.exit(1)
def test_check_json_rpc_geth(): assert is_supported_client( 'Geth/v1.7.3-unstable-e9295163/linux-amd64/go1.9.1') assert is_supported_client( 'Geth/v1.7.2-unstable-e9295163/linux-amd64/go1.9.1') assert is_supported_client( 'Geth/v1.8.2-unstable-e9295163/linux-amd64/go1.9.1') assert is_supported_client( 'Geth/v2.0.3-unstable-e9295163/linux-amd64/go1.9.1') assert is_supported_client( 'Geth/v11.55.86-unstable-e9295163/linux-amd64/go1.9.1') assert is_supported_client( 'Geth/v999.999.999-unstable-e9295163/linux-amd64/go1.9.1') assert not is_supported_client( 'Geth/v1.7.1-unstable-e9295163/linux-amd64/go1.9.1') assert not is_supported_client( 'Geth/v0.7.1-unstable-e9295163/linux-amd64/go1.9.1') assert not is_supported_client( 'Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1') assert not is_supported_client( 'Geth/v0.0.0-unstable-e9295163/linux-amd64/go1.9.1')
def _setup_web3(eth_rpc_endpoint): web3 = Web3(HTTPProvider(eth_rpc_endpoint)) try: node_version = web3.version.node # pylint: disable=no-member except ConnectTimeout: raise EthNodeCommunicationError("Couldn't connect to the ethereum node") supported, _ = is_supported_client(node_version) if not supported: click.secho( 'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2', fg='red', ) sys.exit(1) return web3
def check_json_rpc(client): try: client_version = client.web3.version.node except (requests.exceptions.ConnectionError, EthNodeCommunicationError): print( '\n' 'Could not contact the ethereum node through JSON-RPC.\n' 'Please make sure that JSON-RPC is enabled for these interfaces:\n' '\n' ' eth_*, net_*, web3_*\n' '\n' 'geth: https://github.com/ethereum/go-ethereum/wiki/Management-APIs\n' ) sys.exit(1) else: if not is_supported_client(client_version): print('You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2') sys.exit(1)
def __init__( self, web3: Web3, privkey: bytes, gasprice: int = None, nonce_offset: int = 0, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') monkey_patch_web3(web3, self) try: version = web3.version.node except ConnectTimeout: raise EthNodeCommunicationError('couldnt reach the ethereum node') _, eth_node = is_supported_client(version) sender = privatekey_to_address(privkey) transaction_count = web3.eth.getTransactionCount( to_checksum_address(sender), 'pending') _available_nonce = transaction_count + nonce_offset self.eth_node = eth_node self.given_gas_price = gasprice self.privkey = privkey self.sender = sender # Needs to be initialized to None in the beginning since JSONRPCClient # gets constructed before the RaidenService Object. self.stop_event = None self.web3 = web3 self._gaslimit_cache = TTLCache(maxsize=16, ttl=RPC_CACHE_TTL) self._gasprice_cache = TTLCache(maxsize=16, ttl=RPC_CACHE_TTL) self._available_nonce = _available_nonce self._nonce_lock = Semaphore() self._nonce_offset = nonce_offset log.debug( 'JSONRPCClient created', sender=pex(self.sender), available_nonce=_available_nonce, )
def _setup_web3(eth_rpc_endpoint): web3 = Web3(HTTPProvider(eth_rpc_endpoint)) try: node_version = web3.version.node # pylint: disable=no-member except ConnectTimeout: raise EthNodeCommunicationError("Couldn't connect to the ethereum node") except ValueError: raise EthNodeInterfaceError( 'The underlying ethereum node does not have the web3 rpc interface ' 'enabled. Please run it with --rpcapi eth,net,web3,txpool for geth ' 'and --jsonrpc-apis=eth,net,web3,parity for parity.', ) supported, _ = is_supported_client(node_version) if not supported: click.secho( 'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2', fg='red', ) sys.exit(1) return web3
def __init__( self, web3: Web3, privkey: bytes, gas_price_strategy: Callable = rpc_gas_price_strategy, nonce_offset: int = 0, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') monkey_patch_web3(web3, self, gas_price_strategy) try: version = web3.version.node except ConnectTimeout: raise EthNodeCommunicationError('couldnt reach the ethereum node') _, eth_node = is_supported_client(version) sender = privatekey_to_address(privkey) transaction_count = web3.eth.getTransactionCount( to_checksum_address(sender), 'pending') _available_nonce = transaction_count + nonce_offset self.eth_node = eth_node self.privkey = privkey self.sender = sender self.web3 = web3 self._gasprice_cache = TTLCache(maxsize=16, ttl=RPC_CACHE_TTL) self._available_nonce = _available_nonce self._nonce_lock = Semaphore() self._nonce_offset = nonce_offset log.debug( 'JSONRPCClient created', sender=pex(self.sender), available_nonce=_available_nonce, )
def _setup_web3(eth_rpc_endpoint): web3 = Web3(HTTPProvider(eth_rpc_endpoint)) try: node_version = web3.version.node # pylint: disable=no-member except ConnectTimeout: raise EthNodeCommunicationError( "Couldn't connect to the ethereum node") except ValueError: raise EthNodeInterfaceError( 'The underlying ethereum node does not have the web3 rpc interface ' 'enabled. Please run it with --rpcapi eth,net,web3,txpool for geth ' 'and --jsonrpc-apis=eth,net,web3,parity for parity.', ) supported, _ = is_supported_client(node_version) if not supported: click.secho( 'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2', fg='red', ) sys.exit(1) return web3
def __init__( self, host: str, port: int, privkey: bytes, gasprice: int = None, nonce_update_interval: float = 5.0, nonce_offset: int = 0, web3: Web3 = None, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') endpoint = 'http://{}:{}'.format(host, port) self.port = port self.privkey = privkey self.sender = privatekey_to_address(privkey) # Needs to be initialized to None in the beginning since JSONRPCClient # gets constructed before the RaidenService Object. self.stop_event = None self.nonce_last_update = 0 self.nonce_available_value = None self.nonce_lock = Semaphore() self.nonce_update_interval = nonce_update_interval self.nonce_offset = nonce_offset self.given_gas_price = gasprice cache = cachetools.TTLCache( maxsize=1, ttl=RPC_CACHE_TTL, ) cache_wrapper = cachetools.cached(cache=cache) self.gaslimit = cache_wrapper(self._gaslimit) cache = cachetools.TTLCache( maxsize=1, ttl=RPC_CACHE_TTL, ) cache_wrapper = cachetools.cached(cache=cache) self.gasprice = cache_wrapper(self._gasprice) # web3 if web3 is None: self.web3: Web3 = Web3(HTTPProvider(endpoint)) else: self.web3 = web3 try: # we use a PoA chain for smoketest, use this middleware to fix this self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) except ValueError: # `middleware_stack.inject()` raises a value error if the same middleware is # injected twice. This happens with `eth-tester` setup where a single session # scoped web3 instance is used for all clients pass # create the connection test middleware (but only for non-tester chain) if not hasattr(web3, 'testing'): connection_test = make_connection_test_middleware(self) self.web3.middleware_stack.inject(connection_test, layer=0) supported, self.eth_node = is_supported_client(self.web3.version.node) if not supported: print('You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2') sys.exit(1)
def test_check_json_rpc_parity(): g1, client = is_supported_client( 'Parity//v1.7.6-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g2, _ = is_supported_client( 'Parity//v1.7.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g3, _ = is_supported_client( 'Parity//v1.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g4, _ = is_supported_client( 'Parity//v2.9.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g5, _ = is_supported_client( 'Parity//v23.94.75-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g6, _ = is_supported_client( 'Parity//v99.994.975-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert client == EthClient.PARITY assert all([g1, g2, g3, g4, g5, g6]) b1, client = is_supported_client( 'Parity//v1.7.5-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b2, _ = is_supported_client( 'Parity//v1.5.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b3, _ = is_supported_client( 'Parity//v0.7.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b4, _ = is_supported_client( 'Parity//v0.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b5, _ = is_supported_client( 'Parity//v0.0.0-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not client assert not any([b1, b2, b3, b4, b5])
def run_app( address, keystore_path, gas_price, eth_rpc_endpoint, registry_contract_address, secret_registry_contract_address, discovery_contract_address, listen_address, mapped_socket, max_unresponsive_time, api_address, rpc, sync_check, console, password_file, web_ui, datadir, transport, matrix_server, network_id, extra_config=None, **kwargs, ): # pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument from raiden.app import App if transport == 'udp' and not mapped_socket: raise RuntimeError('Missing socket') address_hex = to_normalized_address(address) if address else None address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file) address = to_canonical_address(address_hex) (listen_host, listen_port) = split_endpoint(listen_address) (api_host, api_port) = split_endpoint(api_address) if datadir is None: datadir = os.path.join(os.path.expanduser('~'), '.raiden') config = deepcopy(App.DEFAULT_CONFIG) if extra_config: merge_dict(config, extra_config) config['transport']['udp']['host'] = listen_host config['transport']['udp']['port'] = listen_port config['console'] = console config['rpc'] = rpc config['web_ui'] = rpc and web_ui config['api_host'] = api_host config['api_port'] = api_port if mapped_socket: config['socket'] = mapped_socket.socket config['transport']['udp']['external_ip'] = mapped_socket.external_ip config['transport']['udp'][ 'external_port'] = mapped_socket.external_port config['transport_type'] = transport config['transport']['matrix']['server'] = matrix_server config['transport']['udp'][ 'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES config['transport']['udp']['nat_keepalive_timeout'] = timeout privatekey_hex = hexlify(privatekey_bin) config['privatekey_hex'] = privatekey_hex parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint) if not parsed_eth_rpc_endpoint.scheme: eth_rpc_endpoint = f'http://{eth_rpc_endpoint}' web3 = Web3(HTTPProvider(eth_rpc_endpoint)) try: node_version = web3.version.node # pylint: disable=no-member except ConnectTimeout: raise EthNodeCommunicationError( "Couldn't connect to the ethereum node") supported, _ = is_supported_client(node_version) if not supported: print( 'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2' ) sys.exit(1) rpc_client = JSONRPCClient( web3, privatekey_bin, gasprice=gas_price, ) blockchain_service = BlockChainService(privatekey_bin, rpc_client) net_id = blockchain_service.network_id if net_id != network_id: if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME: print(( "The chosen ethereum network '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format( constants.ID_TO_NETWORKNAME[network_id], constants.ID_TO_NETWORKNAME[net_id])) else: print(( "The chosen ethereum network id '{}' differs from the ethereum client '{}'. " 'Please update your settings.').format(network_id, net_id)) sys.exit(1) config['chain_id'] = network_id if sync_check: check_synced(blockchain_service) database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8], 'log.db') config['database_path'] = database_path print( '\nYou are connected to the \'{}\' network and the DB path is: {}'. format( constants.ID_TO_NETWORKNAME.get(net_id) or net_id, database_path, ), ) contract_addresses_given = (registry_contract_address is not None and secret_registry_contract_address is not None and discovery_contract_address is not None) contract_addresses_known = net_id in constants.ID_TO_NETWORK_CONFIG if not contract_addresses_given and not contract_addresses_known: print(( "There are known contract addresses for network id '{}'. Please provide " 'them in the command line or the configuration file.' ).format(net_id)) sys.exit(1) contract_addresses = constants.ID_TO_NETWORK_CONFIG.get(net_id, dict()) try: token_network_registry = blockchain_service.token_network_registry( registry_contract_address or contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ) except ContractVersionMismatch: handle_contract_version_mismatch('token network registry', registry_contract_address) except AddressWithoutCode: handle_contract_no_code('token network registry', registry_contract_address) except AddressWrongContract: handle_contract_wrong_address('token network registry', registry_contract_address) try: secret_registry = blockchain_service.secret_registry( secret_registry_contract_address or contract_addresses[CONTRACT_SECRET_REGISTRY], ) except ContractVersionMismatch: handle_contract_version_mismatch('secret registry', secret_registry_contract_address) except AddressWithoutCode: handle_contract_no_code('secret registry', secret_registry_contract_address) except AddressWrongContract: handle_contract_wrong_address('secret registry', secret_registry_contract_address) discovery = None if transport == 'udp': check_discovery_registration_gas(blockchain_service, address) try: dicovery_proxy = blockchain_service.discovery( discovery_contract_address or contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ) discovery = ContractDiscovery( blockchain_service.node_address, dicovery_proxy, ) except ContractVersionMismatch: handle_contract_version_mismatch('discovery', discovery_contract_address) except AddressWithoutCode: handle_contract_no_code('discovery', discovery_contract_address) except AddressWrongContract: handle_contract_wrong_address('discovery', discovery_contract_address) throttle_policy = TokenBucket( config['transport']['udp']['throttle_capacity'], config['transport']['udp']['throttle_fill_rate'], ) transport = UDPTransport( discovery, mapped_socket.socket, throttle_policy, config['transport']['udp'], ) elif transport == 'matrix': try: transport = MatrixTransport(config['transport']['matrix']) except RaidenError as ex: click.secho(f'FATAL: {ex}', fg='red') sys.exit(1) else: raise RuntimeError(f'Unknown transport type "{transport}" given') try: chain_config = constants.ID_TO_NETWORK_CONFIG.get(net_id, {}) start_block = chain_config.get(constants.START_QUERY_BLOCK_KEY, 0) raiden_app = App( config=config, chain=blockchain_service, query_start_block=start_block, default_registry=token_network_registry, default_secret_registry=secret_registry, transport=transport, discovery=discovery, ) except RaidenError as e: click.secho(f'FATAL: {e}', fg='red') sys.exit(1) try: raiden_app.start() except filelock.Timeout: name_or_id = constants.ID_TO_NETWORKNAME.get(network_id, network_id) print( f'FATAL: Another Raiden instance already running for account {address_hex} on ' f'network id {name_or_id}', ) sys.exit(1) return raiden_app
def __init__( self, web3: Web3, privkey: bytes, gas_price_strategy: typing.Callable = rpc_gas_price_strategy, block_num_confirmations: int = 0, uses_infura=False, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') if block_num_confirmations < 0: raise ValueError('Number of confirmations has to be positive', ) monkey_patch_web3(web3, gas_price_strategy) try: version = web3.version.node except ConnectTimeout: raise EthNodeCommunicationError('couldnt reach the ethereum node') _, eth_node = is_supported_client(version) address = privatekey_to_address(privkey) address_checksumed = to_checksum_address(address) if uses_infura: warnings.warn( 'Infura does not provide an API to ' 'recover the latest used nonce. This may cause the Raiden node ' 'to error on restarts.\n' 'The error will manifest while there is a pending transaction ' 'from a previous execution in the Ethereum\'s client pool. When ' 'Raiden restarts the same transaction with the same nonce will ' 'be retried and *rejected*, because the nonce is already used.', ) # The first valid nonce is 0, therefore the count is already the next # available nonce available_nonce = web3.eth.getTransactionCount( address_checksumed, 'pending') elif eth_node == constants.EthClient.PARITY: parity_assert_rpc_interfaces(web3) available_nonce = parity_discover_next_available_nonce( web3, address_checksumed, ) elif eth_node == constants.EthClient.GETH: geth_assert_rpc_interfaces(web3) available_nonce = geth_discover_next_available_nonce( web3, address_checksumed, ) else: raise EthNodeInterfaceError( f'Unsupported Ethereum client {version}') self.eth_node = eth_node self.privkey = privkey self.address = address self.web3 = web3 self.default_block_num_confirmations = block_num_confirmations self._available_nonce = available_nonce self._nonce_lock = Semaphore() log.debug( 'JSONRPCClient created', node=pex(self.address), available_nonce=available_nonce, client=version, )
def test_check_json_rpc_parity(): g1, client = is_supported_client( 'Parity//v1.7.6-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g2, _ = is_supported_client( 'Parity//v1.7.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g3, _ = is_supported_client( 'Parity//v1.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g4, _ = is_supported_client( 'Parity//v2.9.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g5, _ = is_supported_client( 'Parity//v23.94.75-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) g6, _ = is_supported_client( 'Parity//v99.994.975-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert client == EthClient.PARITY assert all([g1, g2, g3, g4, g5, g6]) b1, client = is_supported_client( 'Parity//v1.7.5-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b2, _ = is_supported_client( 'Parity//v1.5.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b3, _ = is_supported_client( 'Parity//v0.7.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b4, _ = is_supported_client( 'Parity//v0.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) b5, _ = is_supported_client( 'Parity//v0.0.0-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not client assert not any([b1, b2, b3, b4, b5])
def test_check_json_rpc_parity(): assert is_supported_client( 'Parity//v1.7.6-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert is_supported_client( 'Parity//v1.7.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert is_supported_client( 'Parity//v1.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert is_supported_client( 'Parity//v2.9.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert is_supported_client( 'Parity//v23.94.75-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert is_supported_client( 'Parity//v99.994.975-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not is_supported_client( 'Parity//v1.7.5-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not is_supported_client( 'Parity//v1.5.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not is_supported_client( 'Parity//v0.7.1-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not is_supported_client( 'Parity//v0.8.7-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', ) assert not is_supported_client( 'Parity//v0.0.0-stable-19535333c-20171013/x86_64-linux-gnu/rustc1.20.0', )
def __init__( self, web3: Web3, privkey: bytes, gas_price_strategy: Callable = rpc_gas_price_strategy, block_num_confirmations: int = 0, uses_infura=False, ): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') if block_num_confirmations < 0: raise ValueError( 'Number of confirmations has to be positive', ) monkey_patch_web3(web3, gas_price_strategy) try: version = web3.version.node except ConnectTimeout: raise EthNodeCommunicationError('couldnt reach the ethereum node') _, eth_node = is_supported_client(version) address = privatekey_to_address(privkey) address_checksumed = to_checksum_address(address) if uses_infura: warnings.warn( 'Infura does not provide an API to ' 'recover the latest used nonce. This may cause the Raiden node ' 'to error on restarts.\n' 'The error will manifest while there is a pending transaction ' 'from a previous execution in the Ethereum\'s client pool. When ' 'Raiden restarts the same transaction with the same nonce will ' 'be retried and *rejected*, because the nonce is already used.', ) # The first valid nonce is 0, therefore the count is already the next # available nonce available_nonce = web3.eth.getTransactionCount(address_checksumed, 'pending') elif eth_node == constants.EthClient.PARITY: parity_assert_rpc_interfaces(web3) available_nonce = parity_discover_next_available_nonce( web3, address_checksumed, ) elif eth_node == constants.EthClient.GETH: geth_assert_rpc_interfaces(web3) available_nonce = geth_discover_next_available_nonce( web3, address_checksumed, ) else: raise EthNodeInterfaceError(f'Unsupported Ethereum client {version}') self.eth_node = eth_node self.privkey = privkey self.address = address self.web3 = web3 self.default_block_num_confirmations = block_num_confirmations self._available_nonce = available_nonce self._nonce_lock = Semaphore() log.debug( 'JSONRPCClient created', node=pex(self.address), available_nonce=available_nonce, client=version, )