def geth_assert_rpc_interfaces(web3: Web3):
try:
web3.version.node
except ValueError:
raise EthNodeInterfaceError(
"The underlying geth node does not have the web3 rpc interface "
"enabled. Please run it with --rpcapi eth,net,web3,txpool")
try:
web3.eth.blockNumber
except ValueError:
raise EthNodeInterfaceError(
"The underlying geth node does not have the eth rpc interface "
"enabled. Please run it with --rpcapi eth,net,web3,txpool")
try:
web3.net.version
except ValueError:
raise EthNodeInterfaceError(
"The underlying geth node does not have the net rpc interface "
"enabled. Please run it with --rpcapi eth,net,web3,txpool")
try:
web3.txpool.inspect
except ValueError:
raise EthNodeInterfaceError(
"The underlying geth node does not have the txpool rpc interface "
"enabled. Please run it with --rpcapi eth,net,web3,txpool")
def parity_assert_rpc_interfaces(web3: Web3):
try:
web3.version.node
except ValueError:
raise EthNodeInterfaceError(
"The underlying parity node does not have the web3 rpc interface "
"enabled. Please run it with --jsonrpc-apis=eth,net,web3,parity")
try:
web3.eth.blockNumber
except ValueError:
raise EthNodeInterfaceError(
"The underlying parity node does not have the eth rpc interface "
"enabled. Please run it with --jsonrpc-apis=eth,net,web3,parity")
try:
web3.net.version
except ValueError:
raise EthNodeInterfaceError(
"The underlying parity node does not have the net rpc interface "
"enabled. Please run it with --jsonrpc-apis=eth,net,web3,parity")
try:
web3.manager.request_blocking(
"parity_nextNonce", ["0x0000000000000000000000000000000000000000"])
except ValueError:
raise EthNodeInterfaceError(
"The underlying parity node does not have the parity rpc interface "
"enabled. Please run it with --jsonrpc-apis=eth,net,web3,parity")
def __init__(
self,
web3: Web3,
privkey: Optional[PrivateKey],
gas_price_strategy: Callable = rpc_gas_price_strategy,
gas_estimate_correction: Callable = lambda gas: gas,
block_num_confirmations: int = 0,
) -> None:
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)
version = web3.version.node
supported, eth_node, _ = is_supported_client(version)
if not supported:
raise EthNodeInterfaceError(
f"Unsupported Ethereum client {version}")
address = privatekey_to_address(privkey)
address_checksumed = to_checksum_address(address)
if eth_node is EthClient.PARITY:
parity_assert_rpc_interfaces(web3)
available_nonce = parity_discover_next_available_nonce(
web3, address_checksumed)
elif eth_node is EthClient.GETH:
geth_assert_rpc_interfaces(web3)
available_nonce = geth_discover_next_available_nonce(
web3, address_checksumed)
self.eth_node = eth_node
self.privkey = privkey
self.address = address
self.web3 = web3
self.default_block_num_confirmations = block_num_confirmations
# Ask for the chain id only once and store it here
self.chain_id = ChainID(int(self.web3.version.network))
self._available_nonce = available_nonce
self._nonce_lock = Semaphore()
self._gas_estimate_correction = gas_estimate_correction
log.debug(
"JSONRPCClient created",
node=to_checksum_address(self.address),
available_nonce=available_nonce,
client=version,
)
def check_ethereum_client_is_supported(web3: Web3) -> None:
try:
node_version = web3.clientVersion
except ValueError:
raise EthNodeInterfaceError(
"The underlying ethereum node does not have the web3 rpc interface "
"enabled. Please run it with --rpcapi eth,net,web3 for geth "
"and --jsonrpc-apis=eth,net,web3,parity for parity.")
supported, our_client, our_version = is_supported_client(node_version)
if not supported:
raise RaidenError(
f"You need a Byzantium enabled ethereum node. Parity >= "
f"{LOWEST_SUPPORTED_PARITY_VERSION} <= {HIGHEST_SUPPORTED_PARITY_VERSION}"
f" or Geth >= {LOWEST_SUPPORTED_GETH_VERSION} <= {HIGHEST_SUPPORTED_GETH_VERSION}"
f" but you have {our_version} {our_client}")
def check_ethereum_client_is_supported(web3: Web3) -> None:
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)
def test_run_error_reporting(cli_runner, monkeypatch):
caught_exceptions = {
APIServerPortInUseError(): ReturnCode.PORT_ALREADY_IN_USE,
ConfigurationError(): ReturnCode.RAIDEN_CONFIGURATION_ERROR,
ConnectTimeout(): ReturnCode.GENERIC_COMMUNICATION_ERROR,
ConnectionError(): ReturnCode.GENERIC_COMMUNICATION_ERROR,
EthereumNonceTooLow(): ReturnCode.ETH_ACCOUNT_ERROR,
EthNodeInterfaceError(): ReturnCode.ETH_INTERFACE_ERROR,
KeystoreAuthenticationError(): ReturnCode.ETH_ACCOUNT_ERROR,
KeystoreFileNotFound(): ReturnCode.ETH_ACCOUNT_ERROR,
RaidenUnrecoverableError(): ReturnCode.FATAL,
ReplacementTransactionUnderpriced(): ReturnCode.ETH_ACCOUNT_ERROR,
RequestsConnectionError(): ReturnCode.GENERIC_COMMUNICATION_ERROR,
Exception(): ReturnCode.FATAL,
}
for exception, code in caught_exceptions.items():
monkeypatch.setattr(cli, "run_services", mock_raises(exception))
result = cli_runner(cli.run, "--accept-disclaimer")
assert result.exception.code == code
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,
gas_estimate_correction: Callable = lambda gas: gas,
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 is constants.EthClient.PARITY:
parity_assert_rpc_interfaces(web3)
available_nonce = parity_discover_next_available_nonce(
web3, address_checksumed)
elif eth_node is 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()
self._gas_estimate_correction = gas_estimate_correction
log.debug(
"JSONRPCClient created",
node=pex(self.address),
available_nonce=available_nonce,
client=version,
)
