solver-multirpc 3.1.4__py3-none-any.whl

src/multirpc/exceptions.py

@@ -0,0 +1,77 @@
+from src.multirpc.tx_trace import TxTrace
+
+BaseException_ = Exception
+
+
+class Web3InterfaceException(BaseException_):
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.args[0]})"
+
+
+class OutOfRangeTransactionFee(Web3InterfaceException):
+    pass
+
+
+class FailedOnAllRPCs(Web3InterfaceException):
+    pass
+
+
+class ViewCallFailed(Web3InterfaceException):
+    pass
+
+
+class TransactionFailedStatus(Web3InterfaceException):
+    def __init__(self, hex_tx_hash, func_name=None, func_args=None, func_kwargs=None, trace=None):
+        self.hex_tx_hash = hex_tx_hash
+        self.func_name = func_name
+        self.func_args = func_args
+        self.func_kwargs = func_kwargs
+        self.trace: TxTrace = trace
+
+    def __str__(self):
+        return (f'{self.__class__.__name__}({self.hex_tx_hash} func={self.func_name}, '
+                f'{self.func_name=}, {self.func_kwargs=}, {self.trace=})')
+
+    def __repr__(self):
+        return (f'{self.__class__.__name__}({self.hex_tx_hash} func={self.func_name}, '
+                f'{self.func_name=}, {self.func_kwargs=}, {self.trace=})')
+
+
+class FailedToGetGasPrice(Web3InterfaceException):
+    pass
+
+
+class MaximumRPCInEachBracketReached(Web3InterfaceException):
+    pass
+
+
+class AtLastProvideOneValidRPCInEachBracket(Web3InterfaceException):
+    pass
+
+
+class TransactionValueError(Web3InterfaceException):
+    pass
+
+
+class GetBlockFailed(Web3InterfaceException):
+    pass
+
+
+class DontHaveThisRpcType(Web3InterfaceException):
+    pass
+
+
+class NotValidViewPolicy(Web3InterfaceException):
+    pass
+
+
+class TransactionTypeNotSupportedInMultiCall(Web3InterfaceException):
+    pass
+
+
+class KwargsNotSupportedInMultiCall(Web3InterfaceException):
+    pass
+
+
+class FailedToGetGasFromApi(Web3InterfaceException):
+    pass

src/multirpc/gas_estimation.py

@@ -0,0 +1,151 @@
+import logging
+from _decimal import Decimal
+from decimal import Decimal
+from typing import Callable, Dict, List, Optional, Union
+
+import requests
+from aiohttp import ClientResponseError
+from requests import ConnectionError, JSONDecodeError, ReadTimeout, RequestException
+from web3 import AsyncWeb3, Web3
+from web3.types import Wei
+
+from .constants import ChainIdToGas, DEFAULT_API_PROVIDER, DevEnv, FixedValueGas, GasEstimationLogger, \
+    GasEstimationMethod, \
+    GasFromRpcChainIds, GasMultiplierHigh, GasMultiplierLow, GasMultiplierMedium, RequestTimeout
+from .exceptions import FailedToGetGasFromApi, FailedToGetGasPrice, OutOfRangeTransactionFee
+from .utils import TxPriority
+
+
+class GasEstimation:
+
+    def __init__(
+            self,
+            chain_id: int,
+            providers: List[AsyncWeb3],
+            default_method: Optional[GasEstimationMethod] = None,
+            apm_client=None,
+            gas_multiplier_low: Union[float, Decimal] = GasMultiplierLow,
+            gas_multiplier_medium: Union[float, Decimal] = GasMultiplierMedium,
+            gas_multiplier_high: Union[float, Decimal] = GasMultiplierHigh,
+            gas_api_provider: str = DEFAULT_API_PROVIDER,
+            log_level: logging = logging.WARN
+    ):
+        self.gas_api_provider = gas_api_provider
+        self.chain_id = chain_id
+        self.providers = providers
+        self.default_method: GasEstimationMethod = default_method
+        self.apm = apm_client
+        self.multipliers = {
+            TxPriority.Low: gas_multiplier_low,
+            TxPriority.Medium: gas_multiplier_medium,
+            TxPriority.High: gas_multiplier_high,
+        }
+        self.gas_estimation_method: Dict[GasEstimationMethod, Callable] = {
+            GasEstimationMethod.GAS_API_PROVIDER: self._get_gas_from_api,
+            GasEstimationMethod.RPC: self._get_gas_from_rpc,
+            GasEstimationMethod.FIXED: self._get_fixed_value,
+            GasEstimationMethod.CUSTOM: self._custom_gas_estimation,
+        }
+        self.method_sorted_priority = [
+            GasEstimationMethod.GAS_API_PROVIDER,
+            GasEstimationMethod.RPC,
+            GasEstimationMethod.FIXED,
+            GasEstimationMethod.CUSTOM
+        ]
+        GasEstimationLogger.setLevel(log_level)
+
+    def __logger_params(self, **kwargs):
+        if self.apm:
+            self.apm.span_label(**kwargs)
+        else:
+            GasEstimationLogger.info(f'params={kwargs}')
+
+    async def _get_gas_from_api(self, priority: TxPriority, gas_upper_bound: Union[float, Decimal]) -> Dict[str, Wei]:
+        gas_provider = self.gas_api_provider.format(chain_id=self.chain_id)
+        resp = None
+        try:
+            resp = requests.get(gas_provider, timeout=RequestTimeout)
+            if resp.status_code != 200:
+                raise FailedToGetGasFromApi(f'failed to get gas with {resp.status_code=} on {gas_provider=}')
+            resp_json = resp.json()
+            max_fee_per_gas = Decimal(resp_json[priority.value]["suggestedMaxFeePerGas"])
+            max_priority_fee_per_gas = Decimal(resp_json[priority.value]["suggestedMaxPriorityFeePerGas"])
+            base_fee = Decimal(resp_json[priority.value]["estimatedBaseFee"])
+            self.__logger_params(
+                max_fee_per_gas=max_fee_per_gas,
+                max_priority_fee_per_gas=max_priority_fee_per_gas,
+                gas_price_provider=gas_provider,
+            )
+            if max_fee_per_gas > gas_upper_bound:
+                raise OutOfRangeTransactionFee(
+                    f"gas price exceeded. {gas_upper_bound=} but it is {max_fee_per_gas}"
+                )
+            gas_params = {
+                'baseFee': Web3.to_wei(base_fee, "GWei"),
+                "maxFeePerGas": Web3.to_wei(max_fee_per_gas, "GWei"),
+                "maxPriorityFeePerGas": Web3.to_wei(max_priority_fee_per_gas, "GWei"),
+            }
+            return gas_params
+        except (RequestException, JSONDecodeError, KeyError) as e:
+            if not DevEnv:
+                GasEstimationLogger.exception(f'Failed to get gas info from api({self.chain_id=}) {resp.status_code=}')
+            raise FailedToGetGasPrice(f"Failed to get gas info from api({self.chain_id=}): {e}")
+
+    async def _get_gas_from_rpc(self, priority: TxPriority, gas_upper_bound: Union[float, Decimal]) -> Dict[str, Wei]:
+        gas_price = None
+        found_gas_below_upper_bound = False
+
+        for provider in self.providers:  # type: AsyncWeb3
+            rpc_url = provider.provider.endpoint_uri
+            try:
+                gas_price = await provider.eth.gas_price
+                self.__logger_params(gas_price=str(gas_price / 1e9), gas_price_provider=rpc_url)
+                if gas_price / 1e9 <= gas_upper_bound:
+                    found_gas_below_upper_bound = True
+                    break
+            except (ConnectionError, ReadTimeout, ValueError, ConnectionResetError) as e:
+                GasEstimationLogger.error(f"Failed to get gas price from {rpc_url}, {e=}")
+            except ClientResponseError as e:
+                if e.message.startswith("Too Many Requests"):
+                    GasEstimationLogger.error(f"Failed to get gas price from {rpc_url}, {e=}")
+                raise
+
+        if gas_price is None:
+            raise FailedToGetGasPrice("Non of RCP could provide gas price!")
+        if not found_gas_below_upper_bound:
+            raise OutOfRangeTransactionFee(
+                f"gas price exceeded. {gas_upper_bound=} but it is {gas_price / 1e9}"
+            )
+        return {'gasPrice': Wei(int(gas_price * self.multipliers.get(priority, 1)))}
+
+    async def _get_fixed_value(self, priority: TxPriority, gas_upper_bound: Union[float, Decimal]) -> Dict[str, Wei]:
+        gas = ChainIdToGas.get(self.chain_id) or FixedValueGas
+        if gas > gas_upper_bound:
+            raise OutOfRangeTransactionFee(f"gas price exceeded. {gas_upper_bound=} but it is {gas}")
+        return {"gasPrice": Web3.to_wei(gas * self.multipliers.get(priority, 1), "GWei")}
+
+    async def _custom_gas_estimation(self, priority: TxPriority, gas_upper_bound: Union[float, Decimal]):
+        raise NotImplemented()
+
+    async def get_gas_price(
+            self, gas_upper_bound: int, priority: TxPriority, method: GasEstimationMethod = None
+    ) -> Dict[str, Wei]:
+        if method := self.gas_estimation_method.get(method) or self.gas_estimation_method.get(self.default_method):
+            try:
+                return await method(priority, gas_upper_bound)
+            except FailedToGetGasPrice as e:
+                raise e
+        gas_params = {}
+
+        if DevEnv or self.chain_id in GasFromRpcChainIds:
+            return await self._get_gas_from_rpc(priority, gas_upper_bound)
+        for method_key in self.method_sorted_priority:
+            try:
+                gas_params = await self.gas_estimation_method[method_key](priority, gas_upper_bound)
+                break
+            except (FailedToGetGasPrice, OutOfRangeTransactionFee) as e:
+                GasEstimationLogger.warning(f"This method({method_key}) failed to provide gas with this error: {e}")
+                continue
+        if not gas_params:
+            raise FailedToGetGasPrice("All of methods failed to estimate gas")
+        return gas_params

src/multirpc/sync_multi_rpc_interface.py

@@ -0,0 +1,135 @@
+import asyncio
+import logging
+from typing import Dict, List, Optional, Union
+
+from eth_typing import Address, ChecksumAddress
+from web3._utils.contracts import encode_transaction_data  # noqa
+from web3.types import BlockData, BlockIdentifier, TxReceipt
+
+from . import BaseMultiRpc
+from .base_multi_rpc_interface import BaseContractFunction
+from .constants import GasLimit, GasUpperBound, ViewPolicy
+from .exceptions import DontHaveThisRpcType, KwargsNotSupportedInMultiCall, TransactionTypeNotSupportedInMultiCall
+from .gas_estimation import GasEstimation, GasEstimationMethod
+from .utils import ContractFunctionType, NestedDict, TxPriority, thread_safe
+
+
+class MultiRpc(BaseMultiRpc):
+    """
+    This class is used to be more sure when running web3 view calls and sending transactions by using of multiple RPCs.
+    """
+
+    @thread_safe
+    def __init__(
+            self,
+            rpc_urls: NestedDict,
+            contract_address: Union[Address, ChecksumAddress, str],
+            contract_abi: Dict,
+            rpcs_supporting_tx_trace: Optional[List[str]] = None,
+            view_policy: ViewPolicy = ViewPolicy.MostUpdated,
+            gas_estimation: Optional[GasEstimation] = None,
+            gas_limit: int = GasLimit,
+            gas_upper_bound: int = GasUpperBound,
+            apm=None,
+            enable_estimate_gas_limit: bool = False,
+            is_proof_authority: bool = False,
+            multicall_custom_address: str = None,
+            log_level: logging = logging.WARN,
+            setup_on_init: bool = True
+    ):
+        super().__init__(rpc_urls, contract_address, contract_abi, rpcs_supporting_tx_trace,
+                         view_policy, gas_estimation, gas_limit,
+                         gas_upper_bound, apm, enable_estimate_gas_limit,
+                         is_proof_authority, multicall_custom_address, log_level)
+
+        for func_abi in self.contract_abi:
+            if func_abi.get("stateMutability") in ("view", "pure"):
+                function_type = ContractFunctionType.View
+            elif func_abi.get("type") == "function":
+                function_type = ContractFunctionType.Transaction
+            else:
+                continue
+            self.functions.__setattr__(
+                func_abi["name"],
+                self.ContractFunction(func_abi["name"], func_abi, self, function_type),
+            )
+        if setup_on_init:
+            self.setup()
+
+    @thread_safe
+    def setup(self) -> None:
+        return asyncio.run(super().setup())
+
+    @thread_safe
+    def get_nonce(self, address: Union[Address, ChecksumAddress, str]) -> int:
+        return asyncio.run(super()._get_nonce(address))
+
+    @thread_safe
+    def get_tx_receipt(self, tx_hash) -> TxReceipt:
+        return asyncio.run(super().get_tx_receipt(tx_hash))
+
+    @thread_safe
+    def get_block(self, block_identifier: BlockIdentifier = 'latest', full_transactions: bool = False) -> BlockData:
+        return asyncio.run(super().get_block(block_identifier, full_transactions))
+
+    @thread_safe
+    def get_block_number(self) -> int:
+        return asyncio.run((super().get_block_number()))
+
+    class ContractFunction(BaseContractFunction):
+        def __call__(self, *args, **kwargs):
+            cf = MultiRpc.ContractFunction(self.name, self.abi, self.mr, self.typ)
+            cf.args = args
+            cf.kwargs = kwargs
+            return cf
+
+        @thread_safe
+        def call(
+                self,
+                address: str = None,
+                private_key: str = None,
+                gas_limit: int = None,
+                gas_upper_bound: int = None,
+                wait_for_receipt: int = 90,
+                priority: TxPriority = TxPriority.Low,
+                gas_estimation_method: GasEstimationMethod = None,
+                block_identifier: Union[str, int] = 'latest',
+                enable_estimate_gas_limit: Optional[bool] = None,
+                use_multicall=False,
+        ):
+            if self.mr.providers.get(self.typ) is None:
+                raise DontHaveThisRpcType(f"Doesn't have {self.typ} RPCs")
+            if self.typ == ContractFunctionType.View:
+                return asyncio.run(self.mr._call_view_function(
+                    self.name, block_identifier, use_multicall, *self.args, **self.kwargs,
+                ))
+            elif self.typ == ContractFunctionType.Transaction:
+                return asyncio.run(self.mr._call_tx_function(
+                    func_name=self.name,
+                    func_args=self.args,
+                    func_kwargs=self.kwargs,
+                    address=address or self.mr.address,
+                    private_key=private_key or self.mr.private_key,
+                    gas_limit=gas_limit or self.mr.gas_limit,
+                    gas_upper_bound=gas_upper_bound or self.mr.gas_upper_bound,
+                    wait_for_receipt=wait_for_receipt,
+                    priority=priority,
+                    gas_estimation_method=gas_estimation_method,
+                    enable_estimate_gas_limit=enable_estimate_gas_limit
+                ))
+
+        @thread_safe
+        def multicall(
+                self,
+                block_identifier: Union[str, int] = 'latest',
+        ):
+            if self.mr.providers.get(self.typ) is None:
+                raise DontHaveThisRpcType(f"Doesn't have {self.typ} RPCs")
+            if self.kwargs != {}:
+                raise KwargsNotSupportedInMultiCall
+            if self.typ == ContractFunctionType.View:
+                return asyncio.run(self.mr._call_view_function(
+                    self.name, block_identifier, True, *self.args, **self.kwargs,
+                ))
+            elif self.typ == ContractFunctionType.Transaction:
+                raise TransactionTypeNotSupportedInMultiCall

src/multirpc/tx_trace.py

@@ -0,0 +1,153 @@
+import requests
+
+from src.multirpc.constants import MultiRPCLogger
+
+
+class TxTrace:
+    """
+    geth trace transaction sample output :
+
+    {
+      "jsonrpc": "2.0",
+      "id": 1,
+      "result": {
+        "from": "0x15d34aaf54267db7d7c367839aaf71a00a2c6a65",
+        "gas": "0x989680",
+        "gasUsed": "0xca4b",
+        "to": "0x9fe46736679d2d9a65f0992f2272de9f3c7fa6e0",
+        "input": "0x3f65c7f4000000000000000000000000ba55e57bb198a641135e9dc9e96ebff834cab11000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006590012200000000000000000000000000000000000000000000000000000000000001a0ffffffffffffffffffffffffffffffffffffffffffffffffe440925e7ed57800ffffffffffffffffffffffffffffffffffffffffffffffffe440925e7ed5780000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000220891d24df965ef1367f4c8d974f394b0a43f7be3a2767ba887cef8dd2adfd89c000000000000000000000000090f79bf6eb2c4f870365e785982e1f101e93b906000000000000000000000000392118fc9f5acf2b2b9e509804bb7e68253635b80000000000000000000000000000000000000000000000000000000000000020ad0a18a3d1d4340dcc24a08636a2782e2edf6d8e5434939763ebf402b166d7e40000000000000000000000000000000000000000000000000000000000000020b01bc3cb7585f01e38c0af92705ce6799b89ab1cd49955757b4094468941f8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000417de46c7e53aa9365ab17de1e6f3efedd87d67fd77b341d3f4bd5919cd19805ae2a28c3b17771caf6e661db72e6f684cc6caba3e40e1436d591e98e0f1e73ec2b1b00000000000000000000000000000000000000000000000000000000000000",
+        "output": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000234c69717569646174696f6e46616365743a2050617274794120697320736f6c76656e740000000000000000000000000000000000000000000000000000000000",
+        "error": "execution reverted",
+        "revertReason": "LiquidationFacet: PartyA is solvent",
+        "calls": [
+          {
+            "from": "0x9fe46736679d2d9a65f0992f2272de9f3c7fa6e0",
+            "gas": "0x95b6b0",
+            "gasUsed": "0x4aa7",
+            "to": "0xa513e6e4b8f2a923d98304ec87f64353c4d5c853",
+            "input": "0x3f65c7f4000000000000000000000000ba55e57bb198a641135e9dc9e96ebff834cab11000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006590012200000000000000000000000000000000000000000000000000000000000001a0ffffffffffffffffffffffffffffffffffffffffffffffffe440925e7ed57800ffffffffffffffffffffffffffffffffffffffffffffffffe440925e7ed5780000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000220891d24df965ef1367f4c8d974f394b0a43f7be3a2767ba887cef8dd2adfd89c000000000000000000000000090f79bf6eb2c4f870365e785982e1f101e93b906000000000000000000000000392118fc9f5acf2b2b9e509804bb7e68253635b80000000000000000000000000000000000000000000000000000000000000020ad0a18a3d1d4340dcc24a08636a2782e2edf6d8e5434939763ebf402b166d7e40000000000000000000000000000000000000000000000000000000000000020b01bc3cb7585f01e38c0af92705ce6799b89ab1cd49955757b4094468941f8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000417de46c7e53aa9365ab17de1e6f3efedd87d67fd77b341d3f4bd5919cd19805ae2a28c3b17771caf6e661db72e6f684cc6caba3e40e1436d591e98e0f1e73ec2b1b00000000000000000000000000000000000000000000000000000000000000",
+            "output": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000234c69717569646174696f6e46616365743a2050617274794120697320736f6c76656e740000000000000000000000000000000000000000000000000000000000",
+            "error": "execution reverted",
+            "revertReason": "LiquidationFacet: PartyA is solvent",
+            "value": "0x0",
+            "type": "DELEGATECALL"
+          }
+        ],
+        "value": "0x0",
+        "type": "CALL"
+      }
+    }
+    """
+
+    def __init__(self, tx_hash, rpc: str):
+        self.tx_hash = tx_hash
+        self.rpc = rpc
+        self.response = self.tx_trace()
+        self._json = None
+
+    def __repr__(self):
+        return f'{self.tx_hash}-{self.response and self.response.text}'
+
+    def __str__(self):
+        return f'{self.tx_hash}-{self.response and self.response.text}'
+
+    def tx_trace(self):
+        try:
+            data = {
+                "id": 1,
+                "jsonrpc": "2.0",
+                "method": "debug_traceTransaction",
+                "params": [
+                    self.tx_hash,
+                    {"tracer": 'callTracer', "disableStack": False, "disableStorage": True}
+                ]
+            }
+
+            response = requests.post(self.rpc, json=data)
+            if response.status_code == 200:
+                if error := response.json().get('error'):
+                    MultiRPCLogger.error(f'failed to get tx({self.tx_hash}) trace with error: {error}')
+                    return None
+                return response
+            MultiRPCLogger.error(f'tx_trace({self.tx_hash}) status = {response.status_code}, \n {response.json()}')
+
+        except requests.HTTPError:
+            MultiRPCLogger.exception('Exception in debug_traceTransaction')
+
+    def ok(self):
+        return bool(self.response)
+
+    def text(self):
+        if self.ok():
+            return self.response.text
+        return ''
+
+    def json(self) -> dict:
+        if self._json:
+            return self._json
+        if self.ok():
+            self._json = self.response.json()
+        else:
+            self._json = {}
+        return self._json
+
+    def result(self):
+        return TxTraceResult(result=self.json().get('result') or {})
+
+
+class TxTraceResult:
+
+    def __init__(self, result):
+        self._json = result
+
+    def __repr__(self):
+        return f'{self._json}'
+
+    def get(self, key, default=None):
+        return self._json.get(key, default)
+
+    def error(self):
+        return self.get('error')
+
+    def revert_reason(self):
+        return self.get('revertReason', '')
+
+    def from_(self):
+        return self.get('from')
+
+    def to(self):
+        return self.get('to')
+
+    def gas_used(self):
+        return self.get('gasUsed')
+
+    def calls(self) -> list['TxTraceResult']:
+        return [TxTraceResult(result=call) for call in self.get('calls', [])]
+
+    def all_revert_reasons(self) -> list:
+        revert_reasons = []
+
+        if current_reason := self.get('revertReason'):
+            revert_reasons.append(current_reason)
+
+        if calls := self.calls():
+            for child_call in calls:
+                revert_reasons += child_call.all_revert_reasons()
+
+        return revert_reasons
+
+    def short_error(self):
+        return f'error={self.error()} revertReason={self.revert_reason()}'
+
+    def long_error(self):
+        revert_reasons = self.all_revert_reasons()
+        return f'error={self.error()} revert-reasons={revert_reasons}'
+
+    def first_usable_error(self):
+        for error in [self.error()] + self.all_revert_reasons():
+            if error and \
+                    'execution reverted' not in error and \
+                    'MultiAccount: Error occurred' not in error and \
+                    'Execution reverted' not in error:
+                return error
+        return ''