coerce accessList storageKeys to HexStr, not HexBytes, fix no_default_exceptions test

Author: pacrob

docs/web3.eth.rst

@@ -960,17 +960,17 @@ The following methods are available on the ``web3.eth`` namespace.
         ...     "pending",
         ... )
         AttributeDict({
-            'accessList': [
+            "accessList": [
                 AttributeDict({
-                    'address': '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
-                    'storageKeys': [
-                        HexBytes('0x0000000000000000000000000000000000000000000000000000000000000003'),
-                        HexBytes('0x0000000000000000000000000000000000000000000000000000000000000007'),
+                    "address": "0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe",
+                    "storageKeys": [
+                        "0x0000000000000000000000000000000000000000000000000000000000000003",
+                        "0x0000000000000000000000000000000000000000000000000000000000000007",
                     ]
                 }),
                 AttributeDict({
-                    'address': '0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413',
-                    'storageKeys': []
+                    "address": "0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413",
+                    "storageKeys": []
                 }),
             ],
             "gasUsed": 21000

newsfragments/3434.breaking.rst

@@ -0,0 +1 @@
+Format entries in ``accessList`` ``storageKeys`` to be ``HexStr`` instead of ``HexBytes``

tests/core/eth-module/test_transactions.py

@@ -318,12 +318,8 @@ def test_get_transaction_formatters(w3, request_mocker):
                     {
                         "address": checksummed_addr,
                         "storageKeys": [
-                            HexBytes(
-                                "0x0000000000000000000000000000000000000000000000000000000000000032"  # noqa: E501
-                            ),
-                            HexBytes(
-                                "0x0000000000000000000000000000000000000000000000000000000000000036"  # noqa: E501
-                            ),
+                            "0x0000000000000000000000000000000000000000000000000000000000000032",  # noqa: E501
+                            "0x0000000000000000000000000000000000000000000000000000000000000036",  # noqa: E501
                         ],
                     }
                 ),

tests/core/test_library_files.py

@@ -1,6 +1,6 @@
 import os
 
-WEB3_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "web3")
+WEB3_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../..", "web3")
 DEFAULT_EXCEPTIONS = (
     AssertionError,
     ValueError,

tests/core/utilities/test_method_formatters.py

@@ -1,14 +1,20 @@
 import pytest
 
+from eth_typing import (
+    HexStr,
+)
+
 from web3._utils.method_formatters import (
     get_error_formatters,
     raise_contract_logic_error_on_revert,
+    storage_key_to_hexstr,
 )
 from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
     ContractLogicError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCResponse,
@@ -192,3 +198,41 @@ def test_get_error_formatters() -> None:
     with pytest.raises(ContractLogicError):
         formatters(REVERT_WITHOUT_MSG)
     assert formatters(OTHER_ERROR) == OTHER_ERROR
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_output",
+    [
+        ("0x" + "a" * 64, HexStr("0x" + "a" * 64)),
+        ("a" * 64, HexStr("0x" + "a" * 64)),
+        ("0x" + "a" * 63, Web3ValueError),
+        ("a" * 63, Web3ValueError),
+        (b"a" * 32, HexStr("0x" + "61" * 32)),
+        (b"a" * 31, Web3ValueError),
+        (b"a" * 33, Web3ValueError),
+        (
+            7719472615821079694904732333912527190217998977709370935963838933860875309329,  # noqa: E501
+            HexStr("0x" + "1" * 64),
+        ),
+        (3567, Web3ValueError),
+        (3.14, Web3ValueError),
+    ],
+    ids=[
+        "valid-0x-hex-string",
+        "valid-no-0x-hex-string",
+        "invalid-0x-hex-string",
+        "invalid-no-0x-hex-string",
+        "valid-32-byte-value",
+        "invalid-31-byte-value",
+        "invalid-33-byte-value",
+        "valid-integer",
+        "invalid-integer",
+        "invalid-float",
+    ],
+)
+def test_storage_key_to_hexstr(input_value, expected_output):
+    if isinstance(expected_output, type) and issubclass(expected_output, Exception):
+        with pytest.raises(expected_output):
+            storage_key_to_hexstr(input_value)
+    else:
+        assert storage_key_to_hexstr(input_value) == expected_output

web3/_utils/method_formatters.py

@@ -187,10 +187,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 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),
     }
 )
 

web3/_utils/module_testing/eth_module.py

@@ -1210,7 +1210,7 @@ async def test_eth_create_access_list(
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict
@@ -2786,7 +2786,7 @@ def test_eth_create_access_list(
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict

web3/providers/persistent/persistent.py

@@ -23,6 +23,7 @@
     ProviderConnectionError,
     TaskNotRunning,
     TimeExhausted,
+    Web3AttributeError,
 )
 from web3.providers.async_base import (
     AsyncJSONBaseProvider,
@@ -71,7 +72,7 @@ def get_endpoint_uri_or_ipc_path(self) -> str:
         elif hasattr(self, "ipc_path"):
             return str(self.ipc_path)
         else:
-            raise AttributeError(
+            raise Web3AttributeError(
                 "`PersistentConnectionProvider` must have either `endpoint_uri` or "
                 "`ipc_path` attribute."
             )