web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/providers/eth_tester/main.py

@@ -2,9 +2,12 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Coroutine,
     Dict,
+    Literal,
     Optional,
     Union,
+    cast,
 )
 
 from eth_abi import (
@@ -17,16 +20,6 @@ from eth_utils import (
     is_bytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
-from web3.middleware.attrdict import (
-    async_attrdict_middleware,
-    attrdict_middleware,
-)
-from web3.middleware.buffered_gas_estimate import (
-    async_buffered_gas_estimate_middleware,
-)
 from web3.providers import (
     BaseProvider,
 )
@@ -39,9 +32,14 @@ from web3.types import (
     RPCResponse,
 )
 
+from ...exceptions import (
+    Web3TypeError,
+)
+from ...middleware import (
+    async_combine_middleware,
+    combine_middleware,
+)
 from .middleware import (
-    async_default_transaction_fields_middleware,
-    async_ethereum_tester_middleware,
     default_transaction_fields_middleware,
     ethereum_tester_middleware,
 )
@@ -50,13 +48,22 @@ if TYPE_CHECKING:
     from eth_tester import EthereumTester  # noqa: F401
     from eth_tester.backends.base import BaseChainBackend  # noqa: F401
 
+    from web3 import (  # noqa: F401
+        AsyncWeb3,
+        Web3,
+    )
+    from web3.middleware.base import (  # noqa: F401
+        Middleware,
+        MiddlewareOnion,
+        Web3Middleware,
+    )
+
 
 class AsyncEthereumTesterProvider(AsyncBaseProvider):
-    middlewares = (
-        async_attrdict_middleware,
-        async_buffered_gas_estimate_middleware,
-        async_default_transaction_fields_middleware,
-        async_ethereum_tester_middleware,
+    _current_request_id = 0
+    _middleware = (
+        default_transaction_fields_middleware,
+        ethereum_tester_middleware,
     )
 
     def __init__(self) -> None:
@@ -74,16 +81,43 @@ class AsyncEthereumTesterProvider(AsyncBaseProvider):
         self.ethereum_tester = EthereumTester()
         self.api_endpoints = API_ENDPOINTS
 
+    async def request_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
+    ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
+        # override the request_func to add the ethereum_tester_middleware
+
+        middleware = middleware_onion.as_tuple_of_middleware() + tuple(self._middleware)
+
+        cache_key = self._request_func_cache[0]
+        if cache_key != middleware:
+            self._request_func_cache = (
+                middleware,
+                await async_combine_middleware(
+                    middleware=middleware,
+                    async_w3=async_w3,
+                    provider_request_fn=self.make_request,
+                ),
+            )
+        return self._request_func_cache[-1]
+
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        return _make_request(method, params, self.api_endpoints, self.ethereum_tester)
+        response = _make_request(
+            method,
+            params,
+            self.api_endpoints,
+            self.ethereum_tester,
+            repr(self._current_request_id),
+        )
+        self._current_request_id += 1
+        return response
 
     async def is_connected(self, show_traceback: bool = False) -> Literal[True]:
         return True
 
 
 class EthereumTesterProvider(BaseProvider):
-    middlewares = (
-        attrdict_middleware,
+    _current_request_id = 0
+    _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
     )
@@ -98,6 +132,7 @@ class EthereumTesterProvider(BaseProvider):
         ] = None,
     ) -> None:
         # do not import eth_tester until runtime, it is not a default dependency
+        super().__init__()
         from eth_tester import EthereumTester  # noqa: F811
         from eth_tester.backends.base import (
             BaseChainBackend,
@@ -110,7 +145,7 @@ class EthereumTesterProvider(BaseProvider):
         elif isinstance(ethereum_tester, BaseChainBackend):
             self.ethereum_tester = EthereumTester(ethereum_tester)
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 "Expected ethereum_tester to be of type `eth_tester.EthereumTester` or "
                 "a subclass of `eth_tester.backends.base.BaseChainBackend`, "
                 f"instead received {type(ethereum_tester)}. "
@@ -129,24 +164,52 @@ class EthereumTesterProvider(BaseProvider):
         else:
             self.api_endpoints = api_endpoints
 
+    def request_func(
+        self, w3: "Web3", middleware_onion: "MiddlewareOnion"
+    ) -> Callable[..., RPCResponse]:
+        # override the request_func to add the ethereum_tester_middleware
+
+        middleware = middleware_onion.as_tuple_of_middleware() + tuple(self._middleware)
+
+        cache_key = self._request_func_cache[0]
+        if cache_key != middleware:
+            self._request_func_cache = (
+                middleware,
+                combine_middleware(
+                    middleware=middleware,
+                    w3=w3,
+                    provider_request_fn=self.make_request,
+                ),
+            )
+        return self._request_func_cache[-1]
+
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        return _make_request(method, params, self.api_endpoints, self.ethereum_tester)
+        response = _make_request(
+            method,
+            params,
+            self.api_endpoints,
+            self.ethereum_tester,
+            repr(self._current_request_id),
+        )
+        self._current_request_id += 1
+        return response
 
     def is_connected(self, show_traceback: bool = False) -> Literal[True]:
         return True
 
 
-def _make_response(result: Any, message: str = "") -> RPCResponse:
+def _make_response(result: Any, response_id: str, message: str = "") -> RPCResponse:
     if isinstance(result, Exception):
-        return RPCResponse(
+        return cast(
+            RPCResponse,
             {
-                "id": 1,
+                "id": response_id,
                 "jsonrpc": "2.0",
-                "error": RPCError({"code": -32601, "message": message}),
-            }
+                "error": cast(RPCError, {"code": -32601, "message": message}),
+            },
         )
 
-    return RPCResponse({"id": 1, "jsonrpc": "2.0", "result": result})
+    return cast(RPCResponse, {"id": response_id, "jsonrpc": "2.0", "result": result})
 
 
 def _make_request(
@@ -154,6 +217,7 @@ def _make_request(
     params: Any,
     api_endpoints: Dict[str, Dict[str, Any]],
     ethereum_tester_instance: "EthereumTester",
+    request_id: str,
 ) -> RPCResponse:
     # do not import eth_tester derivatives until runtime,
     # it is not a default dependency
@@ -166,11 +230,15 @@ def _make_request(
     try:
         delegator = api_endpoints[namespace][endpoint]
     except KeyError as e:
-        return _make_response(e, f"Unknown RPC Endpoint: {method}")
+        return _make_response(e, request_id, message=f"Unknown RPC Endpoint: {method}")
     try:
         response = delegator(ethereum_tester_instance, params)
     except NotImplementedError as e:
-        return _make_response(e, f"RPC Endpoint has not been implemented: {method}")
+        return _make_response(
+            e,
+            request_id,
+            message=f"RPC Endpoint has not been implemented: {method}",
+        )
     except TransactionFailed as e:
         first_arg = e.args[0]
         try:
@@ -187,4 +255,4 @@ def _make_request(
             reason = first_arg
         raise TransactionFailed(f"execution reverted: {reason}")
     else:
-        return _make_response(response)
+        return _make_response(response, request_id)

web3/providers/eth_tester/middleware.py

@@ -40,17 +40,14 @@ from web3._utils.formatters import (
 from web3._utils.method_formatters import (
     apply_list_to_array_formatter,
 )
-from web3.middleware import (
-    construct_formatting_middleware,
+from web3.middleware.base import (
+    Web3Middleware,
 )
 from web3.middleware.formatting import (
-    async_construct_formatting_middleware,
+    FormattingMiddlewareBuilder,
 )
 from web3.types import (
-    AsyncMiddlewareCoroutine,
-    Middleware,
     RPCEndpoint,
-    RPCResponse,
     TxParams,
 )
 
@@ -62,7 +59,7 @@ if TYPE_CHECKING:
 
 
 def is_named_block(value: Any) -> bool:
-    return value in {"latest", "earliest", "pending", "safe", "finalized"}
+    return value in {"latest", "earliest", "safe", "finalized"}
 
 
 def is_hexstr(value: Any) -> bool:
@@ -95,7 +92,7 @@ TRANSACTION_REQUEST_FORMATTERS = {
     "maxFeePerGas": to_integer_if_hex,
     "maxPriorityFeePerGas": to_integer_if_hex,
     "accessList": apply_list_to_array_formatter(
-        (apply_key_map({"storageKeys": "storage_keys"}))
+        apply_key_map({"storageKeys": "storage_keys"})
     ),
 }
 transaction_request_formatter = apply_formatters_to_dict(TRANSACTION_REQUEST_FORMATTERS)
@@ -113,14 +110,14 @@ filter_request_remapper = apply_key_map(FILTER_REQUEST_KEY_MAPPING)
 
 
 FILTER_REQUEST_FORMATTERS = {
-    "fromBlock": to_integer_if_hex,
-    "toBlock": to_integer_if_hex,
+    "from_block": to_integer_if_hex,
+    "to_block": to_integer_if_hex,
 }
 filter_request_formatter = apply_formatters_to_dict(FILTER_REQUEST_FORMATTERS)
 
 filter_request_transformer = compose(
-    filter_request_remapper,
     filter_request_formatter,
+    filter_request_remapper,
 )
 
 
@@ -138,6 +135,7 @@ TRANSACTION_RESULT_KEY_MAPPING = {
     "max_priority_fee_per_gas": "maxPriorityFeePerGas",
     "transaction_hash": "transactionHash",
     "transaction_index": "transactionIndex",
+    "data": "input",
 }
 transaction_result_remapper = apply_key_map(TRANSACTION_RESULT_KEY_MAPPING)
 
@@ -201,7 +199,6 @@ BLOCK_RESULT_KEY_MAPPING = {
 block_result_remapper = apply_key_map(BLOCK_RESULT_KEY_MAPPING)
 
 BLOCK_RESULT_FORMATTERS = {
-    "logsBloom": integer_to_hex,
     "withdrawals": apply_list_to_array_formatter(
         apply_key_map({"validator_index": "validatorIndex"}),
     ),
@@ -288,21 +285,14 @@ request_formatters = {
     ),
     # EVM
     RPCEndpoint("evm_revert"): apply_formatters_to_args(hex_to_integer),
-    # Personal
-    RPCEndpoint("personal_sendTransaction"): apply_formatters_to_args(
-        transaction_request_transformer,
-        identity,
-    ),
 }
 
 result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {
     RPCEndpoint("eth_getBlockByHash"): apply_formatter_if(
-        is_dict,
-        compose(block_result_remapper, block_result_formatter),
+        is_dict, compose(block_result_remapper, block_result_formatter)
     ),
     RPCEndpoint("eth_getBlockByNumber"): apply_formatter_if(
-        is_dict,
-        compose(block_result_remapper, block_result_formatter),
+        is_dict, compose(block_result_remapper, block_result_formatter)
     ),
     RPCEndpoint("eth_getBlockTransactionCountByHash"): apply_formatter_if(
         is_dict,
@@ -343,15 +333,8 @@ result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {
 }
 
 
-ethereum_tester_middleware = construct_formatting_middleware(
-    request_formatters=request_formatters, result_formatters=result_formatters
-)
-
-
 def guess_from(w3: "Web3", _: TxParams) -> ChecksumAddress:
-    if w3.eth.coinbase:
-        return w3.eth.coinbase
-    elif w3.eth.accounts and len(w3.eth.accounts) > 0:
+    if w3.eth.accounts and len(w3.eth.accounts) > 0:
         return w3.eth.accounts[0]
 
     return None
@@ -369,48 +352,14 @@ def fill_default(
         return assoc(transaction, field, guess_val)
 
 
-def default_transaction_fields_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-    def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-        if method in (
-            "eth_call",
-            "eth_estimateGas",
-            "eth_sendTransaction",
-            "eth_createAccessList",
-        ):
-            fill_default_from = fill_default("from", guess_from, w3)
-            filled_transaction = pipe(
-                params[0],
-                fill_default_from,
-            )
-            return make_request(method, [filled_transaction] + list(params)[1:])
-        else:
-            return make_request(method, params)
-
-    return middleware
-
-
 # --- async --- #
 
 
-async def async_ethereum_tester_middleware(  # type: ignore
-    make_request, web3: "AsyncWeb3"
-) -> Middleware:
-    middleware = await async_construct_formatting_middleware(
-        request_formatters=request_formatters, result_formatters=result_formatters
-    )
-    return await middleware(make_request, web3)
-
-
 async def async_guess_from(
     async_w3: "AsyncWeb3", _: TxParams
 ) -> Optional[ChecksumAddress]:
-    coinbase = await async_w3.eth.coinbase
     accounts = await async_w3.eth.accounts
-    if coinbase is not None:
-        return coinbase
-    elif accounts is not None and len(accounts) > 0:
+    if accounts is not None and len(accounts) > 0:
         return accounts[0]
     return None
 
@@ -430,20 +379,43 @@ async def async_fill_default(
         return assoc(transaction, field, guess_val)
 
 
-async def async_default_transaction_fields_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], async_w3: "AsyncWeb3"
-) -> AsyncMiddlewareCoroutine:
-    async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
+# --- define middleware --- #
+
+
+class DefaultTransactionFieldsMiddleware(Web3Middleware):
+    def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         if method in (
             "eth_call",
             "eth_estimateGas",
             "eth_sendTransaction",
+            "eth_createAccessList",
+        ):
+            fill_default_from = fill_default("from", guess_from, self._w3)
+            filled_transaction = pipe(
+                params[0],
+                fill_default_from,
+            )
+            params = [filled_transaction] + list(params)[1:]
+        return method, params
+
+    # --- async --- #
+
+    async def async_request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
+        if method in (
+            "eth_call",
+            "eth_estimateGas",
+            "eth_sendTransaction",
+            "eth_createAccessList",
         ):
             filled_transaction = await async_fill_default(
-                "from", async_guess_from, async_w3, params[0]
+                "from", async_guess_from, self._w3, params[0]
             )
-            return await make_request(method, [filled_transaction] + list(params)[1:])
-        else:
-            return await make_request(method, params)
+            params = [filled_transaction] + list(params)[1:]
+
+        return method, params
+
 
-    return middleware
+ethereum_tester_middleware = FormattingMiddlewareBuilder.build(
+    request_formatters=request_formatters, result_formatters=result_formatters
+)
+default_transaction_fields_middleware = DefaultTransactionFieldsMiddleware

web3/providers/ipc.py

@@ -14,9 +14,11 @@ from types import (
 )
 from typing import (
     Any,
-    Optional,
+    List,
+    Tuple,
     Type,
     Union,
+    cast,
 )
 
 from web3._utils.threads import (
@@ -27,6 +29,13 @@ from web3.types import (
     RPCResponse,
 )
 
+from .._utils.batching import (
+    sort_batch_response_by_response_ids,
+)
+from ..exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from .base import (
     JSONBaseProvider,
 )
@@ -86,62 +95,40 @@ class PersistantSocket:
         return self.sock
 
 
-def get_default_ipc_path() -> Optional[str]:
+def get_default_ipc_path() -> str:
     if sys.platform == "darwin":
-        ipc_path = os.path.expanduser(
-            os.path.join("~", "Library", "Ethereum", "geth.ipc")
-        )
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return os.path.expanduser(os.path.join("~", "Library", "Ethereum", "geth.ipc"))
 
     elif sys.platform.startswith("linux") or sys.platform.startswith("freebsd"):
-        ipc_path = os.path.expanduser(os.path.join("~", ".ethereum", "geth.ipc"))
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return os.path.expanduser(os.path.join("~", ".ethereum", "geth.ipc"))
 
     elif sys.platform == "win32":
-        ipc_path = r"\\.\pipe\geth.ipc"
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
-            f"Unsupported platform '{sys.platform}'.  Only darwin/linux/win32/"
+        raise Web3ValueError(
+            f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
 
 
-def get_dev_ipc_path() -> Optional[str]:
+def get_dev_ipc_path() -> str:
     if os.environ.get("WEB3_PROVIDER_URI", ""):
-        ipc_path = os.environ.get("WEB3_PROVIDER_URI")
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return os.environ.get("WEB3_PROVIDER_URI")
 
     elif sys.platform == "darwin":
         tmpdir = os.environ.get("TMPDIR", "")
-        ipc_path = os.path.expanduser(os.path.join(tmpdir, "geth.ipc"))
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return os.path.expanduser(os.path.join(tmpdir, "geth.ipc"))
 
     elif sys.platform.startswith("linux") or sys.platform.startswith("freebsd"):
-        ipc_path = os.path.expanduser(os.path.join("/tmp", "geth.ipc"))
-        if os.path.exists(ipc_path):
-            return ipc_path
-        return None
+        return os.path.expanduser(os.path.join("/tmp", "geth.ipc"))
 
     elif sys.platform == "win32":
-        ipc_path = os.path.join("\\\\", ".", "pipe", "geth.ipc")
-        if os.path.exists(ipc_path):
-            return ipc_path
+        return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
-            f"Unsupported platform '{sys.platform}'.  Only darwin/linux/win32/"
+        raise Web3ValueError(
+            f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
 
@@ -153,8 +140,7 @@ class IPCProvider(JSONBaseProvider):
     def __init__(
         self,
         ipc_path: Union[str, Path] = None,
-        timeout: int = 10,
-        *args: Any,
+        timeout: int = 30,
         **kwargs: Any,
     ) -> None:
         if ipc_path is None:
@@ -162,22 +148,17 @@ class IPCProvider(JSONBaseProvider):
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
             self.ipc_path = str(Path(ipc_path).expanduser().resolve())
         else:
-            raise TypeError("ipc_path must be of type string or pathlib.Path")
+            raise Web3TypeError("ipc_path must be of type string or pathlib.Path")
 
         self.timeout = timeout
         self._lock = threading.Lock()
         self._socket = PersistantSocket(self.ipc_path)
-        super().__init__()
+        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"
 
-    def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        self.logger.debug(
-            f"Making request IPC. Path: {self.ipc_path}, Method: {method}"
-        )
-        request = self.encode_rpc_request(method, params)
-
+    def _make_request(self, request: bytes) -> RPCResponse:
         with self._lock, self._socket as sock:
             try:
                 sock.sendall(request)
@@ -208,6 +189,21 @@ class IPCProvider(JSONBaseProvider):
                         timeout.sleep(0)
                         continue
 
+    def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+        self.logger.debug(
+            f"Making request IPC. Path: {self.ipc_path}, Method: {method}"
+        )
+        request = self.encode_rpc_request(method, params)
+        return self._make_request(request)
+
+    def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        self.logger.debug(f"Making batch request IPC. Path: {self.ipc_path}")
+        request_data = self.encode_batch_rpc_request(requests)
+        response = cast(List[RPCResponse], self._make_request(request_data))
+        return sort_batch_response_by_response_ids(response)
+
 
 # A valid JSON RPC response can only end in } or ] http://www.jsonrpc.org/specification
 def has_valid_json_rpc_ending(raw_response: bytes) -> bool: