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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solver-multirpc
-Version: 3.1.7
+Version: 3.1.10
 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.7 → solver_multirpc-3.1.10}/multirpc/base_multi_rpc_interface.py

@@ -16,7 +16,7 @@ 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
@@ -311,7 +311,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 +492,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

{solver_multirpc-3.1.7 → solver_multirpc-3.1.10}/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]})"
 
 

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

@@ -14,7 +14,7 @@ from eth_typing import URI
 from web3 import AsyncHTTPProvider, AsyncWeb3, Web3, WebSocketProvider
 from web3._utils.http import DEFAULT_HTTP_TIMEOUT
 from web3._utils.http_session_manager import HTTPSessionManager
-from web3.middleware import ExtraDataToPOAMiddleware, Web3Middleware
+from web3.middleware import ExtraDataToPOAMiddleware
 
 from .constants import MaxRPCInEachBracket, MultiRPCLogger
 from .exceptions import AtLastProvideOneValidRPCInEachBracket, MaximumRPCInEachBracketReached
@@ -202,58 +202,21 @@ class MultiRpcAsyncHTTPProvider(AsyncHTTPProvider):
         self._request_session_manager = MultiRpcHTTPSessionManager()
 
 
-class SimpleCacheMiddleware(Web3Middleware):
-    rpc_whitelist = {
-        "web3_clientVersion",
-        "net_version",
-        "eth_chainId",
-    }
-
-    def __init__(self, w3):
-        super().__init__(w3)
-        self.cache = {}
-
-    def wrap_make_request(self, make_request):
-        def middleware(method, params: Any):
-            cache_key = (method, tuple(params))
-            if method in self.rpc_whitelist and cache_key in self.cache:
-                return self.cache[cache_key]  # Return cached response
-
-            response = make_request(method, params)  # Make actual RPC request
-
-            if method in self.rpc_whitelist:
-                self.cache[cache_key] = response  # Store response in cache
-
-            return response
-
-        return middleware
-
-    async def async_wrap_make_request(self, make_request):
-        async def middleware(method, params: Any):
-            cache_key = (method, tuple(params))
-            if method in self.rpc_whitelist and cache_key in self.cache:
-                return self.cache[cache_key]  # Return cached response
-
-            response = await make_request(method, params)  # Make actual RPC request
-
-            if method in self.rpc_whitelist:
-                self.cache[cache_key] = response  # Store response in cache
-
-            return response
-
-        return middleware
-
-
 async def create_web3_from_rpc(rpc_urls: NestedDict, is_proof_of_authority: bool) -> NestedDict:
     async def create_web3(rpc_: str):
         async_w3: AsyncWeb3
+        provider_share_configs = dict(
+            cache_allowed_requests=True,
+            cacheable_requests={'eth_chainId',
+                                'web3_clientVersion',
+                                'net_version'},
+        )
         if rpc_.startswith("http"):
-            async_w3 = AsyncWeb3(MultiRpcAsyncHTTPProvider(rpc_))
+            async_w3 = AsyncWeb3(MultiRpcAsyncHTTPProvider(rpc_, **provider_share_configs))
         else:
-            async_w3 = AsyncWeb3(WebSocketProvider(rpc_))
+            async_w3 = AsyncWeb3(WebSocketProvider(rpc_, **provider_share_configs))
         if is_proof_of_authority:
             async_w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-        async_w3.middleware_onion.add(SimpleCacheMiddleware, 'simple_cache')
         try:
             status = await async_w3.is_connected()
         except (asyncio.exceptions.TimeoutError, aiohttp.client_exceptions.ClientResponseError):

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solver-multirpc"
-version = "3.1.7"
+version = "3.1.10"
 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"