w3.eth.call now accepts no_retry in transaction data. Web3Advanced now checks max filter_block_range and revert_reason_available

Author: simone1999

IceCreamSwapWeb3/EthAdvanced.py

@@ -1,13 +1,16 @@
 from time import sleep
+from typing import Optional
 
 from web3.eth import Eth
 from web3.exceptions import ContractLogicError
-from web3.types import FilterParams, LogReceipt
+from web3.types import FilterParams, LogReceipt, CallOverride, BlockIdentifier, TxParams
+
+from IceCreamSwapWeb3 import Web3Advanced
 
 
 def exponential_retry(func_name: str = None):
     def wrapper(func):
-        def inner(*args, no_retry=False, **kwargs):
+        def inner(*args, no_retry: bool = False, **kwargs):
             if no_retry:
                 return func(*args, **kwargs)
 
@@ -33,9 +36,10 @@ def inner(*args, no_retry=False, **kwargs):
 
 
 class EthAdvanced(Eth):
-    # todo: implement multicall
+    w3: Web3Advanced
+
     METHODS_TO_RETRY = [
-        'fee_history', 'call', 'create_access_list', 'estimate_gas',
+        'fee_history', 'create_access_list', 'estimate_gas',
         'get_transaction', 'get_raw_transaction', 'get_raw_transaction_by_block',
         'send_transaction', 'send_raw_transaction', 'get_block', 'get_balance',
         'get_code', 'get_transaction_count', 'get_transaction_receipt',
@@ -50,23 +54,6 @@ class EthAdvanced(Eth):
         'max_priority_fee', 'mining', 'syncing'
     ]
 
-    FILTER_RANGES_TO_TRY = sorted([
-        10_000,
-        5_000,
-        2_000,
-        1_000,
-        500,
-        200,
-        100,
-        50,
-        20,
-        10,
-        5,
-        2,
-        1
-    ], reverse=True)
-    assert FILTER_RANGES_TO_TRY[-1] == 1
-
     def __init__(self, w3):
         super().__init__(w3=w3)
 
@@ -75,8 +62,6 @@ def __init__(self, w3):
 
         self.chain_id_cached = super()._chain_id()
 
-        self.filter_block_range = self._find_max_filter_range()
-
     def _wrap_methods_with_retry(self):
         for method_name in self.METHODS_TO_RETRY:
             method = getattr(self, method_name)
@@ -87,6 +72,26 @@ def _wrap_methods_with_retry(self):
             wrapped_prop = property(exponential_retry(func_name=prop_name)(prop.fget))
             setattr(self.__class__, prop_name, wrapped_prop)
 
+    def call(
+            self,
+            transaction: TxParams,
+            block_identifier: Optional[BlockIdentifier] = None,
+            state_override: Optional[CallOverride] = None,
+            ccip_read_enabled: Optional[bool] = None,
+            no_retry: bool = None,
+    ):
+        if "no_retry" in transaction:
+            no_retry = transaction["no_retry"]
+            del transaction["no_retry"]
+
+        return exponential_retry(func_name="call")(super().call)(
+            transaction=transaction,
+            block_identifier=block_identifier,
+            state_override=state_override,
+            ccip_read_enabled=ccip_read_enabled,
+            no_retry=no_retry,
+        )
+
     def get_logs(self, filter_params: FilterParams, show_progress_bar=False, p_bar=None) -> list[LogReceipt]:
         # getting the respective block numbers, could be block hashes or strings like "latest"
         from_block = filter_params["fromBlock"]
@@ -108,10 +113,13 @@ def get_logs(self, filter_params: FilterParams, show_progress_bar=False, p_bar=N
             p_bar = tqdm(total=num_blocks)
 
         # if we already know that the filter range is too large, split it
-        if num_blocks > self.filter_block_range:
+        filter_block_range = self.w3.filter_block_range
+        if filter_block_range == 0:
+            raise Exception("RPC does not support eth_getLogs")
+        if num_blocks > filter_block_range:
             results = []
-            for filter_start in range(from_block, to_block + 1, self.filter_block_range):
-                filter_end = min(filter_start + self.filter_block_range - 1, to_block)
+            for filter_start in range(from_block, to_block + 1, filter_block_range):
+                filter_end = min(filter_start + filter_block_range - 1, to_block)
                 partial_filter = filter_params.copy()
                 partial_filter["fromBlock"] = filter_start
                 partial_filter["toBlock"] = filter_end
@@ -150,23 +158,6 @@ def get_logs(self, filter_params: FilterParams, show_progress_bar=False, p_bar=N
             p_bar.update(num_blocks)
         return events
 
-    def _find_max_filter_range(self):
-        current_block = self.block_number
-        for filter_range in self.FILTER_RANGES_TO_TRY:
-            try:
-                # getting logs from the 0 address as it does not emit any logs.
-                # This way we can test the maximum allowed filter range without getting back a ton of logs
-                result = self._get_logs({
-                    "address": "0x0000000000000000000000000000000000000000",
-                    "fromBlock": current_block - 5 - filter_range + 1,
-                    "toBlock": current_block - 5,
-                })
-                assert result == []
-                return filter_range
-            except Exception:
-                pass
-        raise ValueError("Unable to use eth_getLogs")
-
     def _chain_id(self):
         # usually this causes an RPC call and is used in every eth_call. Getting it once in the init and then not again.
         return self.chain_id_cached

IceCreamSwapWeb3/Web3Advanced.py

@@ -1,4 +1,5 @@
 from web3 import Web3
+from web3.exceptions import ContractLogicError
 from web3.main import get_default_modules
 from web3.middleware import geth_poa_middleware
 
@@ -8,14 +9,32 @@
 class Web3Advanced(Web3):
     eth: EthAdvanced
 
+    FILTER_RANGES_TO_TRY = sorted([
+        10_000,
+        5_000,
+        2_000,
+        1_000,
+        500,
+        200,
+        100,
+        50,
+        20,
+        10,
+        5,
+        2,
+        1
+    ], reverse=True)
+    assert FILTER_RANGES_TO_TRY[-1] == 1
+
     def __init__(
             self,
             node_url: str,
             should_retry=True,
     ):
+        self.node_url = node_url
         self.should_retry = should_retry
 
-        provider = self._construct_provider(node_url=node_url)
+        provider = self._construct_provider(node_url=self.node_url)
 
         # use the EthAdvanced class instead of the Eth class for w3.eth
         modules = get_default_modules()
@@ -25,6 +44,11 @@ def __init__(
 
         self.middleware_onion.inject(geth_poa_middleware, layer=0, name="poa")  # required for pos chains
 
+        self.filter_block_range = self._find_max_filter_range()
+        self.revert_reason_available: bool = self._check_revert_reason_available()
+        if not self.revert_reason_available:
+            print(f"RPC {self.node_url} does not return revert reasons")
+
     @staticmethod
     def _construct_provider(node_url):
         assert "://" in node_url
@@ -35,3 +59,38 @@ def _construct_provider(node_url):
             return Web3.WebsocketProvider(node_url)
         else:
             raise ValueError(f"Unknown protocol for RPC URL {node_url}")
+
+    def _find_max_filter_range(self):
+        current_block = self.eth.block_number
+        for filter_range in self.FILTER_RANGES_TO_TRY:
+            try:
+                # getting logs from the 0 address as it does not emit any logs.
+                # This way we can test the maximum allowed filter range without getting back a ton of logs
+                result = self.eth._get_logs({
+                    "address": "0x0000000000000000000000000000000000000000",
+                    "fromBlock": current_block - 5 - filter_range + 1,
+                    "toBlock": current_block - 5,
+                })
+                assert result == []
+                return filter_range
+            except Exception:
+                pass
+        print(f"Can not use eth_getLogs with RPC {self.node_url}")
+        return 0
+
+    def _check_revert_reason_available(self):
+        with open("abi/RevertTester.abi") as f:
+            revert_tester_abi = f.read()
+        with open("bytecode/RevertTester.bytecode") as f:
+            revert_tester_bytecode = f.read()
+        revert_tester_contract = self.eth.contract(abi=revert_tester_abi, bytecode=revert_tester_bytecode)
+        try:
+            self.eth.call({
+                "data": revert_tester_contract.constructor().data_in_transaction
+            }, no_retry=True)
+            # should revert, if not, reverts are useless
+            return False
+        except Exception as e:
+            if not isinstance(e, ContractLogicError):
+                return False
+            return e.message == "execution reverted: abc"

IceCreamSwapWeb3/abi/RevertTester.abi

@@ -0,0 +1,7 @@
+[
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	}
+]

IceCreamSwapWeb3/bytecode/RevertTester.bytecode

@@ -0,0 +1 @@
+6080604052348015600f57600080fd5b5060405162461bcd60e51b815260206004820152600360248201526261626360e81b604482015260640160405180910390fdfe

setup.py

@@ -6,6 +6,7 @@
 
 requirements = [
     'web3',
+    'rlp',
 ]
 
 # Setting up