solver-multirpc 3.1.10__tar.gz → 3.1.12__tar.gz

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solver-multirpc
-Version: 3.1.10
+Version: 3.1.12
 Summary: A robust Python library for interacting with Ethereum smart contracts via multiple RPC endpoints, ensuring reliability, availability, and load distribution with automatic retries on failure.
 License: MIT
 Author: rorschach

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/async_multi_rpc_interface.py

@@ -34,12 +34,13 @@ class AsyncMultiRpc(BaseMultiRpc):
             is_proof_authority: bool = False,
             multicall_custom_address: str = None,
             log_level: logging = logging.WARN,
-            setup_on_init: bool = True
+            setup_on_init: bool = True,
+            is_flash_block_aware: Optional[bool] = None
     ):
         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)
+                         is_proof_authority, multicall_custom_address, log_level, is_flash_block_aware)
 
         for func_abi in self.contract_abi:
             if func_abi.get("stateMutability") in ("view", "pure"):
@@ -55,13 +56,14 @@ class AsyncMultiRpc(BaseMultiRpc):
         if setup_on_init:
             asyncio.run(self.setup())
 
-    async def get_nonce(self, address: Union[Address, ChecksumAddress, str]) -> int:
-        return await super()._get_nonce(address)
+    async def get_nonce(self, address: Union[Address, ChecksumAddress, str],
+                        block_identifier: BlockIdentifier = None) -> int:
+        return await super()._get_nonce(address, block_identifier)
 
     async def get_tx_receipt(self, tx_hash) -> TxReceipt:
         return await super().get_tx_receipt(tx_hash)
 
-    async def get_block(self, block_identifier: BlockIdentifier = 'latest',
+    async def get_block(self, block_identifier: BlockIdentifier = None,
                         full_transactions: bool = False) -> BlockData:
         return await super().get_block(block_identifier, full_transactions)
 
@@ -84,7 +86,7 @@ class AsyncMultiRpc(BaseMultiRpc):
                 wait_for_receipt: int = 90,
                 priority: TxPriority = TxPriority.Low,
                 gas_estimation_method: GasEstimationMethod = None,
-                block_identifier: Union[str, int] = 'latest',
+                block_identifier: Union[str, int] = None,
                 enable_estimate_gas_limit: Optional[bool] = None,
         ):
             if self.mr.providers.get(self.typ) is None:
@@ -110,7 +112,7 @@ class AsyncMultiRpc(BaseMultiRpc):
 
         async def multicall(
                 self,
-                block_identifier: Union[str, int] = 'latest',
+                block_identifier: Union[str, int] = None,
         ):
             if self.mr.providers.get(self.typ) is None:
                 raise DontHaveThisRpcType(f"Doesn't have {self.typ} RPCs")

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/base_multi_rpc_interface.py

@@ -19,12 +19,13 @@ from web3.contract import Contract
 from web3.exceptions import BadResponseFormat, BlockNotFound, TimeExhausted, TransactionNotFound, Web3RPCError
 from web3.types import BlockData, BlockIdentifier, TxReceipt
 
-from .constants import EstimateGasLimitBuffer, GasLimit, GasUpperBound, MultiRPCLogger, ViewPolicy
+from .constants import EstimateGasLimitBuffer, FlashBlockSupportedChains, GasLimit, GasUpperBound, MultiRPCLogger, \
+    ViewPolicy
 from .exceptions import (DontHaveThisRpcType, FailedOnAllRPCs, GetBlockFailed, NotValidViewPolicy,
                          TransactionFailedStatus, TransactionValueError, Web3InterfaceException)
 from .gas_estimation import GasEstimation, GasEstimationMethod
 from .tx_trace import TxTrace
-from .utils import NestedDict, ResultEvent, TxPriority, get_chain_id, create_web3_from_rpc, \
+from .utils import NestedDict, ResultEvent, TxPriority, create_web3_from_rpc, get_chain_id, \
     get_span_proper_label_from_provider, get_unix_time, reduce_list_of_list
 
 T = TypeVar("T")
@@ -49,7 +50,8 @@ class BaseMultiRpc(ABC):
             enable_estimate_gas_limit: bool = False,
             is_proof_authority: bool = False,
             multicall_custom_address: str = None,
-            log_level: logging = logging.WARN
+            log_level: logging = logging.WARN,
+            is_flash_block_aware: Optional[bool] = None
     ):
         """
         Args:
@@ -90,7 +92,7 @@ class BaseMultiRpc(ABC):
         self.address = None
         self.private_key = None
         self.chain_id = None
-
+        self.is_flash_block_aware = is_flash_block_aware
         MultiRPCLogger.setLevel(log_level)
 
     def _logger_params(self, **kwargs) -> None:
@@ -99,6 +101,9 @@ class BaseMultiRpc(ABC):
         else:
             MultiRPCLogger.info(f'params={kwargs}')
 
+    def get_block_identifier(self, block_identifier=None):
+        return block_identifier or ('pending' if self.is_flash_block_aware else 'latest')
+
     def set_account(self, address: Union[ChecksumAddress, str], private_key: str) -> None:
         """
         Set public key and private key for sending transactions. If these values set, there is no need to pass address,
@@ -114,6 +119,11 @@ class BaseMultiRpc(ABC):
         self.providers = await create_web3_from_rpc(self.rpc_urls, self.is_proof_authority)
         self.chain_id = await get_chain_id(self.providers)
 
+        if self.is_flash_block_aware is None:
+            self.is_flash_block_aware = self.chain_id in FlashBlockSupportedChains
+
+        MultiRPCLogger.debug(f"{self.chain_id=}, {self.is_flash_block_aware=}")
+
         if self.gas_estimation is None and self.providers.get('transaction'):
             self.gas_estimation = GasEstimation(
                 self.chain_id,
@@ -196,7 +206,7 @@ class BaseMultiRpc(ABC):
 
     async def _call_view_function(self,
                                   func_name: str,
-                                  block_identifier: Union[str, int] = 'latest',
+                                  block_identifier: Union[str, int] = None,
                                   use_multicall=False,
                                   *args, **kwargs):
         """
@@ -222,6 +232,7 @@ class BaseMultiRpc(ABC):
                 return results[max_index][2]
             return results[max_index][2][0]
 
+        block_identifier = self.get_block_identifier(block_identifier)
         last_error = None
         for contracts, multi_calls in zip(self.contracts['view'].values(),
                                           self.multi_calls['view'].values()):  # type: any, List[AsyncMulticall]
@@ -246,7 +257,8 @@ class BaseMultiRpc(ABC):
         last_error = None
         for providers in providers_4_nonce.values():
             execution_list = [
-                prov.eth.get_transaction_count(address, block_identifier=block_identifier) for prov in providers
+                prov.eth.get_transaction_count(address, block_identifier=self.get_block_identifier(block_identifier))
+                for prov in providers
             ]
             try:
                 return await self.__gather_tasks(execution_list, max)
@@ -295,7 +307,7 @@ class BaseMultiRpc(ABC):
             account: LocalAccount = Account.from_key(signer_private_key)
             if enable_estimate_gas_limit:
                 del tx['gas']
-                estimate_gas = await provider.eth.estimate_gas(tx)
+                estimate_gas = await provider.eth.estimate_gas(tx, block_identifier=self.get_block_identifier())
                 MultiRPCLogger.info(f"gas_estimation({estimate_gas} gas needed) is successful")
                 return account.sign_transaction({**tx, 'gas': int(estimate_gas * EstimateGasLimitBuffer)})
             return account.sign_transaction(tx)
@@ -339,7 +351,7 @@ class BaseMultiRpc(ABC):
             raise
 
     @staticmethod
-    def _handle_tx_trace(trace: TxTrace, func_name: str, func_args: Tuple, func_kwargs: Dict):
+    def _handle_tx_trace(trace: TxTrace, func_name: str, func_args: Tuple, func_kwargs: Dict) -> Exception | None:
         """
         You can override this method to customize handling failed transaction.
 
@@ -379,11 +391,12 @@ class BaseMultiRpc(ABC):
                 tx_err_count += 1
                 timeout *= 2
 
-    @staticmethod
-    async def __get_tx_trace(tx, provider_url, func_name=None, func_args=None, func_kwargs=None):
+    @classmethod
+    async def __get_tx_trace(cls, tx, provider_url, func_name=None, func_args=None, func_kwargs=None):
         tx_hash = Web3.to_hex(tx)
         trace = TxTrace(tx_hash, provider_url)
-        BaseMultiRpc._handle_tx_trace(trace, func_name, func_args, func_kwargs)
+        if exception := cls._handle_tx_trace(trace, func_name, func_args, func_kwargs):
+            return exception
         return TransactionFailedStatus(tx_hash, func_name, func_args, func_kwargs, trace)
 
     @staticmethod
@@ -577,14 +590,15 @@ class BaseMultiRpc(ABC):
                 raise
         raise last_exception
 
-    async def get_block(self, block_identifier: BlockIdentifier = 'latest',
-                        full_transactions: bool = False) -> BlockData:
+    async def get_block(self, block_identifier: BlockIdentifier = None, full_transactions: bool = False) -> BlockData:
         self.check_for_view()
 
         exceptions = (HTTPError, ConnectionError, ReadTimeout, ValueError, TimeExhausted, BlockNotFound)
         last_exception = None
         for provider in self.providers['view'].values():  # type: List[AsyncWeb3]
-            execution_tx_params_list = [p.eth.get_block(block_identifier, full_transactions) for p in provider]
+            execution_tx_params_list = [
+                p.eth.get_block(self.get_block_identifier(block_identifier), full_transactions) for p in provider
+            ]
             try:
                 return await self.__execute_batch_tasks(
                     execution_tx_params_list,

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/constants.py

@@ -36,6 +36,10 @@ ChainIdToGas = {
 GasFromRpcChainIds = []  # for this chain ids use rpc to estimate gas
 FixedValueGas = 30
 
+FlashBlockSupportedChains = [
+    8453    # base
+]
+
 MultiRPCLoggerName = 'Multi-RPC'
 GasEstimationLoggerName = MultiRPCLoggerName + '.Gas-Estimation'
 

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/exceptions.py

@@ -54,6 +54,9 @@ class MaximumRPCInEachBracketReached(Web3InterfaceException):
 class AtLastProvideOneValidRPCInEachBracket(Web3InterfaceException):
     pass
 
+class AllRPCShouldSupportFlashBlockOrNot(Web3InterfaceException):
+    pass
+
 
 class TransactionValueError(Web3InterfaceException):
     pass

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/sync_multi_rpc_interface.py

@@ -34,12 +34,13 @@ class MultiRpc(BaseMultiRpc):
             is_proof_authority: bool = False,
             multicall_custom_address: str = None,
             log_level: logging = logging.WARN,
-            setup_on_init: bool = True
+            setup_on_init: bool = True,
+            is_flash_block_aware: Optional[bool] = None
     ):
         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)
+                         is_proof_authority, multicall_custom_address, log_level, is_flash_block_aware)
 
         for func_abi in self.contract_abi:
             if func_abi.get("stateMutability") in ("view", "pure"):
@@ -60,15 +61,15 @@ class MultiRpc(BaseMultiRpc):
         return asyncio.run(super().setup())
 
     @thread_safe
-    def get_nonce(self, address: Union[Address, ChecksumAddress, str]) -> int:
-        return asyncio.run(super()._get_nonce(address))
+    def get_nonce(self, address: Union[Address, ChecksumAddress, str], block_identifier: BlockIdentifier = None) -> int:
+        return asyncio.run(super()._get_nonce(address, block_identifier))
 
     @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:
+    def get_block(self, block_identifier: BlockIdentifier = None, full_transactions: bool = False) -> BlockData:
         return asyncio.run(super().get_block(block_identifier, full_transactions))
 
     @thread_safe
@@ -92,7 +93,7 @@ class MultiRpc(BaseMultiRpc):
                 wait_for_receipt: int = 90,
                 priority: TxPriority = TxPriority.Low,
                 gas_estimation_method: GasEstimationMethod = None,
-                block_identifier: Union[str, int] = 'latest',
+                block_identifier: Union[str, int] = None,
                 enable_estimate_gas_limit: Optional[bool] = None,
                 use_multicall=False,
         ):
@@ -100,7 +101,7 @@ class MultiRpc(BaseMultiRpc):
                 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,
+                    self.name, block_identifier, use_multicall, *self.args, **self.kwargs
                 ))
             elif self.typ == ContractFunctionType.Transaction:
                 return asyncio.run(self.mr._call_tx_function(
@@ -114,13 +115,13 @@ class MultiRpc(BaseMultiRpc):
                     wait_for_receipt=wait_for_receipt,
                     priority=priority,
                     gas_estimation_method=gas_estimation_method,
-                    enable_estimate_gas_limit=enable_estimate_gas_limit
+                    enable_estimate_gas_limit=enable_estimate_gas_limit,
                 ))
 
         @thread_safe
         def multicall(
                 self,
-                block_identifier: Union[str, int] = 'latest',
+                block_identifier: Union[str, int] = None,
         ):
             if self.mr.providers.get(self.typ) is None:
                 raise DontHaveThisRpcType(f"Doesn't have {self.typ} RPCs")
@@ -128,7 +129,7 @@ class MultiRpc(BaseMultiRpc):
                 raise KwargsNotSupportedInMultiCall
             if self.typ == ContractFunctionType.View:
                 return asyncio.run(self.mr._call_view_function(
-                    self.name, block_identifier, True, *self.args, **self.kwargs,
+                    self.name, block_identifier, True, *self.args, **self.kwargs
                 ))
             elif self.typ == ContractFunctionType.Transaction:
                 raise TransactionTypeNotSupportedInMultiCall

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/multirpc/utils.py

@@ -17,7 +17,8 @@ from web3._utils.http_session_manager import HTTPSessionManager
 from web3.middleware import ExtraDataToPOAMiddleware
 
 from .constants import MaxRPCInEachBracket, MultiRPCLogger
-from .exceptions import AtLastProvideOneValidRPCInEachBracket, MaximumRPCInEachBracketReached
+from .exceptions import AtLastProvideOneValidRPCInEachBracket, \
+    MaximumRPCInEachBracketReached
 
 
 def get_span_proper_label_from_provider(endpoint_uri):

{solver_multirpc-3.1.10 → solver_multirpc-3.1.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solver-multirpc"
-version = "3.1.10"
+version = "3.1.12"
 description = "A robust Python library for interacting with Ethereum smart contracts via multiple RPC endpoints, ensuring reliability, availability, and load distribution with automatic retries on failure."
 authors = ["rorschach <rorschach45001@gmail.com>"]
 license = "MIT"