web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/_utils/method_formatters.py

@@ -9,6 +9,7 @@ from typing import (
     Iterable,
     NoReturn,
     Tuple,
+    TypeVar,
     Union,
     cast,
 )
@@ -32,8 +33,6 @@ from eth_utils.curried import (
     is_integer,
     is_null,
     is_string,
-    remove_0x_prefix,
-    text_if_str,
     to_checksum_address,
     to_list,
     to_tuple,
@@ -52,10 +51,6 @@ from hexbytes import (
 from web3._utils.abi import (
     is_length,
 )
-from web3._utils.encoding import (
-    hexstr_if_str,
-    to_hex,
-)
 from web3._utils.error_formatters_utils import (
     raise_contract_logic_error_on_revert,
     raise_transaction_indexing_error_if_indexing,
@@ -99,6 +94,8 @@ from web3.datastructures import (
 from web3.exceptions import (
     BlockNotFound,
     TransactionNotFound,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     BlockIdentifier,
@@ -115,6 +112,8 @@ if TYPE_CHECKING:
     from web3.eth import Eth  # noqa: F401
     from web3.module import Module  # noqa: F401
 
+TValue = TypeVar("TValue")
+
 
 def bytes_to_ascii(value: bytes) -> str:
     return codecs.decode(value, "ascii")
@@ -136,7 +135,7 @@ def to_hexbytes(
     if isinstance(val, (str, int, bytes)):
         result = HexBytes(val)
     else:
-        raise TypeError(f"Cannot convert {val!r} to HexBytes")
+        raise Web3TypeError(f"Cannot convert {val!r} to HexBytes")
 
     extra_bytes = len(result) - num_bytes
     if extra_bytes == 0 or (variable_length and extra_bytes < 0):
@@ -144,7 +143,7 @@ def to_hexbytes(
     elif all(byte == 0 for byte in result[:extra_bytes]):
         return HexBytes(result[extra_bytes:])
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"The value {result!r} is {len(result)} bytes, but should be {num_bytes}"
         )
 
@@ -177,9 +176,9 @@ def type_aware_apply_formatters_to_dict_keys_and_values(
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
-    formatted_dict = dict(
-        (key_formatters(k), value_formatters(v)) for k, v in dict_like_object.items()
-    )
+    formatted_dict = {
+        key_formatters(k): value_formatters(v) for k, v in dict_like_object.items()
+    }
     return (
         AttributeDict.recursive(formatted_dict)
         if is_attrdict(dict_like_object)
@@ -191,10 +190,28 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     return to_list(apply_formatter_to_array(formatter))
 
 
+def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
+    if not isinstance(value, (bytes, int, str)):
+        raise Web3ValueError(
+            f"Storage key must be one of bytes, int, str, got {type(value)}"
+        )
+    if isinstance(value, str):
+        if value.startswith("0x") and len(value) == 66:
+            return HexStr(value)
+        elif len(value) == 64:
+            return HexStr(f"0x{value}")
+    elif isinstance(value, bytes):
+        if len(value) == 32:
+            return cast(HexStr, HexBytes(value).to_0x_hex())
+    elif isinstance(value, int):
+        return storage_key_to_hexstr(hex(value))
+    raise Web3ValueError(f"Storage key must be a 32-byte value, got {value!r}")
+
+
 ACCESS_LIST_FORMATTER = type_aware_apply_formatters_to_dict(
     {
         "address": to_checksum_address,
-        "storageKeys": apply_list_to_array_formatter(to_hexbytes(64)),
+        "storageKeys": apply_list_to_array_formatter(storage_key_to_hexstr),
     }
 )
 
@@ -233,6 +250,10 @@ TRANSACTION_RESULT_FORMATTERS = {
     ),
     "input": HexBytes,
     "data": HexBytes,  # Nethermind, for example, returns both `input` and `data`
+    "maxFeePerBlobGas": to_integer_if_hex,
+    "blobVersionedHashes": apply_formatter_if(
+        is_not_null, apply_formatter_to_array(to_hexbytes(32))
+    ),
 }
 
 
@@ -281,6 +302,8 @@ RECEIPT_FORMATTERS = {
     "to": apply_formatter_if(is_address, to_checksum_address),
     "effectiveGasPrice": to_integer_if_hex,
     "type": to_integer_if_hex,
+    "blobGasPrice": to_integer_if_hex,
+    "blobGasUsed": to_integer_if_hex,
 }
 
 
@@ -404,8 +427,8 @@ ACCOUNT_PROOF_FORMATTERS = {
 proof_formatter = type_aware_apply_formatters_to_dict(ACCOUNT_PROOF_FORMATTERS)
 
 FILTER_PARAMS_FORMATTERS = {
-    "fromBlock": apply_formatter_if(is_integer, integer_to_hex),
-    "toBlock": apply_formatter_if(is_integer, integer_to_hex),
+    "fromBlock": to_hex_if_integer,
+    "toBlock": to_hex_if_integer,
 }
 
 
@@ -419,7 +442,22 @@ filter_result_formatter = apply_one_of_formatters(
     )
 )
 
+ACCESS_LIST_REQUEST_FORMATTER = type_aware_apply_formatters_to_dict(
+    {
+        "accessList": apply_formatter_if(
+            is_not_null,
+            apply_list_to_array_formatter(
+                apply_formatters_to_dict(
+                    {
+                        "storageKeys": apply_list_to_array_formatter(to_hex_if_bytes),
+                    }
+                )
+            ),
+        ),
+    }
+)
 transaction_param_formatter = compose(
+    ACCESS_LIST_REQUEST_FORMATTER,
     remove_key_if("to", lambda txn: txn["to"] in {"", b"", None}),
     remove_key_if("gasPrice", lambda txn: txn["gasPrice"] in {"", b"", None}),
 )
@@ -516,6 +554,7 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     ),
     RPC.eth_getBalance: apply_formatter_at_index(to_hex_if_integer, 1),
     RPC.eth_getBlockByNumber: apply_formatter_at_index(to_hex_if_integer, 0),
+    RPC.eth_getBlockReceipts: apply_formatter_at_index(to_hex_if_integer, 0),
     RPC.eth_getBlockTransactionCountByNumber: apply_formatter_at_index(
         to_hex_if_integer,
         0,
@@ -559,16 +598,6 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_sendTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_signTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_getProof: apply_formatter_at_index(to_hex_if_integer, 2),
-    # personal
-    RPC.personal_importRawKey: apply_formatter_at_index(
-        compose(remove_0x_prefix, hexstr_if_str(to_hex)),
-        0,
-    ),
-    RPC.personal_sign: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_ecRecover: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_sendTransaction: apply_formatter_at_index(
-        transaction_param_formatter, 0
-    ),
     # Snapshot and Revert
     RPC.evm_revert: apply_formatter_at_index(integer_to_hex, 0),
     # tracing
@@ -581,6 +610,102 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
 }
 
 # --- Result Formatters --- #
+# -- debug -- #
+DEBUG_CALLTRACE_LOG_ENTRY_FORMATTERS = apply_formatter_if(
+    is_not_null,
+    type_aware_apply_formatters_to_dict(
+        {
+            "address": to_checksum_address,
+            "topics": apply_list_to_array_formatter(to_hexbytes(32)),
+            "data": HexBytes,
+            "position": to_integer_if_hex,
+        }
+    ),
+)
+
+
+debug_calltrace_log_list_result_formatter: Callable[
+    [Formatters], Any
+] = apply_formatter_to_array(DEBUG_CALLTRACE_LOG_ENTRY_FORMATTERS)
+
+
+PRETRACE_INNER_FORMATTERS = {
+    "balance": to_integer_if_hex,
+    "nonce": to_integer_if_hex,
+}
+
+
+def has_pretrace_keys(val: Any) -> bool:
+    if isinstance(val, dict) or isinstance(val, AttributeDict):
+        return (
+            val.get("balance")
+            or val.get("nonce")
+            or val.get("code")
+            or val.get("storage")
+        )
+    return False
+
+
+@curry
+def pretrace_formatter(
+    resp: Union[AttributeDict[str, Any], Dict[str, Any]],
+) -> Union[ReadableAttributeDict[str, Any], Dict[str, Any]]:
+    return type_aware_apply_formatters_to_dict_keys_and_values(
+        apply_formatter_if(is_address, to_checksum_address),
+        apply_formatter_if(
+            has_pretrace_keys,
+            type_aware_apply_formatters_to_dict(PRETRACE_INNER_FORMATTERS),
+        ),
+        resp,
+    )
+
+
+DEBUG_PRESTATE_DIFFMODE_FORMATTERS = {
+    "pre": pretrace_formatter,
+    "post": pretrace_formatter,
+}
+
+
+DEBUG_CALLTRACE_FORMATTERS = {
+    "from": to_checksum_address,
+    "to": to_checksum_address,
+    "value": to_integer_if_hex,
+    "gas": to_integer_if_hex,
+    "gasUsed": to_integer_if_hex,
+    "input": HexBytes,
+    "output": HexBytes,
+    "calls": lambda calls: debug_calltrace_list_result_formatter(calls),
+    "logs": debug_calltrace_log_list_result_formatter,
+}
+
+
+OPCODE_TRACE_FORMATTERS = {
+    "pc": to_integer_if_hex,
+    "gas": to_integer_if_hex,
+    "gasCost": to_integer_if_hex,
+    "refund": to_integer_if_hex,
+}
+
+
+DEBUG_TRACE_FORMATTERS = {
+    **DEBUG_CALLTRACE_FORMATTERS,
+    **OPCODE_TRACE_FORMATTERS,
+    **DEBUG_PRESTATE_DIFFMODE_FORMATTERS,
+}
+
+
+trace_result_formatters = type_aware_apply_formatters_to_dict(DEBUG_TRACE_FORMATTERS)
+
+
+debug_calltrace_result_formatter = type_aware_apply_formatters_to_dict(
+    DEBUG_CALLTRACE_FORMATTERS
+)
+
+
+debug_calltrace_list_result_formatter: Callable[
+    [Formatters], Any
+] = apply_formatter_to_array(debug_calltrace_result_formatter)
+
 
 # -- tracing -- #
 
@@ -620,7 +745,7 @@ TRACE_RESULT_FORMATTERS = apply_formatter_if(
 )
 
 # result formatters for the trace field
-TRACE_FORMATTERS = apply_formatter_if(
+TRACE_FORMATTERS: Callable[[TValue], Union[Any, TValue]] = apply_formatter_if(
     is_not_null,
     type_aware_apply_formatters_to_dict(
         {
@@ -711,9 +836,9 @@ def subscription_formatter(value: Any) -> Union[HexBytes, HexStr, Dict[str, Any]
 PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     # Eth
     RPC.eth_accounts: apply_list_to_array_formatter(to_checksum_address),
+    RPC.eth_blobBaseFee: to_integer_if_hex,
     RPC.eth_blockNumber: to_integer_if_hex,
     RPC.eth_chainId: to_integer_if_hex,
-    RPC.eth_coinbase: to_checksum_address,
     RPC.eth_call: HexBytes,
     RPC.eth_createAccessList: ACCESS_LIST_RESPONSE_FORMATTER,
     RPC.eth_estimateGas: to_integer_if_hex,
@@ -723,6 +848,7 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBalance: to_integer_if_hex,
     RPC.eth_getBlockByHash: apply_formatter_if(is_not_null, block_formatter),
     RPC.eth_getBlockByNumber: apply_formatter_if(is_not_null, block_formatter),
+    RPC.eth_getBlockReceipts: apply_formatter_to_array(receipt_formatter),
     RPC.eth_getBlockTransactionCountByHash: to_integer_if_hex,
     RPC.eth_getBlockTransactionCountByNumber: to_integer_if_hex,
     RPC.eth_getCode: HexBytes,
@@ -752,7 +878,6 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     ),
     RPC.eth_getUncleCountByBlockHash: to_integer_if_hex,
     RPC.eth_getUncleCountByBlockNumber: to_integer_if_hex,
-    RPC.eth_hashrate: to_integer_if_hex,
     RPC.eth_protocolVersion: compose(
         apply_formatter_if(is_0x_prefixed, to_integer_if_hex),
         apply_formatter_if(is_integer, str),
@@ -763,13 +888,6 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_signTransaction: apply_formatter_if(is_not_null, signed_tx_formatter),
     RPC.eth_signTypedData: HexBytes,
     RPC.eth_syncing: apply_formatter_if(is_not_false, syncing_formatter),
-    # personal
-    RPC.personal_importRawKey: to_checksum_address,
-    RPC.personal_listAccounts: apply_list_to_array_formatter(to_checksum_address),
-    RPC.personal_listWallets: apply_list_to_array_formatter(geth_wallets_formatter),
-    RPC.personal_newAccount: to_checksum_address,
-    RPC.personal_sendTransaction: to_hexbytes(32),
-    RPC.personal_signTypedData: HexBytes,
     # Transaction Pool
     RPC.txpool_content: transaction_pool_content_formatter,
     RPC.txpool_inspect: transaction_pool_inspect_formatter,
@@ -777,6 +895,14 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.evm_snapshot: hex_to_integer,
     # Net
     RPC.net_peerCount: to_integer_if_hex,
+    # Debug
+    RPC.debug_traceTransaction: apply_formatter_if(
+        is_not_null,
+        compose(
+            pretrace_formatter,
+            trace_result_formatters,
+        ),
+    ),
     # tracing
     RPC.trace_block: trace_list_result_formatter,
     RPC.trace_call: common_tracing_result_formatter,
@@ -900,6 +1026,7 @@ def raise_transaction_not_found_with_index(
 NULL_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBlockByHash: raise_block_not_found,
     RPC.eth_getBlockByNumber: raise_block_not_found,
+    RPC.eth_getBlockReceipts: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByHash: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByNumber: raise_block_not_found,
     RPC.eth_getUncleCountByBlockHash: raise_block_not_found,

web3/_utils/module.py

@@ -13,6 +13,7 @@ from typing import (
 )
 
 from web3.exceptions import (
+    Web3AttributeError,
     Web3ValidationError,
 )
 from web3.module import (
@@ -50,7 +51,7 @@ def attach_modules(
         module_class = module_info[0] if module_info_is_list_like else module_info
 
         if hasattr(parent_module, module_name):
-            raise AttributeError(
+            raise Web3AttributeError(
                 f"Cannot set {parent_module} module named '{module_name}'. "
                 " The web3 object already has an attribute with that name"
             )

web3/_utils/module_testing/__init__.py

@@ -5,8 +5,9 @@ from .eth_module import (
 from .go_ethereum_admin_module import (
     GoEthereumAdminModuleTest,
 )
-from .go_ethereum_personal_module import (
-    GoEthereumPersonalModuleTest,
+from .go_ethereum_debug_module import (
+    GoEthereumAsyncDebugModuleTest,
+    GoEthereumDebugModuleTest,
 )
 from .go_ethereum_txpool_module import (
     GoEthereumAsyncTxPoolModuleTest,