solver-multirpc 3.1.4__py3-none-any.whl

src/multirpc/utils.py

@@ -0,0 +1,265 @@
+import asyncio
+import enum
+import json
+import time
+import traceback
+from dataclasses import dataclass
+from functools import reduce, wraps
+from threading import Thread
+from typing import Any, Dict, List, Tuple, Union
+
+import aiohttp.client_exceptions
+from aiohttp import ClientTimeout
+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
+
+from .constants import MaxRPCInEachBracket, MultiRPCLogger
+from .exceptions import AtLastProvideOneValidRPCInEachBracket, MaximumRPCInEachBracketReached
+
+
+def get_span_proper_label_from_provider(endpoint_uri):
+    return endpoint_uri.split("//")[-1].replace(".", "__").replace("/", "__")
+
+
+class ReturnableThread(Thread):
+    def __init__(self, target, args=(), kwargs=None):
+        super().__init__(target=target, args=args, kwargs=kwargs)
+        self.target = target
+        self.args = args
+        self.kwargs = kwargs if kwargs is not None else {}
+        self.result = None
+        self._exception = None
+
+    def run(self) -> None:
+        try:
+            self.result = self.target(*self.args, **self.kwargs)
+        except Exception as e:
+            self._exception = e
+            traceback.print_exc()
+
+    def join(self, *args, **kwargs):
+        super().join(*args, **kwargs)
+        if self._exception:
+            raise self._exception
+        return self.result
+
+
+def thread_safe(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        event_loop = asyncio._get_running_loop()
+        if event_loop is None:
+            return func(*args, **kwargs)
+        t = ReturnableThread(target=func, args=args, kwargs=kwargs)
+        t.start()
+        return t.join()
+
+    return wrapper
+
+
+class ResultEvent(asyncio.Event):
+    def __init__(self):
+        super().__init__()
+        self.result_ = None
+
+    def set_result(self, result):
+        self.result_ = result
+
+    def get_result(self):
+        return self.result_
+
+
+def get_unix_time():
+    return int(time.time() * 1000)
+
+
+class TxPriority(enum.Enum):
+    Low = "low"
+    Medium = "medium"
+    High = "high"
+
+
+class ContractFunctionType:
+    View = "view"
+    Transaction = "transaction"
+
+
+class NestedDict:
+    def __init__(self, data: Dict = None):
+        if data is None:
+            data = dict()
+        self.data = data
+
+    def __getitem__(self, keys: Union[Tuple[any], any]):
+        if not isinstance(keys, tuple):
+            keys = (keys,)
+        result = self.data
+        for key in keys:
+            result = result[key]
+        return result
+
+    def __setitem__(self, keys: Union[Tuple[any], any], value) -> None:
+        if not isinstance(keys, tuple):
+            keys = (keys,)
+        current_dict = self.data
+        for key in keys[:-1]:
+            if not isinstance(current_dict.get(key), dict):
+                current_dict[key] = {}
+            current_dict = current_dict[key]
+        current_dict[keys[-1]] = value
+
+    def get(self, keys, default=None):
+        if not isinstance(keys, tuple):
+            keys = (keys,)
+        current_dict = self.data
+        for key in keys:
+            try:
+                current_dict = current_dict[key]
+            except KeyError:
+                return default
+        return current_dict
+
+    def items(self):
+        def get_items_recursive(data, current_keys=()):
+            for key, value in data.items():
+                if isinstance(value, dict):
+                    yield from get_items_recursive(value, current_keys + (key,))
+                else:
+                    yield current_keys + (key,), value
+
+        return get_items_recursive(self.data)
+
+    def __str__(self):
+        return str(self.data)
+
+    def __repr__(self):
+        return json.dumps(self.data, indent=1)
+
+
+class MultiRpcHTTPSessionManager(HTTPSessionManager):
+    """
+     This class extends the default HTTPSessionManager used by Web3 to ensure that
+     the aiohttp ClientSession is always closed—even in the case of a failure or
+     cancellation. By placing session closure inside a 'finally' block in both
+     'async_make_post_request' and 'async_json_make_get_request', we guarantee
+     proper cleanup of network connections and resources, preventing potential
+     resource leaks or connection pooling issues if an exception is raised during
+     the request or the task is cancelled.
+
+     NOTE: It's based on web3==7.7.0 . If you update web3 check if it's compatible.
+     """
+
+    async def async_make_post_request(
+            self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
+    ) -> bytes:
+        kwargs.setdefault("timeout", ClientTimeout(DEFAULT_HTTP_TIMEOUT))
+        session = await self.async_cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+
+        try:
+            self.logger.debug(f'making post request, {endpoint_uri=}, {kwargs=}')
+            response = await session.post(endpoint_uri, **dict(**kwargs, data=data))
+            response.raise_for_status()
+            return await response.read()
+        finally:
+            self.logger.debug(f'task is done/canceled, session will close, {session=}')
+            if not session.closed:
+                await session.close()
+
+    async def async_json_make_get_request(
+            self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        kwargs.setdefault("timeout", ClientTimeout(DEFAULT_HTTP_TIMEOUT))
+        session = await self.async_cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+        try:
+            response = await session.get(endpoint_uri, *args, **kwargs)
+            response.raise_for_status()
+            return await response.json()
+        finally:
+            self.logger.debug(f'task is done/canceled, {session=}')
+            if not session.closed:
+                await session.close()
+
+
+class MultiRpcAsyncHTTPProvider(AsyncHTTPProvider):
+    """
+    NOTE: It's based on web3==7.7.0 . If you update web3 check if it's compatible.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._request_session_manager = MultiRpcHTTPSessionManager()
+
+
+async def create_web3_from_rpc(rpc_urls: NestedDict, is_proof_of_authority: bool) -> NestedDict:
+    async def create_web3(rpc_: str):
+        async_w3: AsyncWeb3
+        if rpc_.startswith("http"):
+            async_w3 = AsyncWeb3(MultiRpcAsyncHTTPProvider(rpc_))
+        else:
+            async_w3 = AsyncWeb3(WebSocketProvider(rpc_))
+        if is_proof_of_authority:
+            async_w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+        try:
+            status = await async_w3.is_connected()
+        except (asyncio.exceptions.TimeoutError, aiohttp.client_exceptions.ClientResponseError):
+            status = False
+        return async_w3, status
+
+    providers = NestedDict()
+    for key, rpcs in rpc_urls.items():
+        valid_rpcs = []
+
+        if len(rpcs) > MaxRPCInEachBracket:
+            raise MaximumRPCInEachBracketReached
+
+        for i, rpc in enumerate(rpcs):
+            w3, w3_connected = await create_web3(rpc)
+            if not w3_connected:
+                MultiRPCLogger.warning(f"This rpc({rpc}) doesn't work")
+                continue
+            valid_rpcs.append(w3)
+
+        if len(valid_rpcs) == 0:
+            raise AtLastProvideOneValidRPCInEachBracket
+
+        providers[key] = valid_rpcs
+
+    return providers
+
+
+async def calculate_chain_id(providers: NestedDict) -> int:
+    last_error = None
+    for key, providers in providers.items():
+        for provider in providers:
+            try:
+                return await asyncio.wait_for(provider.eth.chain_id, timeout=2)
+            except asyncio.TimeoutError as e:
+                last_error = e
+                MultiRPCLogger.warning(f"Can't acquire chain id from this RPC {provider.provider.endpoint_uri}")
+    raise last_error
+
+
+def reduce_list_of_list(ls: List[List]) -> List[any]:
+    return reduce(lambda ps, p: ps + p, ls)
+
+
+@dataclass
+class ChainConfigTest:
+    name: str
+    contract_address: str
+    rpc: NestedDict
+    tx_hash: str
+    is_proof_authority: bool = False
+    multicall_address: str = None
+
+    def __post_init__(self):
+        self.contract_address = Web3.to_checksum_address(self.contract_address)
+        if self.multicall_address:
+            self.multicall_address = Web3.to_checksum_address(self.multicall_address)

src/tests/abi.json

@@ -0,0 +1,34 @@
+[
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "set",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			}
+		],
+		"name": "map",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]

src/tests/constants.py

@@ -0,0 +1,78 @@
+import json
+
+from src.multirpc.utils import ChainConfigTest, NestedDict
+
+# Arbitrum Configuration
+ArbConfig = ChainConfigTest(
+    'Arbitrum',
+    '0xCFE3c06Fe982A7D16ce3826C64c5f0730054Dc95',
+    NestedDict({
+        "view": {
+            1: ['https://1rpc.io/arb', 'https://rpc.ankr.com/arbitrum', 'https://arbitrum.drpc.org'],
+        },
+        "transaction": {
+            1: ['https://1rpc.io/arb', 'https://rpc.ankr.com/arbitrum', 'https://arbitrum.drpc.org'],
+        }
+    }),
+    '0xbc0f34536fdf5d2593081b112d49d714993d879032e0e9c6998afc3110b7f0ed'
+)
+
+# Polygon Configuration
+PolyConfig = ChainConfigTest(
+    'Polygon',
+    '0xCa7DFDc4dB0F27484Cf5EEa1CdF380301Ef07Ce2',
+    NestedDict({
+        "view": {
+            1: ['https://1rpc.io/matic', 'https://polygon-rpc.com'],
+        },
+        "transaction": {
+            1: ['https://1rpc.io/matic', 'https://polygon-rpc.com'],
+        }
+    }),
+    '0x4b8756bd1d32f62b2b9e3b46b80917bd3de4fd95695bad33e483293284f28678',
+    is_proof_authority=True
+)
+
+# Base Configuration
+BaseConfig = ChainConfigTest(
+    'Base',
+    '0x1d58e7F58d085c87E34b18DAe5A6D08d187cbcbe',
+    NestedDict({
+        "view": {
+            1: ['https://base-rpc.publicnode.com', 'https://base.drpc.org'],
+        },
+        "transaction": {
+            1: ['https://base-rpc.publicnode.com', 'https://base.drpc.org'],
+        }
+    }),
+    '0xbd342d36d503af057cd79fd4f252b4629d6013d0748a2742dc99c9fcbe522072',
+    is_proof_authority=True
+)
+
+# Mantle Configuration
+MantleConfig = ChainConfigTest(
+    'Mantle',
+    '0x535D41D93cDc0818Ad8Eeb452B74e502A5742874',
+    NestedDict({
+        "view": {
+            1: ['https://1rpc.io/mantle', 'https://mantle.drpc.org'],
+        },
+        "transaction": {
+            1: ['https://1rpc.io/mantle', 'https://mantle.drpc.org'],
+        }
+    }),
+    '0x9f33a56be9983753abebbe8fb048601a141097289d96b9844afb36e68f72ef82',
+    is_proof_authority=False,
+)
+
+RPCsSupportingTxTrace = [
+    'https://arbitrum.drpc.org',  # Arbitrum
+    'https://polygon-rpc.com',  # Polygon
+    'https://base.drpc.org',  # Base
+    'https://mantle.drpc.org'  # Mantle
+]
+
+with open("tests/abi.json", "r") as f:
+    abi = json.load(f)
+
+PreviousBlock = 3

src/tests/contract.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.9;
+
+contract Mapping {
+    mapping(address => uint256) public map;
+
+    function set(uint256 value) public {
+        // Revert if the input is exactly one byte of 0x00
+        require(
+            value >= 10,
+            "Error: 10 < value is not allowed."
+        );
+
+        map[msg.sender] = value;
+    }
+}

src/tests/test.py

@@ -0,0 +1,138 @@
+import asyncio
+import logging
+import random
+
+from eth_account import Account
+from web3.exceptions import MismatchedABI
+
+from src.multirpc.async_multi_rpc_interface import AsyncMultiRpc
+from src.multirpc.constants import GasEstimationMethod, ViewPolicy
+from src.multirpc.sync_multi_rpc_interface import MultiRpc
+from src.multirpc.utils import ChainConfigTest
+from src.tests.constants import ArbConfig, BaseConfig, PolyConfig, RPCsSupportingTxTrace, abi
+from src.tests.test_settings import LogLevel, PrivateKey1, PrivateKey2
+
+PreviousBlock = 3
+
+
+async def async_test_map(mr: AsyncMultiRpc, addr: str = None, pk: str = None):
+    random_int = random.randint(10, 100)
+    print(f"Random int: {random_int}")
+    # await mr.functions.set(random_int).call(address=addr, private_key=pk,
+    #                                         gas_estimation_method=GasEstimationMethod.GAS_API_PROVIDER)
+    # await mr.functions.set(random_int).call(address=addr, private_key=pk,
+    #                                         gas_estimation_method=GasEstimationMethod.FIXED)
+
+    # for failure purpose
+    try:
+        await mr.functions.set(random_int, random_int).call(address=addr, private_key=pk,
+                                                            gas_estimation_method=GasEstimationMethod.RPC)
+    except MismatchedABI:
+        pass
+
+    type(random_int)
+
+    try:
+        await mr.functions.set(random.randint(1, 9)
+                               ).call(address=addr, private_key=pk,
+                                      gas_estimation_method=GasEstimationMethod.RPC,
+                                      enable_estimate_gas_limit=False
+                                      )
+    except Exception as e:
+        print(e)
+
+    print(f'encoded function: {mr.functions.set(random_int).get_encoded_data()}')
+    tx_receipt = await mr.functions.set(random_int).call(address=addr, private_key=pk,
+                                                         gas_estimation_method=GasEstimationMethod.RPC)
+
+    print(f"{tx_receipt=}")
+    result = await mr.functions.map(addr).call()
+    print(f"map(addr: {addr}): {result}")
+    assert random_int == result, "test was not successful"
+
+
+async def async_main(chain_config: ChainConfigTest):
+    multi_rpc = AsyncMultiRpc(chain_config.rpc, chain_config.contract_address,
+                              rpcs_supporting_tx_trace=RPCsSupportingTxTrace,
+                              view_policy=ViewPolicy.MostUpdated,
+                              contract_abi=abi, gas_estimation=None, log_level=LogLevel,
+                              is_proof_authority=config_.is_proof_authority,
+                              multicall_custom_address=chain_config.multicall_address, enable_estimate_gas_limit=True)
+    multi_rpc.set_account(address1, private_key=PrivateKey1)
+
+    p_block = await multi_rpc.get_block_number() - PreviousBlock
+    print(f"tx_receipt: {await multi_rpc.get_tx_receipt(chain_config.tx_hash)}")
+    print(f"block: {await multi_rpc.get_block(p_block - 1000)}")
+    print(f"Nonce: {await multi_rpc.get_nonce(address1)}")
+    print(f"map({address1}): {await multi_rpc.functions.map(address1).call()}")
+
+    results = await multi_rpc.functions.map([(address1,), (address2,)] * 100).multicall()
+    print(f"map({address1, address2}): {[res for res in results]}")
+    print(f"map({address1}) in {p_block=}: "
+          f"{await multi_rpc.functions.map(address1).call(block_identifier=p_block)}")
+
+    await async_test_map(multi_rpc, address1)
+    # await async_test_map(multi_rpc, address2, PrivateKey2)
+
+
+def sync_test_map(mr: MultiRpc, addr: str = None, pk: str = None):
+    random_int = random.randint(10, 100)
+    print(f"Random int: {random_int}")
+    print(f'encoded function: {mr.functions.set(random_int).get_encoded_data()}')
+    mr.functions.set(random_int).call(address=addr, private_key=pk)
+
+    result = mr.functions.map(addr).call()
+    print(f"map(addr: {addr}): {result}")
+    assert random_int == result, "test was not successful"
+
+
+def sync_main(chain_config: ChainConfigTest):
+    multi_rpc = MultiRpc(chain_config.rpc, chain_config.contract_address, contract_abi=abi,
+                         rpcs_supporting_tx_trace=RPCsSupportingTxTrace,
+                         gas_estimation=None,
+                         enable_estimate_gas_limit=True, log_level=LogLevel,
+                         is_proof_authority=config_.is_proof_authority,
+                         multicall_custom_address=chain_config.multicall_address)
+    multi_rpc.set_account(address1, private_key=PrivateKey1)
+
+    p_block = multi_rpc.get_block_number() - PreviousBlock
+    print(f"tx_receipt: {multi_rpc.get_tx_receipt(chain_config.tx_hash)}")
+    print(f"block: {multi_rpc.get_block(p_block - 1000)}")
+    print(f"Nonce: {multi_rpc.get_nonce(address1)}")
+    print(f"map({address1}): {multi_rpc.functions.map(address1).call()}")
+
+    results = multi_rpc.functions.map([(address1,), (address2,)]).multicall()
+    print(f"map({address1, address2}): {[res for res in results]}")
+    print(f"map({address1}) in {p_block=}: "
+          f"{multi_rpc.functions.map(address1).call(block_identifier=p_block)}")
+
+    sync_test_map(multi_rpc, address1)
+    sync_test_map(multi_rpc, address2, PrivateKey2)
+
+
+async def test(chain_config: ChainConfigTest):
+    # try:
+    #     sync_main(chain_config)
+    #     print("###sync test was successful###")
+    # except Exception as e:
+    #     logging.error(e)
+
+    try:
+        await async_main(chain_config)
+        print('###async test was successful###')
+    except Exception as e:
+        logging.error(e)
+
+
+if __name__ == '__main__':
+    address1 = Account.from_key(PrivateKey1).address
+    address2 = Account.from_key(PrivateKey2).address
+    for config_ in [
+        ArbConfig,
+        PolyConfig,
+        BaseConfig,
+        # MantleConfig
+    ]:
+        print(f"=============================== Start Testing on {config_.name} ===============================")
+        asyncio.run(test(config_))
+        print(f"=============================== Test on {config_.name} Completed ===============================\n\n")

src/tests/test_settings.py.example

@@ -0,0 +1,7 @@
+import logging
+
+# private key that have gas for in fantom network
+PrivateKey1 = ""
+PrivateKey2 = ""
+
+LogLevel = logging.INFO