web3 7.0.0b3__py3-none-any.whl → 7.0.0b5__py3-none-any.whl

web3/providers/eth_tester/defaults.py

@@ -21,7 +21,6 @@ from eth_tester.exceptions import (
     FilterNotFound,
     TransactionFailed,
     TransactionNotFound,
-    ValidationError,
 )
 from eth_typing import (
     HexAddress,
@@ -218,7 +217,7 @@ def _generate_random_private_key() -> HexStr:
     WARNING: This is not a secure way to generate private keys and should only
     be used for testing purposes.
     """
-    return encode_hex(bytes(bytearray((random.randint(0, 255) for _ in range(32)))))
+    return encode_hex(bytes(bytearray(random.randint(0, 255) for _ in range(32))))
 
 
 @without_params
@@ -226,18 +225,6 @@ def create_new_account(eth_tester: "EthereumTester") -> HexAddress:
     return eth_tester.add_account(_generate_random_private_key())
 
 
-def personal_send_transaction(eth_tester: "EthereumTester", params: Any) -> HexStr:
-    transaction, password = params
-
-    try:
-        eth_tester.unlock_account(transaction["from"], password)
-        transaction_hash = eth_tester.send_transaction(transaction)
-    finally:
-        eth_tester.lock_account(transaction["from"])
-
-    return transaction_hash
-
-
 API_ENDPOINTS = {
     "web3": {
         "clientVersion": client_version,
@@ -404,41 +391,6 @@ API_ENDPOINTS = {
         "writeBlockProfile": not_implemented,
         "writeMemProfile": not_implemented,
     },
-    "personal": {
-        "ec_recover": not_implemented,
-        "import_raw_key": call_eth_tester("add_account"),
-        "list_accounts": call_eth_tester("get_accounts"),
-        "list_wallets": not_implemented,
-        "lock_account": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("lock_account")),
-            static_return(False),
-        ),
-        "new_account": create_new_account,
-        "unlock_account": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("unlock_account")),
-            static_return(False),
-        ),
-        "send_transaction": personal_send_transaction,
-        "sign": not_implemented,
-        # deprecated
-        "ecRecover": not_implemented,
-        "importRawKey": call_eth_tester("add_account"),
-        "listAccounts": call_eth_tester("get_accounts"),
-        "lockAccount": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("lock_account")),
-            static_return(False),
-        ),
-        "newAccount": create_new_account,
-        "unlockAccount": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("unlock_account")),
-            static_return(False),
-        ),
-        "sendTransaction": personal_send_transaction,
-    },
     "testing": {
         "timeTravel": call_eth_tester("time_travel"),
     },

web3/providers/eth_tester/main.py

@@ -4,8 +4,10 @@ from typing import (
     Callable,
     Coroutine,
     Dict,
+    Literal,
     Optional,
     Union,
+    cast,
 )
 
 from eth_abi import (
@@ -18,9 +20,6 @@ from eth_utils import (
     is_bytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3.providers import (
     BaseProvider,
 )
@@ -33,6 +32,9 @@ from web3.types import (
     RPCResponse,
 )
 
+from ...exceptions import (
+    Web3TypeError,
+)
 from ...middleware import (
     async_combine_middleware,
     combine_middleware,
@@ -58,6 +60,7 @@ if TYPE_CHECKING:
 
 
 class AsyncEthereumTesterProvider(AsyncBaseProvider):
+    _current_request_id = 0
     _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
@@ -98,13 +101,22 @@ class AsyncEthereumTesterProvider(AsyncBaseProvider):
         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):
+    _current_request_id = 0
     _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
@@ -133,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)}. "
@@ -172,23 +184,32 @@ class EthereumTesterProvider(BaseProvider):
         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(
@@ -196,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
@@ -208,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:
@@ -229,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

@@ -72,7 +72,9 @@ is_not_named_block = complement(is_named_block)
 # --- Request Mapping --- #
 
 TRANSACTION_REQUEST_KEY_MAPPING = {
+    "blobVersionedHashes": "blob_versioned_hashes",
     "gasPrice": "gas_price",
+    "maxFeePerBlobGas": "max_fee_per_blob_gas",
     "maxFeePerGas": "max_fee_per_gas",
     "maxPriorityFeePerGas": "max_priority_fee_per_gas",
     "accessList": "access_list",
@@ -90,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)
@@ -108,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,
 )
 
 
@@ -123,10 +125,12 @@ filter_request_transformer = compose(
 
 TRANSACTION_RESULT_KEY_MAPPING = {
     "access_list": "accessList",
+    "blob_versioned_hashes": "blobVersionedHashes",
     "block_hash": "blockHash",
     "block_number": "blockNumber",
     "chain_id": "chainId",
     "gas_price": "gasPrice",
+    "max_fee_per_blob_gas": "maxFeePerBlobGas",
     "max_fee_per_gas": "maxFeePerGas",
     "max_priority_fee_per_gas": "maxPriorityFeePerGas",
     "transaction_hash": "transactionHash",
@@ -164,6 +168,8 @@ RECEIPT_RESULT_KEY_MAPPING = {
     "effective_gas_price": "effectiveGasPrice",
     "transaction_hash": "transactionHash",
     "transaction_index": "transactionIndex",
+    "blob_gas_used": "blobGasUsed",
+    "blob_gas_price": "blobGasPrice",
 }
 receipt_result_remapper = apply_key_map(RECEIPT_RESULT_KEY_MAPPING)
 
@@ -186,6 +192,9 @@ BLOCK_RESULT_KEY_MAPPING = {
     # JSON-RPC spec still says miner
     "coinbase": "miner",
     "withdrawals_root": "withdrawalsRoot",
+    "parent_beacon_block_root": "parentBeaconBlockRoot",
+    "blob_gas_used": "blobGasUsed",
+    "excess_blob_gas": "excessBlobGas",
 }
 block_result_remapper = apply_key_map(BLOCK_RESULT_KEY_MAPPING)
 
@@ -276,11 +285,6 @@ 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]]] = {

web3/providers/ipc.py

@@ -26,6 +26,10 @@ from web3.types import (
     RPCResponse,
 )
 
+from ..exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from .base import (
     JSONBaseProvider,
 )
@@ -96,7 +100,7 @@ def get_default_ipc_path() -> str:
         return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
@@ -117,7 +121,7 @@ def get_dev_ipc_path() -> str:
         return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
@@ -139,7 +143,7 @@ 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()

web3/providers/persistent/async_ipc.py

@@ -33,6 +33,7 @@ from ..._utils.caching import (
 )
 from ...exceptions import (
     ProviderConnectionError,
+    Web3TypeError,
 )
 from ..ipc import (
     get_default_ipc_path,
@@ -71,7 +72,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
         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._max_connection_retries = max_connection_retries
         super().__init__(**kwargs)
@@ -91,7 +92,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             current_request_id = json.loads(request_data)["id"]
             await self._get_response_for_request_id(current_request_id, timeout=2)
             return True
-        except (OSError, BrokenPipeError, ProviderConnectionError) as e:
+        except (OSError, ProviderConnectionError) as e:
             if show_traceback:
                 raise ProviderConnectionError(
                     f"Problem connecting to provider with error: {type(e)}: {e}"
@@ -114,11 +115,11 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             except OSError as e:
                 if _connection_attempts == self._max_connection_retries:
                     raise ProviderConnectionError(
-                        f"Could not connect to endpoint: {self.endpoint_uri}. "
+                        f"Could not connect to: {self.ipc_path}. "
                         f"Retries exceeded max of {self._max_connection_retries}."
                     ) from e
                 self.logger.info(
-                    f"Could not connect to endpoint: {self.endpoint_uri}. Retrying in "
+                    f"Could not connect to: {self.ipc_path}. Retrying in "
                     f"{round(_backoff_time, 1)} seconds.",
                     exc_info=True,
                 )
@@ -130,9 +131,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             self._writer.close()
             await self._writer.wait_closed()
             self._writer = None
-            self.logger.debug(
-                f'Successfully disconnected from endpoint: "{self.endpoint_uri}'
-            )
+            self.logger.debug(f'Successfully disconnected from : "{self.ipc_path}')
 
         try:
             self._message_listener_task.cancel()

web3/providers/persistent/persistent.py

@@ -30,7 +30,6 @@ DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 30.0
 class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     logger = logging.getLogger("web3.providers.PersistentConnectionProvider")
     has_persistent_connection = True
-    endpoint_uri: Optional[str] = None
 
     _request_processor: RequestProcessor
     _message_listener_task: Optional["asyncio.Task[None]"] = None
@@ -50,6 +49,17 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         self.request_timeout = request_timeout
         self.silence_listener_task_exceptions = silence_listener_task_exceptions
 
+    def get_endpoint_uri_or_ipc_path(self) -> str:
+        if hasattr(self, "endpoint_uri"):
+            return str(self.endpoint_uri)
+        elif hasattr(self, "ipc_path"):
+            return str(self.ipc_path)
+        else:
+            raise AttributeError(
+                "`PersistentConnectionProvider` must have either `endpoint_uri` or "
+                "`ipc_path` attribute."
+            )
+
     async def connect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 

web3/providers/persistent/request_processor.py

@@ -15,6 +15,9 @@ from web3._utils.caching import (
     RequestInformation,
     generate_cache_key,
 )
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -136,9 +139,9 @@ class RequestProcessor:
     ) -> RequestInformation:
         if "method" in response and response["method"] == "eth_subscription":
             if "params" not in response:
-                raise ValueError("Subscription response must have params field")
+                raise Web3ValueError("Subscription response must have params field")
             if "subscription" not in response["params"]:
-                raise ValueError(
+                raise Web3ValueError(
                     "Subscription response params must have subscription field"
                 )
 
@@ -266,7 +269,7 @@ class RequestProcessor:
             )
         else:
             if not cache_key:
-                raise ValueError(
+                raise Web3ValueError(
                     "Must provide cache key when popping a non-subscription response."
                 )
 
@@ -283,10 +286,7 @@ class RequestProcessor:
     # request processor class methods
 
     def clear_caches(self) -> None:
-        """
-        Clear the request processor caches.
-        """
-
+        """Clear the request processor caches."""
         self._request_information_cache.clear()
         self._request_response_cache.clear()
         self._subscription_response_queue = asyncio.Queue(

web3/providers/persistent/websocket.py

@@ -71,9 +71,9 @@ class WebSocketProvider(PersistentConnectionProvider):
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
-        self.endpoint_uri = URI(endpoint_uri)
-        if self.endpoint_uri is None:
-            self.endpoint_uri = get_default_endpoint()
+        self.endpoint_uri = (
+            URI(endpoint_uri) if endpoint_uri is not None else get_default_endpoint()
+        )
 
         if not any(
             self.endpoint_uri.startswith(prefix)

web3/providers/rpc/async_rpc.py

@@ -20,6 +20,10 @@ from eth_utils import (
     to_dict,
 )
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
@@ -54,9 +58,9 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
-        exception_retry_configuration: Optional[
-            ExceptionRetryConfiguration
-        ] = ExceptionRetryConfiguration(errors=(ClientError, TimeoutError)),
+        exception_retry_configuration: Union[
+            ExceptionRetryConfiguration, Empty
+        ] = empty,
     ) -> None:
         if endpoint_uri is None:
             self.endpoint_uri = get_default_http_endpoint()
@@ -64,7 +68,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
         super().__init__()
 
@@ -74,12 +78,25 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     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=(ClientError, TimeoutError)
+            )
+        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()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
 
     def get_request_headers(self) -> Dict[str, str]:
         return {
@@ -106,7 +123,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
                 except tuple(self.exception_retry_configuration.errors):
                     if i < self.exception_retry_configuration.retries - 1:
                         await asyncio.sleep(
-                            self.exception_retry_configuration.backoff_factor
+                            self.exception_retry_configuration.backoff_factor * 2**i
                         )
                         continue
                     else:

web3/providers/rpc/rpc.py

@@ -18,6 +18,10 @@ from eth_utils import (
 )
 import requests
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
@@ -51,26 +55,16 @@ if TYPE_CHECKING:
 class HTTPProvider(JSONBaseProvider):
     logger = logging.getLogger("web3.providers.HTTPProvider")
     endpoint_uri = None
-
-    _request_args = None
     _request_kwargs = None
 
-    exception_retry_configuration: Optional[ExceptionRetryConfiguration] = None
-
     def __init__(
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         session: Optional[Any] = None,
-        exception_retry_configuration: Optional[ExceptionRetryConfiguration] = (
-            ExceptionRetryConfiguration(
-                errors=(
-                    ConnectionError,
-                    requests.HTTPError,
-                    requests.Timeout,
-                )
-            )
-        ),
+        exception_retry_configuration: Union[
+            ExceptionRetryConfiguration, Empty
+        ] = empty,
     ) -> None:
         if endpoint_uri is None:
             self.endpoint_uri = get_default_http_endpoint()
@@ -78,7 +72,7 @@ class HTTPProvider(JSONBaseProvider):
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
         if session:
             cache_and_return_session(self.endpoint_uri, session)
@@ -88,12 +82,29 @@ class HTTPProvider(JSONBaseProvider):
     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()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
 
     def get_request_headers(self) -> Dict[str, str]:
         return {
@@ -119,7 +130,9 @@ class HTTPProvider(JSONBaseProvider):
                     )
                 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)
+                        time.sleep(
+                            self.exception_retry_configuration.backoff_factor * 2**i
+                        )
                         continue
                     else:
                         raise e

web3/providers/rpc/utils.py

@@ -58,15 +58,6 @@ REQUEST_RETRY_ALLOWLIST = [
     "eth_sign",
     "eth_signTypedData",
     "eth_sendRawTransaction",
-    "personal_importRawKey",
-    "personal_newAccount",
-    "personal_listAccounts",
-    "personal_listWallets",
-    "personal_lockAccount",
-    "personal_unlockAccount",
-    "personal_ecRecover",
-    "personal_sign",
-    "personal_signTypedData",
 ]
 
 
@@ -93,7 +84,7 @@ class ExceptionRetryConfiguration(BaseModel):
         self,
         errors: Sequence[Type[BaseException]] = None,
         retries: int = 5,
-        backoff_factor: float = 0.5,
+        backoff_factor: float = 0.125,
         method_allowlist: Sequence[str] = None,
     ):
         super().__init__(

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])