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

web3/_utils/module_testing/eth_module.py

@@ -139,7 +139,10 @@ RPC_ACCESS_LIST = [
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch  # noqa: F401
 
-    from web3.contract import Contract  # noqa: F401
+    from web3.contract import (  # noqa: F401
+        AsyncContract,
+        Contract,
+    )
     from web3.main import (  # noqa: F401
         AsyncWeb3,
         Web3,
@@ -147,7 +150,8 @@ if TYPE_CHECKING:
 
 
 def abi_encoded_offchain_lookup_contract_address(
-    w3: Union["Web3", "AsyncWeb3"], offchain_lookup_contract: "Contract"
+    w3: Union["Web3", "AsyncWeb3"],
+    offchain_lookup_contract: Union["Contract", "AsyncContract"],
 ) -> HexAddress:
     return HexAddress(
         remove_0x_prefix(
@@ -834,7 +838,7 @@ class AsyncEthModuleTest:
     async def test_eth_estimate_gas_with_override_param_type_check(
         self,
         async_w3: "AsyncWeb3",
-        async_math_contract: "Contract",
+        async_math_contract: "AsyncContract",
         params: StateOverrideParams,
     ) -> None:
         txn_params: TxParams = {"from": await async_w3.eth.coinbase}
@@ -977,6 +981,39 @@ class AsyncEthModuleTest:
         assert block is not None
         assert isinstance(block["number"], int)
 
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_hash(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts(async_empty_block["hash"])
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_not_found(self, async_w3: "AsyncWeb3") -> None:
+        with pytest.raises(BlockNotFound):
+            await async_w3.eth.get_block_receipts(UNKNOWN_HASH)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_with_integer(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts(async_empty_block["number"])
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_safe(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts("safe")
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_finalized(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts("finalized")
+        assert isinstance(receipts, list)
+
     @pytest.mark.asyncio
     async def test_eth_get_block_by_number_full_transactions(
         self, async_w3: "AsyncWeb3", async_block_with_txn: BlockData
@@ -1067,9 +1104,7 @@ class AsyncEthModuleTest:
                 f"{unknown_identifier}"
             ),
         ):
-            await async_w3.eth.get_raw_transaction_by_block(
-                unknown_identifier, 0  # type: ignore
-            )
+            await async_w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)
 
     @pytest.mark.asyncio
     async def test_eth_get_balance(self, async_w3: "AsyncWeb3") -> None:
@@ -1097,7 +1132,7 @@ class AsyncEthModuleTest:
     async def test_eth_get_code_invalid_address(
         self,
         async_w3: "AsyncWeb3",
-        async_math_contract: "Contract",
+        async_math_contract: "AsyncContract",
     ) -> None:
         with pytest.raises(InvalidAddress):
             await async_w3.eth.get_code(
@@ -1106,7 +1141,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_get_code_with_block_identifier(
-        self, async_w3: "AsyncWeb3", async_emitter_contract: "Contract"
+        self, async_w3: "AsyncWeb3", async_emitter_contract: "AsyncContract"
     ) -> None:
         block_id = await async_w3.eth.block_number
         code = await async_w3.eth.get_code(async_emitter_contract.address, block_id)
@@ -1118,28 +1153,15 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_unlocked_account_dual_type: ChecksumAddress,
-        async_math_contract: "Contract",
+        async_math_contract: "AsyncContract",
     ) -> None:
-        # Initialize transaction for gas estimation
-        txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "value": Wei(1),
-            "gas": 21000,
-        }
-        txn = async_math_contract._prepare_transaction(
-            fn_name="incrementCounter",
-            fn_args=[1],
-            transaction=txn_params,
+        # build txn
+        txn = await async_math_contract.functions.incrementCounter(1).build_transaction(
+            {"from": async_unlocked_account_dual_type}
         )
 
-        # create access list using data from transaction
-        response = await async_w3.eth.create_access_list(
-            {
-                "from": async_unlocked_account_dual_type,
-                "to": async_math_contract.address,
-                "data": txn["data"],
-            }
-        )
+        # create access list
+        response = await async_w3.eth.create_access_list(txn)
 
         assert is_dict(response)
         access_list = response["accessList"]
@@ -1149,6 +1171,13 @@ class AsyncEthModuleTest:
         assert len(access_list[0]["storageKeys"][0]) == 32
         assert int(response["gasUsed"]) >= 0
 
+        # assert the result can be used directly in a transaction dict
+        txn["accessList"] = response["accessList"]
+        txn["gas"] = response["gasUsed"]
+
+        # send txn with access list
+        await async_w3.eth.send_transaction(txn)
+
     @pytest.mark.asyncio
     async def test_eth_get_transaction_count(
         self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
@@ -1161,7 +1190,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_call(
-        self, async_w3: "AsyncWeb3", async_math_contract: "Contract"
+        self, async_w3: "AsyncWeb3", async_math_contract: "AsyncContract"
     ) -> None:
         coinbase = await async_w3.eth.coinbase
         txn_params = async_math_contract._prepare_transaction(
@@ -1178,7 +1207,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_with_override_code(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
+        async_revert_contract: "AsyncContract",
     ) -> None:
         coinbase = await async_w3.eth.coinbase
         txn_params = async_revert_contract._prepare_transaction(
@@ -1234,7 +1263,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_with_override_param_type_check(
         self,
         async_w3: "AsyncWeb3",
-        async_math_contract: "Contract",
+        async_math_contract: "AsyncContract",
         params: StateOverrideParams,
     ) -> None:
         coinbase = await async_w3.eth.coinbase
@@ -1247,7 +1276,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_call_with_0_result(
-        self, async_w3: "AsyncWeb3", async_math_contract: "Contract"
+        self, async_w3: "AsyncWeb3", async_math_contract: "AsyncContract"
     ) -> None:
         coinbase = await async_w3.eth.coinbase
         txn_params = async_math_contract._prepare_transaction(
@@ -1264,7 +1293,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_with_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
+        async_revert_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
         txn_params = async_revert_contract._prepare_transaction(
@@ -1283,7 +1312,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_without_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
+        async_revert_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
         with pytest.raises(ContractLogicError, match="execution reverted"):
@@ -1300,10 +1329,10 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_custom_error_with_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
+        async_revert_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(
+        data = async_revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = async_revert_contract._prepare_transaction(
@@ -1320,10 +1349,10 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_custom_error_without_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
+        async_revert_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(fn_name="Unauthorized")
+        data = async_revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = async_revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -1352,7 +1381,7 @@ class AsyncEthModuleTest:
     async def test_contract_panic_errors(
         self,
         async_w3: "AsyncWeb3",
-        async_panic_errors_contract: "Contract",
+        async_panic_errors_contract: "AsyncContract",
         panic_error: str,
         params: List[Any],
     ) -> None:
@@ -1369,7 +1398,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
@@ -1395,7 +1424,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_raises_when_ccip_read_is_disabled(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
     ) -> None:
         return_data = (
             OFFCHAIN_LOOKUP_4BYTE_DATA
@@ -1433,7 +1462,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_call_flag_overrides_provider_flag(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
@@ -1461,7 +1490,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_raises_if_max_redirects_is_less_than_4(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         max_redirects: int,
     ) -> None:
         default_max_redirects = async_w3.provider.ccip_read_max_redirects
@@ -1478,7 +1507,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_raises_for_improperly_formatted_rest_request_response(  # noqa: E501
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
@@ -1502,7 +1531,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_tries_next_url_for_non_4xx_error_status_and_tests_POST(  # noqa: E501
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
         status_code_non_4xx_error: int,
@@ -1540,7 +1569,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_calls_raise_for_status_for_4xx_status_code(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
@@ -1563,7 +1592,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_raises_when_all_supplied_urls_fail(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
     ) -> None:
         # GET and POST requests should fail since responses are not mocked
         with pytest.raises(
@@ -1577,7 +1606,7 @@ class AsyncEthModuleTest:
     async def test_eth_call_continuous_offchain_lookup_raises_with_too_many_requests(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
+        async_offchain_lookup_contract: "AsyncContract",
         async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
@@ -1652,7 +1681,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_block_with_txn_with_log: BlockData,
-        async_emitter_contract: "Contract",
+        async_emitter_contract: "AsyncContract",
         txn_hash_with_log: HexStr,
     ) -> None:
         receipt = await async_w3.eth.wait_for_transaction_receipt(txn_hash_with_log)
@@ -1719,7 +1748,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_block_with_txn_with_log: BlockData,
-        async_emitter_contract: "Contract",
+        async_emitter_contract: "AsyncContract",
         txn_hash_with_log: HexStr,
     ) -> None:
         receipt = await async_w3.eth.wait_for_transaction_receipt(txn_hash_with_log)
@@ -1744,7 +1773,7 @@ class AsyncEthModuleTest:
         accounts = await async_w3.eth.accounts
         assert is_list_like(accounts)
         assert len(accounts) != 0
-        assert all((is_checksum_address(account) for account in accounts))
+        assert all(is_checksum_address(account) for account in accounts)
         assert await async_w3.eth.coinbase in accounts
 
     @pytest.mark.asyncio
@@ -1917,7 +1946,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_eth_get_storage_at(
-        self, async_w3: "AsyncWeb3", async_storage_contract: "Contract"
+        self, async_w3: "AsyncWeb3", async_storage_contract: "AsyncContract"
     ) -> None:
         async_storage_contract_address = async_storage_contract.address
 
@@ -1945,7 +1974,7 @@ class AsyncEthModuleTest:
     @pytest.mark.asyncio
     @pytest.mark.xfail
     async def test_async_eth_get_storage_at_ens_name(
-        self, async_w3: "AsyncWeb3", async_storage_contract: "Contract"
+        self, async_w3: "AsyncWeb3", async_storage_contract: "AsyncContract"
     ) -> None:
         with ens_addresses(async_w3, {"storage.eth": async_storage_contract.address}):
             storage = await async_w3.eth.get_storage_at(ENS("storage.eth"), 1)
@@ -2503,7 +2532,7 @@ class EthModuleTest:
         accounts = w3.eth.accounts
         assert is_list_like(accounts)
         assert len(accounts) != 0
-        assert all((is_checksum_address(account) for account in accounts))
+        assert all(is_checksum_address(account) for account in accounts)
         assert w3.eth.coinbase in accounts
 
     def test_eth_block_number(self, w3: "Web3") -> None:
@@ -2702,24 +2731,14 @@ class EthModuleTest:
         unlocked_account_dual_type: ChecksumAddress,
         math_contract: "Contract",
     ) -> None:
-        # Initialize transaction for gas estimation
-        txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "value": Wei(1),
-            "gas": 21000,
-        }
-
-        txn = math_contract.functions.incrementCounter(1).build_transaction(txn_params)
-
-        # create access list using data from transaction
-        response = w3.eth.create_access_list(
-            {
-                "from": unlocked_account_dual_type,
-                "to": math_contract.address,
-                "data": txn["data"],
-            }
+        # build txn
+        txn = math_contract.functions.incrementCounter(1).build_transaction(
+            {"from": unlocked_account_dual_type}
         )
 
+        # create access list
+        response = w3.eth.create_access_list(txn)
+
         assert is_dict(response)
         access_list = response["accessList"]
         assert len(access_list) > 0
@@ -2728,6 +2747,13 @@ class EthModuleTest:
         assert len(access_list[0]["storageKeys"][0]) == 32
         assert int(response["gasUsed"]) >= 0
 
+        # assert the result can be used directly in a transaction dict
+        txn["accessList"] = response["accessList"]
+        txn["gas"] = response["gasUsed"]
+
+        # send txn with access list
+        w3.eth.send_transaction(txn)
+
     def test_eth_sign(
         self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
     ) -> None:
@@ -3755,7 +3781,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
+        data = revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = revert_contract._prepare_transaction(
@@ -3775,7 +3801,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -4064,7 +4090,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
+        data = revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = revert_contract._prepare_transaction(
@@ -4084,7 +4110,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -4222,7 +4248,35 @@ class EthModuleTest:
     ) -> None:
         block = w3.eth.get_block(block_with_txn["number"], True)
         transaction = block["transactions"][0]
-        assert transaction["hash"] == block_with_txn["transactions"][0]  # type: ignore
+        assert transaction["hash"] == block_with_txn["transactions"][0]
+
+    def test_eth_getBlockReceipts_hash(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts(empty_block["hash"])
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_not_found(self, w3: "Web3") -> None:
+        with pytest.raises(BlockNotFound):
+            w3.eth.get_block_receipts(UNKNOWN_HASH)
+
+    def test_eth_getBlockReceipts_with_integer(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts(empty_block["number"])
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_safe(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts("safe")
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_finalized(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts("finalized")
+        assert isinstance(receipts, list)
 
     def test_eth_getTransactionByHash(self, w3: "Web3", mined_txn_hash: HexStr) -> None:
         transaction = w3.eth.get_transaction(mined_txn_hash)
@@ -4653,7 +4707,7 @@ class EthModuleTest:
                 f"{unknown_identifier}"
             ),
         ):
-            w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)  # type: ignore
+            w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)
 
     def test_default_account(
         self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress

web3/_utils/module_testing/go_ethereum_personal_module.py

@@ -62,7 +62,7 @@ class GoEthereumPersonalModuleTest:
         accounts = w3.geth.personal.list_accounts()
         assert is_list_like(accounts)
         assert len(accounts) > 0
-        assert all((is_checksum_address(item) for item in accounts))
+        assert all(is_checksum_address(item) for item in accounts)
 
     def test_personal_list_wallets(self, w3: "Web3") -> None:
         wallets = w3.geth.personal.list_wallets()

web3/_utils/module_testing/module_testing_utils.py

@@ -7,6 +7,7 @@ from typing import (
     Collection,
     Dict,
     Generator,
+    Literal,
     Sequence,
     Union,
 )
@@ -28,9 +29,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3._utils.request import (
     async_cache_and_return_session,
     cache_and_return_session,

web3/_utils/module_testing/utils.py

@@ -36,6 +36,7 @@ class RequestMocker:
     via a ``request_mocker`` fixture defined within the appropriate context.
 
     Example:
+    -------
 
         def test_my_w3(w3, request_mocker):
             assert w3.eth.block_number == 0
@@ -46,6 +47,7 @@ class RequestMocker:
             assert w3.eth.block_number == 0
 
     Example with async and a mocked response object:
+    -----------------------------------------------
 
         async def test_my_w3(async_w3, request_mocker):
             def _iter_responses():
@@ -77,6 +79,7 @@ class RequestMocker:
 
     If a method name is not present in any of the dicts above, the request is made as
     usual.
+
     """
 
     def __init__(
@@ -90,12 +93,13 @@ class RequestMocker:
         self.mock_results = mock_results or {}
         self.mock_errors = mock_errors or {}
         self.mock_responses = mock_responses or {}
-        self._make_request: Union["AsyncMakeRequestFn", "MakeRequestFn"] = (
-            w3.provider.make_request
-        )
+        self._make_request: Union[
+            "AsyncMakeRequestFn", "MakeRequestFn"
+        ] = w3.provider.make_request
 
     def __enter__(self) -> "Self":
-        setattr(self.w3.provider, "make_request", self._mock_request_handler)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._mock_request_handler  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with mocked make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -103,7 +107,8 @@ class RequestMocker:
 
     # define __exit__ with typing information
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        setattr(self.w3.provider, "make_request", self._make_request)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -163,13 +168,15 @@ class RequestMocker:
 
     # -- async -- #
     async def __aenter__(self) -> "Self":
-        setattr(self.w3.provider, "make_request", self._async_mock_request_handler)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._async_mock_request_handler  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with mocked make_request
         self.w3.provider._request_func_cache = (None, None)
         return self
 
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        setattr(self.w3.provider, "make_request", self._make_request)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 

web3/_utils/normalizers.py

@@ -60,6 +60,7 @@ from web3._utils.validation import (
 from web3.exceptions import (
     InvalidAddress,
     NameNotFound,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -151,7 +152,7 @@ def abi_bytes_to_hex(
 
     num_bytes = abi_type.sub
     if len(bytes_data) > num_bytes:
-        raise ValueError(
+        raise Web3ValueError(
             f"This value was expected to be at most {num_bytes} bytes, "
             f"but instead was {len(bytes_data)}: {data!r}"
         )
@@ -273,8 +274,7 @@ def normalize_address_no_ens(address: ChecksumAddress) -> ChecksumAddress:
 def normalize_bytecode(bytecode: bytes) -> HexBytes:
     if bytecode:
         bytecode = HexBytes(bytecode)
-    # type ignored b/c bytecode is converted to HexBytes above
-    return bytecode  # type: ignore
+    return bytecode
 
 
 # --- async -- #

web3/_utils/request.py

@@ -109,9 +109,9 @@ def get_response_from_post_request(
 
 
 def make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
+    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
 ) -> bytes:
-    response = get_response_from_post_request(endpoint_uri, data=data, *args, **kwargs)
+    response = get_response_from_post_request(endpoint_uri, data=data, **kwargs)
     response.raise_for_status()
     return response.content
 
@@ -236,10 +236,10 @@ async def async_get_response_from_post_request(
 
 
 async def async_make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
+    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
 ) -> bytes:
     response = await async_get_response_from_post_request(
-        endpoint_uri, data=data, *args, **kwargs
+        endpoint_uri, data=data, **kwargs
     )
     response.raise_for_status()
     return await response.read()

web3/_utils/rpc_abi.py

@@ -24,6 +24,9 @@ from eth_utils.toolz import (
 from web3._utils.abi import (
     map_abi_data,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.types import (
     RPCEndpoint,
 )
@@ -57,6 +60,7 @@ class RPC:
     eth_getBalance = RPCEndpoint("eth_getBalance")
     eth_getBlockByHash = RPCEndpoint("eth_getBlockByHash")
     eth_getBlockByNumber = RPCEndpoint("eth_getBlockByNumber")
+    eth_getBlockReceipts = RPCEndpoint("eth_getBlockReceipts")
     eth_getBlockTransactionCountByHash = RPCEndpoint(
         "eth_getBlockTransactionCountByHash"
     )
@@ -157,6 +161,7 @@ TRANSACTION_PARAMS_ABIS = {
     "from": "address",
     "gas": "uint",
     "gasPrice": "uint",
+    "maxFeePerBlobGas": "uint",
     "maxFeePerGas": "uint",
     "maxPriorityFeePerGas": "uint",
     "nonce": "uint",
@@ -245,6 +250,6 @@ def abi_request_formatters(
             single_dict_formatter = apply_abi_formatters_to_dict(normalizers, abi_types)
             yield method, apply_formatter_at_index(single_dict_formatter, 0)
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 f"ABI definitions must be a list or dictionary, got {abi_types!r}"
             )