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

web3/main.py

@@ -91,11 +91,9 @@ from web3.exceptions import (
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
-    AsyncGethPersonal,
     AsyncGethTxPool,
     Geth,
     GethAdmin,
-    GethPersonal,
     GethTxPool,
 )
 from web3.manager import (
@@ -156,7 +154,6 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
             AsyncGeth,
             {
                 "admin": AsyncGethAdmin,
-                "personal": AsyncGethPersonal,
                 "txpool": AsyncGethTxPool,
             },
         ),
@@ -171,7 +168,6 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
             Geth,
             {
                 "admin": GethAdmin,
-                "personal": GethPersonal,
                 "txpool": GethTxPool,
             },
         ),

web3/manager.py

@@ -35,8 +35,8 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    Web3RPCError,
     Web3TypeError,
-    Web3ValueError,
 )
 from web3.middleware import (
     AttributeDictMiddleware,
@@ -87,6 +87,7 @@ def _raise_bad_response_format(response: RPCResponse, error: str = "") -> None:
     raw_response = f"The raw response is: {response}"
 
     if error is not None and error != "":
+        error = error[:-1] if error.endswith(".") else error
         message = f"{message} {error}. {raw_response}"
     else:
         message = f"{message} {raw_response}"
@@ -117,6 +118,111 @@ def apply_null_result_formatters(
         return response
 
 
+def _validate_subscription_fields(response: RPCResponse) -> None:
+    params = response["params"]
+    subscription = params["subscription"]
+    if not isinstance(subscription, str) and not len(subscription) == 34:
+        _raise_bad_response_format(
+            response, "eth_subscription 'params' must include a 'subscription' field."
+        )
+
+
+def _validate_response(
+    response: RPCResponse,
+    error_formatters: Optional[Callable[..., Any]],
+    is_subscription_response: bool = False,
+    logger: Optional[logging.Logger] = None,
+) -> None:
+    if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
+        _raise_bad_response_format(
+            response, 'The "jsonrpc" field must be present with a value of "2.0".'
+        )
+
+    response_id = response.get("id")
+    if "id" in response:
+        int_error_msg = (
+            '"id" must be an integer or a string representation of an integer.'
+        )
+        if response_id is None and "error" in response:
+            # errors can sometimes have null `id`, according to the JSON-RPC spec
+            pass
+        elif not isinstance(response_id, (str, int)):
+            _raise_bad_response_format(response, int_error_msg)
+        elif isinstance(response_id, str):
+            try:
+                int(response_id)
+            except ValueError:
+                _raise_bad_response_format(response, int_error_msg)
+    elif is_subscription_response:
+        # if `id` is not present, this must be a subscription response
+        _validate_subscription_fields(response)
+    else:
+        _raise_bad_response_format(
+            response,
+            'Response must include an "id" field or be formatted as an '
+            "`eth_subscription` response.",
+        )
+
+    if all(key in response for key in {"error", "result"}):
+        _raise_bad_response_format(
+            response, 'Response cannot include both "error" and "result".'
+        )
+    elif (
+        not any(key in response for key in {"error", "result"})
+        and not is_subscription_response
+    ):
+        _raise_bad_response_format(
+            response, 'Response must include either "error" or "result".'
+        )
+    elif "error" in response:
+        error = response["error"]
+
+        # raise the error when the value is a string
+        if error is None or not isinstance(error, dict):
+            _raise_bad_response_format(
+                response,
+                'response["error"] must be a valid object as defined by the '
+                "JSON-RPC 2.0 specification.",
+            )
+
+        # errors must include an integer code
+        code = error.get("code")
+        if not isinstance(code, int):
+            _raise_bad_response_format(
+                response, 'error["code"] is required and must be an integer value.'
+            )
+        elif code == METHOD_NOT_FOUND:
+            exception = MethodUnavailable(
+                repr(error),
+                rpc_response=response,
+                user_message=(
+                    "This method is not available. Check your node provider or your "
+                    "client's API docs to see what methods are supported and / or "
+                    "currently enabled."
+                ),
+            )
+            logger.error(exception.user_message)
+            logger.debug(f"RPC error response: {response}")
+            raise exception
+
+        # errors must include a message
+        error_message = error.get("message")
+        if not isinstance(error_message, str):
+            _raise_bad_response_format(
+                response, 'error["message"] is required and must be a string value.'
+            )
+
+        apply_error_formatters(error_formatters, response)
+
+        web3_rpc_error = Web3RPCError(repr(error), rpc_response=response)
+        logger.error(web3_rpc_error.user_message)
+        logger.debug(f"RPC error response: {response}")
+        raise web3_rpc_error
+
+    elif "result" not in response and not is_subscription_response:
+        _raise_bad_response_format(response)
+
+
 class RequestManager:
     logger = logging.getLogger("web3.manager.RequestManager")
 
@@ -203,90 +309,42 @@ class RequestManager:
     #
     # See also: https://www.jsonrpc.org/specification
     #
-    @staticmethod
     def formatted_response(
+        self,
         response: RPCResponse,
         params: Any,
         error_formatters: Optional[Callable[..., Any]] = None,
         null_result_formatters: Optional[Callable[..., Any]] = None,
     ) -> Any:
-        # jsonrpc is not enforced (as per the spec) but if present, it must be 2.0
-        if "jsonrpc" in response and response["jsonrpc"] != "2.0":
-            _raise_bad_response_format(
-                response, 'The "jsonrpc" field must be present with a value of "2.0"'
-            )
+        is_subscription_response = (
+            response.get("method") == "eth_subscription"
+            and response.get("params") is not None
+            and response["params"].get("subscription") is not None
+            and response["params"].get("result") is not None
+        )
 
-        # id is not enforced (as per the spec) but if present, it must be a
-        # string or integer
-        # TODO: v7 - enforce id per the spec
-        if "id" in response:
-            response_id = response["id"]
-            # id is always None for errors
-            if response_id is None and "error" not in response:
-                _raise_bad_response_format(
-                    response, '"id" must be None when an error is present'
-                )
-            elif not isinstance(response_id, (str, int, type(None))):
-                _raise_bad_response_format(response, '"id" must be a string or integer')
-
-        # Response may not include both "error" and "result"
-        if "error" in response and "result" in response:
-            _raise_bad_response_format(
-                response, 'Response cannot include both "error" and "result"'
-            )
+        _validate_response(
+            response,
+            error_formatters,
+            is_subscription_response=is_subscription_response,
+            logger=self.logger,
+        )
 
-        # Format and validate errors
-        elif "error" in response:
-            error = response.get("error")
-            # Raise the error when the value is a string
-            if error is None or isinstance(error, str):
-                raise Web3ValueError(error)
-
-            # Errors must include an integer code
-            code = error.get("code")
-            if not isinstance(code, int):
-                _raise_bad_response_format(response, "error['code'] must be an integer")
-            elif code == METHOD_NOT_FOUND:
-                raise MethodUnavailable(
-                    error,
-                    user_message="Check your node provider's API docs to see what "
-                    "methods are supported",
-                )
-
-            # Errors must include a message
-            if not isinstance(error.get("message"), str):
-                _raise_bad_response_format(
-                    response, "error['message'] must be a string"
-                )
-
-            apply_error_formatters(error_formatters, response)
-
-            raise Web3ValueError(error)
-
-        # Format and validate results
-        elif "result" in response:
+        # format results
+        if "result" in response:
             # Null values for result should apply null_result_formatters
             # Skip when result not present in the response (fallback to False)
             if response.get("result", False) in NULL_RESPONSES:
                 apply_null_result_formatters(null_result_formatters, response, params)
             return response.get("result")
 
-        # Response from eth_subscription includes response["params"]["result"]
-        elif (
-            response.get("method") == "eth_subscription"
-            and response.get("params") is not None
-            and response["params"].get("subscription") is not None
-            and response["params"].get("result") is not None
-        ):
+        # response from eth_subscription includes response["params"]["result"]
+        elif is_subscription_response:
             return {
                 "subscription": response["params"]["subscription"],
                 "result": response["params"]["result"],
             }
 
-        # Any other response type raises BadResponseFormat
-        else:
-            _raise_bad_response_format(response)
-
     def request_blocking(
         self,
         method: Union[RPCEndpoint, Callable[..., RPCEndpoint]],

web3/middleware/filter.py

@@ -589,6 +589,10 @@ SyncFilter = Union[RequestLogs, RequestBlocks]
 AsyncFilter = Union[AsyncRequestLogs, AsyncRequestBlocks]
 
 
+def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
+    return {"jsonrpc": "2.0", "id": -1, "result": filter_id}
+
+
 class LocalFilterMiddleware(Web3Middleware):
     def __init__(self, w3: Union["Web3", "AsyncWeb3"]):
         self.filters: Dict[str, SyncFilter] = {}
@@ -615,7 +619,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -626,12 +630,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": next(_filter.filter_changes)}
+                    return _simulate_rpc_response_with_result(
+                        next(_filter.filter_changes)  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:
@@ -663,7 +671,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.async_filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -674,12 +682,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.async_filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": await _filter.filter_changes.__anext__()}
+                    return _simulate_rpc_response_with_result(
+                        await _filter.filter_changes.__anext__()  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": await _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        await _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:

web3/middleware/signing.py

@@ -182,7 +182,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
@@ -211,7 +211,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),

web3/providers/eth_tester/defaults.py

@@ -21,7 +21,6 @@ from eth_tester.exceptions import (
     FilterNotFound,
     TransactionFailed,
     TransactionNotFound,
-    ValidationError,
 )
 from eth_typing import (
     HexAddress,
@@ -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

@@ -7,6 +7,7 @@ from typing import (
     Literal,
     Optional,
     Union,
+    cast,
 )
 
 from eth_abi import (
@@ -59,6 +60,7 @@ if TYPE_CHECKING:
 
 
 class AsyncEthereumTesterProvider(AsyncBaseProvider):
+    _current_request_id = 0
     _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
@@ -99,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,
@@ -173,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(
@@ -197,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
@@ -209,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:
@@ -230,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

@@ -110,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,
 )
 
 
@@ -285,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/rpc/async_rpc.py

@@ -123,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

@@ -130,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/tools/benchmark/node.py

@@ -24,10 +24,7 @@ from web3.tools.benchmark.utils import (
     kill_proc_gracefully,
 )
 
-GETH_FIXTURE_ZIP = "geth-1.13.11-fixture.zip"
-
-# use same coinbase value as in `web3.py/tests/integration/generate_fixtures/common.py`
-COINBASE = "0xdc544d1aa88ff8bbd2f2aec754b1f1e99e1812fd"
+GETH_FIXTURE_ZIP = "geth-1.13.14-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/types.py

@@ -295,7 +295,7 @@ RPCId = Optional[Union[int, str]]
 
 
 class RPCResponse(TypedDict, total=False):
-    error: Union[RPCError, str]
+    error: RPCError
     id: RPCId
     jsonrpc: Literal["2.0"]
     result: Any

{web3-7.0.0b4.dist-info → web3-7.0.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b4
+Version: 7.0.0b5
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp >=3.7.4.post0
 Requires-Dist: eth-abi >=5.0.1
-Requires-Dist: eth-account >=0.12.0
+Requires-Dist: eth-account >=0.12.2
 Requires-Dist: eth-hash[pycryptodome] >=0.5.1
 Requires-Dist: eth-typing >=4.0.0
 Requires-Dist: eth-utils >=4.0.0