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

web3/providers/rpc/rpc.py

@@ -0,0 +1,179 @@
+import logging
+import time
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+from eth_typing import (
+    URI,
+)
+from eth_utils import (
+    to_dict,
+)
+import requests
+
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
+from web3._utils.http import (
+    construct_user_agent,
+)
+from web3.types import (
+    RPCEndpoint,
+    RPCResponse,
+)
+
+from ..._utils.batching import (
+    sort_batch_response_by_response_ids,
+)
+from ..._utils.caching import (
+    handle_request_caching,
+)
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
+from ..base import (
+    JSONBaseProvider,
+)
+from .utils import (
+    ExceptionRetryConfiguration,
+    check_if_retry_on_failure,
+)
+
+if TYPE_CHECKING:
+    from web3.middleware.base import (  # noqa: F401
+        Middleware,
+    )
+
+
+class HTTPProvider(JSONBaseProvider):
+    logger = logging.getLogger("web3.providers.HTTPProvider")
+    endpoint_uri = None
+    _request_kwargs = None
+
+    def __init__(
+        self,
+        endpoint_uri: Optional[Union[URI, str]] = None,
+        request_kwargs: Optional[Any] = None,
+        session: Optional[Any] = None,
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
+        ] = empty,
+        **kwargs: Any,
+    ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
+        if endpoint_uri is None:
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
+        else:
+            self.endpoint_uri = URI(endpoint_uri)
+
+        self._request_kwargs = request_kwargs or {}
+        self._exception_retry_configuration = exception_retry_configuration
+
+        if session:
+            self._request_session_manager.cache_and_return_session(
+                self.endpoint_uri, session
+            )
+
+        super().__init__(**kwargs)
+
+    def __str__(self) -> str:
+        return f"RPC connection {self.endpoint_uri}"
+
+    @property
+    def exception_retry_configuration(self) -> ExceptionRetryConfiguration:
+        if isinstance(self._exception_retry_configuration, Empty):
+            self._exception_retry_configuration = ExceptionRetryConfiguration(
+                errors=(
+                    ConnectionError,
+                    requests.HTTPError,
+                    requests.Timeout,
+                )
+            )
+        return self._exception_retry_configuration
+
+    @exception_retry_configuration.setter
+    def exception_retry_configuration(
+        self, value: Union[ExceptionRetryConfiguration, Empty]
+    ) -> None:
+        self._exception_retry_configuration = value
+
+    @to_dict
+    def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
+        if "headers" not in self._request_kwargs:
+            yield "headers", self.get_request_headers()
+        yield from self._request_kwargs.items()
+
+    def get_request_headers(self) -> Dict[str, str]:
+        return {
+            "Content-Type": "application/json",
+            "User-Agent": construct_user_agent(type(self)),
+        }
+
+    def _make_request(self, method: RPCEndpoint, request_data: bytes) -> bytes:
+        """
+        If exception_retry_configuration is set, retry on failure; otherwise, make
+        the request without retrying.
+        """
+        if (
+            self.exception_retry_configuration is not None
+            and check_if_retry_on_failure(
+                method, self.exception_retry_configuration.method_allowlist
+            )
+        ):
+            for i in range(self.exception_retry_configuration.retries):
+                try:
+                    return self._request_session_manager.make_post_request(
+                        self.endpoint_uri, request_data, **self.get_request_kwargs()
+                    )
+                except tuple(self.exception_retry_configuration.errors) as e:
+                    if i < self.exception_retry_configuration.retries - 1:
+                        time.sleep(
+                            self.exception_retry_configuration.backoff_factor * 2**i
+                        )
+                        continue
+                    else:
+                        raise e
+            return None
+        else:
+            return self._request_session_manager.make_post_request(
+                self.endpoint_uri, request_data, **self.get_request_kwargs()
+            )
+
+    @handle_request_caching
+    def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+        self.logger.debug(
+            f"Making request HTTP. URI: {self.endpoint_uri}, Method: {method}"
+        )
+        request_data = self.encode_rpc_request(method, params)
+        raw_response = self._make_request(method, request_data)
+        response = self.decode_rpc_response(raw_response)
+        self.logger.debug(
+            f"Getting response HTTP. URI: {self.endpoint_uri}, "
+            f"Method: {method}, Response: {response}"
+        )
+        return response
+
+    def make_batch_request(
+        self, batch_requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        self.logger.debug(f"Making batch request HTTP, uri: `{self.endpoint_uri}`")
+        request_data = self.encode_batch_rpc_request(batch_requests)
+        raw_response = self._request_session_manager.make_post_request(
+            self.endpoint_uri, request_data, **self.get_request_kwargs()
+        )
+        self.logger.debug("Received batch response HTTP.")
+        responses_list = cast(List[RPCResponse], self.decode_rpc_response(raw_response))
+        return sort_batch_response_by_response_ids(responses_list)

web3/providers/rpc/utils.py

@@ -0,0 +1,92 @@
+from typing import (
+    Sequence,
+    Type,
+)
+
+from pydantic import (
+    BaseModel,
+)
+
+from web3.types import (
+    RPCEndpoint,
+)
+
+REQUEST_RETRY_ALLOWLIST = [
+    "admin",
+    "net",
+    "txpool",
+    "testing",
+    "evm",
+    "eth_protocolVersion",
+    "eth_syncing",
+    "eth_chainId",
+    "eth_gasPrice",
+    "eth_accounts",
+    "eth_blockNumber",
+    "eth_getBalance",
+    "eth_getStorageAt",
+    "eth_getProof",
+    "eth_getCode",
+    "eth_getBlockByNumber",
+    "eth_getBlockByHash",
+    "eth_getBlockTransactionCountByNumber",
+    "eth_getBlockTransactionCountByHash",
+    "eth_getUncleCountByBlockNumber",
+    "eth_getUncleCountByBlockHash",
+    "eth_getTransactionByHash",
+    "eth_getTransactionByBlockHashAndIndex",
+    "eth_getTransactionByBlockNumberAndIndex",
+    "eth_getTransactionReceipt",
+    "eth_getTransactionCount",
+    "eth_getRawTransactionByHash",
+    "eth_call",
+    "eth_estimateGas",
+    "eth_createAccessList",
+    "eth_maxPriorityFeePerGas",
+    "eth_newBlockFilter",
+    "eth_newPendingTransactionFilter",
+    "eth_newFilter",
+    "eth_getFilterChanges",
+    "eth_getFilterLogs",
+    "eth_getLogs",
+    "eth_uninstallFilter",
+    "eth_getCompilers",
+    "eth_getWork",
+    "eth_sign",
+    "eth_signTypedData",
+    "eth_sendRawTransaction",
+]
+
+
+def check_if_retry_on_failure(
+    method: RPCEndpoint,
+    allowlist: Sequence[str] = None,
+) -> bool:
+    if allowlist is None:
+        allowlist = REQUEST_RETRY_ALLOWLIST
+
+    if method in allowlist or method.split("_")[0] in allowlist:
+        return True
+    else:
+        return False
+
+
+class ExceptionRetryConfiguration(BaseModel):
+    errors: Sequence[Type[BaseException]]
+    retries: int
+    backoff_factor: float
+    method_allowlist: Sequence[str]
+
+    def __init__(
+        self,
+        errors: Sequence[Type[BaseException]] = None,
+        retries: int = 5,
+        backoff_factor: float = 0.125,
+        method_allowlist: Sequence[str] = None,
+    ):
+        super().__init__(
+            errors=errors,
+            retries=retries,
+            backoff_factor=backoff_factor,
+            method_allowlist=method_allowlist or REQUEST_RETRY_ALLOWLIST,
+        )

web3/testing.py

@@ -12,21 +12,21 @@ from web3.module import (
 
 class Testing(Module):
     def timeTravel(self, timestamp: int) -> None:
-        return self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
+        self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
 
     def mine(self, num_blocks: int = 1) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
+        self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
 
     def snapshot(self) -> int:
         self.last_snapshot_idx = self.w3.manager.request_blocking(RPC.evm_snapshot, [])
         return self.last_snapshot_idx
 
     def reset(self) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_reset, [])
+        self.w3.manager.request_blocking(RPC.evm_reset, [])
 
     def revert(self, snapshot_idx: Optional[int] = None) -> None:
         if snapshot_idx is None:
             revert_target = self.last_snapshot_idx
         else:
             revert_target = snapshot_idx
-        return self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])
+        self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])

web3/tools/benchmark/main.py

@@ -20,10 +20,8 @@ from web3 import (
     Web3,
 )
 from web3.middleware import (
-    async_buffered_gas_estimate_middleware,
-    async_gas_price_strategy_middleware,
-    buffered_gas_estimate_middleware,
-    gas_price_strategy_middleware,
+    BufferedGasEstimateMiddleware,
+    GasPriceStrategyMiddleware,
 )
 from web3.tools.benchmark.node import (
     GethBenchmarkFixture,
@@ -61,7 +59,7 @@ def build_web3_http(endpoint_uri: str) -> Web3:
     wait_for_http(endpoint_uri)
     _w3 = Web3(
         HTTPProvider(endpoint_uri),
-        middlewares=[gas_price_strategy_middleware, buffered_gas_estimate_middleware],
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
     )
     return _w3
 
@@ -70,10 +68,7 @@ async def build_async_w3_http(endpoint_uri: str) -> AsyncWeb3:
     await wait_for_aiohttp(endpoint_uri)
     _w3 = AsyncWeb3(
         AsyncHTTPProvider(endpoint_uri),
-        middlewares=[
-            async_gas_price_strategy_middleware,
-            async_buffered_gas_estimate_middleware,
-        ],
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
     )
     return _w3
 
@@ -113,35 +108,36 @@ def main(logger: logging.Logger, num_calls: int) -> None:
                 asyncio.set_event_loop(loop)
 
             # -- sync -- #
-            coinbase = w3_http.eth.coinbase
+            account = w3_http.eth.accounts[0]
 
             # -- async -- #
             async_w3_http = loop.run_until_complete(
                 build_async_w3_http(fixture.endpoint_uri)
             )
-            async_coinbase = loop.run_until_complete(async_w3_http.eth.coinbase)
+            async_accounts = loop.run_until_complete(async_w3_http.eth.accounts)
+            async_account = async_accounts[0]
 
             methods = [
                 {
                     "name": "eth_gasPrice",
                     "params": {},
-                    "exec": lambda: w3_http.eth.gas_price,
-                    "async_exec": lambda: async_w3_http.eth.gas_price,
+                    "exec": lambda w3_http=w3_http: w3_http.eth.gas_price,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.gas_price,  # noqa: E501
                 },
                 {
                     "name": "eth_sendTransaction",
                     "params": {},
-                    "exec": lambda: w3_http.eth.send_transaction(
+                    "exec": lambda w3_http=w3_http, account=account: w3_http.eth.send_transaction(  # noqa: E501
                         {
                             "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": coinbase,
+                            "from": account,
                             "value": Wei(1),
                         }
                     ),
-                    "async_exec": lambda: async_w3_http.eth.send_transaction(
+                    "async_exec": lambda async_w3_http=async_w3_http, async_account=async_account: async_w3_http.eth.send_transaction(  # noqa: E501
                         {
                             "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": async_coinbase,
+                            "from": async_account,
                             "value": Wei(1),
                         }
                     ),
@@ -149,18 +145,22 @@ def main(logger: logging.Logger, num_calls: int) -> None:
                 {
                     "name": "eth_blockNumber",
                     "params": {},
-                    "exec": lambda: w3_http.eth.block_number,
-                    "async_exec": lambda: async_w3_http.eth.block_number,
+                    "exec": lambda w3_http=w3_http: w3_http.eth.block_number,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.block_number,  # noqa: E501
                 },
                 {
                     "name": "eth_getBlock",
                     "params": {},
-                    "exec": lambda: w3_http.eth.get_block(1),
-                    "async_exec": lambda: async_w3_http.eth.get_block(1),
+                    "exec": lambda w3_http=w3_http: w3_http.eth.get_block(1),
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.get_block(  # noqa: E501
+                        1
+                    ),
                 },
             ]
 
-            def benchmark(method: Dict[str, Any]) -> None:
+            def benchmark(
+                method: Dict[str, Any], loop: asyncio.AbstractEventLoop = loop
+            ) -> None:
                 outcomes: Dict[str, Union[str, float]] = defaultdict(lambda: "N/A")
                 outcomes["name"] = method["name"]
                 outcomes["HTTPProvider"] = sync_benchmark(

web3/tools/benchmark/node.py

@@ -24,10 +24,7 @@ from web3.tools.benchmark.utils import (
     kill_proc_gracefully,
 )
 
-GETH_FIXTURE_ZIP = "geth-1.13.9-fixture.zip"
-
-# use same coinbase value as in `web3.py/tests/integration/generate_fixtures/common.py`
-COINBASE = "0xdc544d1aa88ff8bbd2f2aec754b1f1e99e1812fd"
+GETH_FIXTURE_ZIP = "geth-1.14.5-fixture.zip"
 
 
 class GethBenchmarkFixture:
@@ -84,7 +81,7 @@ class GethBenchmarkFixture:
             "--dev.period",
             "100",
             "--datadir",
-            str(datadir),
+            datadir,
             "--nodiscover",
             "--http",
             "--http.port",
@@ -92,9 +89,6 @@ class GethBenchmarkFixture:
             "--http.api",
             "admin,eth,net,web3",
             "--ipcdisable",
-            "--allow-insecure-unlock",
-            "--miner.etherbase",
-            COINBASE[2:],
             "--password",
             os.path.join(datadir, "keystore", "pw.txt"),
         )

web3/tools/benchmark/reporting.py

@@ -14,7 +14,7 @@ def print_header(logger: Logger, num_calls: int) -> None:
             "HTTPProvider",
             "AsyncHTTProvider",
             "IPCProvider",
-            "WebsocketProvider",
+            "WebSocketProvider",
         )
     )
     logger.info("-" * 112)
@@ -30,7 +30,7 @@ def print_entry(
             method_benchmarks["HTTPProvider"],
             method_benchmarks["AsyncHTTPProvider"],
             method_benchmarks["IPCProvider"],
-            method_benchmarks["WebsocketProvider"],
+            method_benchmarks["WebSocketProvider"],
         )
     )
 

web3/tools/benchmark/utils.py

@@ -17,7 +17,7 @@ def wait_for_socket(ipc_path: str, timeout: int = 30) -> None:
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             sock.connect(ipc_path)
             sock.settimeout(timeout)
-        except (FileNotFoundError, socket.error):
+        except OSError:
             time.sleep(0.01)
         else:
             break

web3/tracing.py

@@ -53,10 +53,10 @@ class Tracing(Module):
         self._default_block = value
 
     def trace_replay_transaction_munger(
-        self,
-        block_identifier: Union[_Hash32, BlockIdentifier],
-        mode: TraceMode = ["trace"],
+        self, block_identifier: Union[_Hash32, BlockIdentifier], mode: TraceMode = None
     ) -> Tuple[Union[BlockIdentifier, _Hash32], TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return (block_identifier, mode)
 
     trace_replay_transaction: Method[Callable[..., BlockTrace]] = Method(
@@ -86,9 +86,11 @@ class Tracing(Module):
     def trace_call_munger(
         self,
         transaction: TxParams,
-        mode: TraceMode = ["trace"],
+        mode: TraceMode = None,
         block_identifier: Optional[BlockIdentifier] = None,
     ) -> Tuple[TxParams, TraceMode, BlockIdentifier]:
+        if mode is None:
+            mode = ["trace"]
         if "from" not in transaction and is_checksum_address(
             self.w3.eth.default_account
         ):
@@ -105,8 +107,10 @@ class Tracing(Module):
     )
 
     def trace_transactions_munger(
-        self, raw_transaction: HexStr, mode: TraceMode = ["trace"]
+        self, raw_transaction: HexStr, mode: TraceMode = None
     ) -> Tuple[HexStr, TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return raw_transaction, mode
 
     trace_raw_transaction: Method[Callable[..., BlockTrace]] = Method(