solver-multirpc 3.1.8__py3-none-any.whl → 3.1.11__py3-none-any.whl

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")

multirpc/base_multi_rpc_interface.py

@@ -16,15 +16,16 @@ from requests import ConnectionError, HTTPError, ReadTimeout
 from web3 import AsyncWeb3, Web3
 from web3._utils.contracts import encode_transaction_data  # noqa
 from web3.contract import Contract
-from web3.exceptions import BadResponseFormat, BlockNotFound, TimeExhausted, TransactionNotFound
+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)
@@ -311,7 +323,7 @@ class BaseMultiRpc(ABC):
             self._logger_params(**{f"{rpc_label_prefix}_post_send_time": get_unix_time()})
             self._logger_params(tx_send_time=int(time.time() * 1000))
             return provider, transaction
-        except ValueError as e:
+        except (ValueError, Web3RPCError) as e:
             MultiRPCLogger.error(f"RPC({rpc_url}) value error: {str(e)}")
             t_bnb_flag = "transaction would cause overdraft" in str(e).lower() and (await provider.eth.chain_id) == 97
             if not (
@@ -492,7 +504,7 @@ class BaseMultiRpc(ABC):
         ]
         result = await self.__execute_batch_tasks(
             execution_tx_list,
-            [ValueError, ConnectionError, ReadTimeout, HTTPError],
+            [ValueError, ConnectionError, ReadTimeout, HTTPError, Web3RPCError],
             FailedOnAllRPCs
         )
         provider, tx = result
@@ -577,14 +589,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,

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'
 

multirpc/exceptions.py

@@ -5,6 +5,8 @@ BaseException_ = Exception
 
 class Web3InterfaceException(BaseException_):
     def __str__(self):
+        if not self.args:
+            return f"{self.__class__.__name__}()"
         return f"{self.__class__.__name__}({self.args[0]})"
 
 
@@ -52,6 +54,9 @@ class MaximumRPCInEachBracketReached(Web3InterfaceException):
 class AtLastProvideOneValidRPCInEachBracket(Web3InterfaceException):
     pass
 
+class AllRPCShouldSupportFlashBlockOrNot(Web3InterfaceException):
+    pass
+
 
 class TransactionValueError(Web3InterfaceException):
     pass

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

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.8.dist-info → solver_multirpc-3.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solver-multirpc
-Version: 3.1.8
+Version: 3.1.11
 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.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+multirpc/__init__.py,sha256=f7h3txKkb_WQX6u-PzbgMpHt1VGqA0OjhrSe4Vdsk5I,100
+multirpc/async_multi_rpc_interface.py,sha256=NTwdOyMbghekredlYR64kr0eiPRxzvUirGBZpFzRgig,5699
+multirpc/base_multi_rpc_interface.py,sha256=9TPQABrutwe8yHu05Nt5Uv5_jZlMdlu8XyY1PIQoUiU,29238
+multirpc/constants.py,sha256=B21pS85Vnm65vvjt25_9TTxviRHYCUlgpIDGOrs1rmg,1262
+multirpc/exceptions.py,sha256=Tfi4aHeOiH1OaYeNBEDX3fJNAUyPgs42VXrRG62IgJs,1937
+multirpc/gas_estimation.py,sha256=k0FVO9FgSRuRQhEkQ9YZZ-rSpW_zxaLLFdMAYOF3xco,7276
+multirpc/sync_multi_rpc_interface.py,sha256=Zs3FVSGNJDhrFBi3m9sn4pMuYGzLwaiz0qy_R9VIo04,5888
+multirpc/tx_trace.py,sha256=G7sTVMzALtTeC1F2JjxMSGRRFlmAAZG-Sdhd4UQtfw8,7885
+multirpc/utils.py,sha256=bhrP15IY_TOB1dK8HP35rRxs9FIIWKoSUY6EVOA4FEA,9073
+solver_multirpc-3.1.11.dist-info/METADATA,sha256=6AwwApO4kTI_q0SDqCKh4rb9wmi3IBj66oISHIwz2t4,8287
+solver_multirpc-3.1.11.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+solver_multirpc-3.1.11.dist-info/RECORD,,

solver_multirpc-3.1.8.dist-info/RECORD

@@ -1,12 +0,0 @@
-multirpc/__init__.py,sha256=f7h3txKkb_WQX6u-PzbgMpHt1VGqA0OjhrSe4Vdsk5I,100
-multirpc/async_multi_rpc_interface.py,sha256=2YyGXst5jyxZ7ro7z7qeOAF2wKC4JEgbwkR-ADCa-9w,5548
-multirpc/base_multi_rpc_interface.py,sha256=I6WP0e3hcJ1IMVipuWdrZFNjoZBdL4BGZ4eXQVT11oI,28502
-multirpc/constants.py,sha256=h0njFnxTtWU8-NO_3q7sMrLAqQAv4JxM3nZcc2WOqEc,1210
-multirpc/exceptions.py,sha256=V8WDmDWeeTLQ1TOJ9_IWXt0z-qefJiDfQ6pAdhuwdcA,1785
-multirpc/gas_estimation.py,sha256=k0FVO9FgSRuRQhEkQ9YZZ-rSpW_zxaLLFdMAYOF3xco,7276
-multirpc/sync_multi_rpc_interface.py,sha256=T9x5bLbLJF_1XorkkDqzc8pZmbdNs6OE9trGjVWQBdg,5762
-multirpc/tx_trace.py,sha256=G7sTVMzALtTeC1F2JjxMSGRRFlmAAZG-Sdhd4UQtfw8,7885
-multirpc/utils.py,sha256=V0hosPMFqsvZy1OtWUOR-4xk1U4bPmGUfviBivygZJw,9067
-solver_multirpc-3.1.8.dist-info/METADATA,sha256=iqs2MY1Ay79oo1yEnVDcSnB3QYxO9NlOhVdeRoPgGRA,8286
-solver_multirpc-3.1.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-solver_multirpc-3.1.8.dist-info/RECORD,,