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

web3/_utils/module_testing/eth_module.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import math
 import pytest
@@ -41,9 +42,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.empty import (
-    empty,
-)
 from web3._utils.ens import (
     ens_addresses,
 )
@@ -82,10 +80,13 @@ from web3.exceptions import (
     TooManyRequests,
     TransactionNotFound,
     TransactionTypeMismatch,
+    Web3RPCError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.middleware import (
     ExtraDataToPOAMiddleware,
+    SignAndSendRawMiddlewareBuilder,
 )
 from web3.types import (
     ENS,
@@ -110,7 +111,7 @@ UNKNOWN_HASH = HexStr(
 # "test offchain lookup" as an abi-encoded string
 OFFCHAIN_LOOKUP_TEST_DATA = "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001474657374206f6666636861696e206c6f6f6b7570000000000000000000000000"  # noqa: E501
 OFFCHAIN_LOOKUP_4BYTE_DATA = "0x556f1830"
-OFFCHAIN_LOOKUP_RETURN_DATA = "00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001c0da96d05a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002c68747470733a2f2f776562332e70792f676174657761792f7b73656e6465727d2f7b646174617d2e6a736f6e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002568747470733a2f2f776562332e70792f676174657761792f7b73656e6465727d2e6a736f6e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001474657374206f6666636861696e206c6f6f6b757000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001474657374206f6666636861696e206c6f6f6b7570000000000000000000000000"  # noqa: E501
+OFFCHAIN_LOOKUP_RETURN_DATA = "00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001a0da96d05a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002c68747470733a2f2f776562332e70792f676174657761792f7b73656e6465727d2f7b646174617d2e6a736f6e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001768747470733a2f2f776562332e70792f6761746577617900000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001474657374206f6666636861696e206c6f6f6b757000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001474657374206f6666636861696e206c6f6f6b7570000000000000000000000000"  # noqa: E501
 # "web3py" as an abi-encoded string
 WEB3PY_AS_HEXBYTES = "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000067765623370790000000000000000000000000000000000000000000000000000"  # noqa: E501
 
@@ -139,7 +140,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 +151,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(
@@ -175,11 +180,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_legacy(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": await async_w3.eth.gas_price,
@@ -195,11 +202,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_modify_transaction_legacy(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": async_w3.to_wei(
@@ -209,7 +218,7 @@ class AsyncEthModuleTest:
         txn_hash = await async_w3.eth.send_transaction(txn_params)
 
         modified_txn_hash = await async_w3.eth.modify_transaction(
-            txn_hash, gasPrice=(cast(int, txn_params["gasPrice"]) * 2), value=2
+            txn_hash, gasPrice=(cast(Wei, txn_params["gasPrice"] * 2)), value=Wei(2)
         )
         modified_txn = await async_w3.eth.get_transaction(modified_txn_hash)
 
@@ -225,11 +234,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_modify_transaction(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": async_w3.to_wei(1, "gwei"),
@@ -239,9 +250,9 @@ class AsyncEthModuleTest:
 
         modified_txn_hash = await async_w3.eth.modify_transaction(
             txn_hash,
-            value=2,
-            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"]) * 2),
-            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"]) * 2),
+            value=Wei(2),
+            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"] * 2)),
+            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"] * 2)),
         )
         modified_txn = await async_w3.eth.get_transaction(modified_txn_hash)
 
@@ -261,11 +272,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_eth_sign_transaction(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(2, "gwei"),
@@ -274,7 +287,7 @@ class AsyncEthModuleTest:
         }
         result = await async_w3.eth.sign_transaction(txn_params)
         signatory_account = async_w3.eth.account.recover_transaction(result["raw"])
-        assert async_unlocked_account == signatory_account
+        assert async_keyfile_account_address_dual_type == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -288,7 +301,7 @@ class AsyncEthModuleTest:
     async def test_eth_sign_typed_data(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
         async_skip_if_testrpc: Callable[["AsyncWeb3"], None],
     ) -> None:
         validJSONMessage = """
@@ -333,7 +346,7 @@ class AsyncEthModuleTest:
         async_skip_if_testrpc(async_w3)
         signature = HexBytes(
             await async_w3.eth.sign_typed_data(
-                async_unlocked_account_dual_type, json.loads(validJSONMessage)
+                async_keyfile_account_address_dual_type, json.loads(validJSONMessage)
             )
         )
         assert len(signature) == 32 + 32 + 1
@@ -342,7 +355,7 @@ class AsyncEthModuleTest:
     async def test_invalid_eth_sign_typed_data(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
         async_skip_if_testrpc: Callable[["AsyncWeb3"], None],
     ) -> None:
         async_skip_if_testrpc(async_w3)
@@ -386,20 +399,21 @@ class AsyncEthModuleTest:
             }
         """
         with pytest.raises(
-            ValueError,
+            Web3ValueError,
             match=r".*Expected 2 items for array type Person\[2\], got 1 items.*",
         ):
             await async_w3.eth.sign_typed_data(
-                async_unlocked_account_dual_type, json.loads(invalid_typed_message)
+                async_keyfile_account_address_dual_type,
+                json.loads(invalid_typed_message),
             )
 
     @pytest.mark.asyncio
     async def test_async_eth_sign_transaction_legacy(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": await async_w3.eth.gas_price,
@@ -407,7 +421,7 @@ class AsyncEthModuleTest:
         }
         result = await async_w3.eth.sign_transaction(txn_params)
         signatory_account = async_w3.eth.account.recover_transaction(result["raw"])
-        assert async_unlocked_account == signatory_account
+        assert async_keyfile_account_address == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -416,11 +430,11 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_eth_sign_transaction_hex_fees(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": hex(async_w3.to_wei(2, "gwei")),
@@ -429,7 +443,7 @@ class AsyncEthModuleTest:
         }
         result = await async_w3.eth.sign_transaction(txn_params)
         signatory_account = async_w3.eth.account.recover_transaction(result["raw"])
-        assert async_unlocked_account == signatory_account
+        assert async_keyfile_account_address == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -444,9 +458,11 @@ class AsyncEthModuleTest:
         reason="async name_to_address_middleware has not been implemented yet"
     )
     async def test_async_eth_sign_transaction_ens_names(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
-        with ens_addresses(async_w3, {"unlocked-account.eth": async_unlocked_account}):
+        with ens_addresses(
+            async_w3, {"unlocked-account.eth": async_keyfile_account_address}
+        ):
             txn_params: TxParams = {
                 "from": "unlocked-account.eth",
                 "to": "unlocked-account.eth",
@@ -458,8 +474,8 @@ class AsyncEthModuleTest:
             }
             result = await async_w3.eth.sign_transaction(txn_params)
             signatory_account = async_w3.eth.account.recover_transaction(result["raw"])
-            assert async_unlocked_account == signatory_account
-            assert result["tx"]["to"] == async_unlocked_account
+            assert async_keyfile_account_address == signatory_account
+            assert result["tx"]["to"] == async_keyfile_account_address
             assert result["tx"]["value"] == txn_params["value"]
             assert result["tx"]["gas"] == txn_params["gas"]
             assert result["tx"]["maxFeePerGas"] == txn_params["maxFeePerGas"]
@@ -471,16 +487,19 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(3, "gwei"),
             "maxPriorityFeePerGas": async_w3.to_wei(1, "gwei"),
         }
+
         txn_hash = await async_w3.eth.send_transaction(txn_params)
         txn = await async_w3.eth.get_transaction(txn_hash)
 
@@ -490,18 +509,21 @@ class AsyncEthModuleTest:
         assert txn["gas"] == 21000
         assert txn["maxFeePerGas"] == txn_params["maxFeePerGas"]
         assert txn["maxPriorityFeePerGas"] == txn_params["maxPriorityFeePerGas"]
-        assert txn["gasPrice"] == txn_params["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_default_fees(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
+
         txn_hash = await async_w3.eth.send_transaction(txn_params)
         txn = await async_w3.eth.get_transaction(txn_hash)
 
@@ -511,15 +533,17 @@ class AsyncEthModuleTest:
         assert txn["gas"] == 21000
         assert is_integer(txn["maxPriorityFeePerGas"])
         assert is_integer(txn["maxFeePerGas"])
-        assert txn["gasPrice"] == txn["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_hex_fees(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": hex(250 * 10**9),
@@ -537,11 +561,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_gas(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "maxFeePerGas": Wei(250 * 10**9),
             "maxPriorityFeePerGas": Wei(2 * 10**9),
@@ -556,11 +582,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_with_gas_price(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": Wei(1),
@@ -572,11 +600,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_priority_fee(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(250 * 10**9),
@@ -588,12 +618,14 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_max_fee(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         maxPriorityFeePerGas = async_w3.to_wei(2, "gwei")
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": maxPriorityFeePerGas,
@@ -611,11 +643,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_max_fee_less_than_tip(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(1 * 10**9),
@@ -628,14 +662,16 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_validation_middleware_chain_id_mismatch(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         wrong_chain_id = 1234567890
         actual_chain_id = await async_w3.eth.chain_id
 
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(2, "gwei"),
@@ -669,29 +705,54 @@ class AsyncEthModuleTest:
         async_w3.middleware_onion.remove("poa")
 
     @pytest.mark.asyncio
-    async def test_eth_send_raw_transaction(self, async_w3: "AsyncWeb3") -> None:
-        # private key 0x3c2ab4e8f17a7dea191b8c991522660126d681039509dc3bb31af7c9bdb63518
-        # This is an unfunded account, but the transaction has a 0 gas price, so is
-        # valid. It never needs to be mined, we just want the transaction hash back
-        # to confirm.
-        # tx = {'to': '0x0000000000000000000000000000000000000000', 'value': 0,  'nonce': 1, 'gas': 21000, 'gasPrice': 0, 'chainId': 131277322940537}  # noqa: E501
-        # NOTE: nonce=1 to make txn unique from the non-async version of this test
-        raw_txn = HexBytes(
-            "0xf8650180825208940000000000000000000000000000000000000000808086eecac466e115a0ffdd42d7dee4ac85427468bc616812e49432e285e4e8f5cd9381163ac3b28108a04ec6b0d89ecbd5e89b0399f336ad50f283fafd70e86593250bf5a2adfb93d17e"  # noqa: E501
-        )
-        expected_hash = HexStr(
-            "0x52b0ff9cb472f25872fa8ec6a62fa59454fc2ae7901cfcc6cc89d096f49b8fc1"
-        )
-        txn_hash = await async_w3.eth.send_raw_transaction(raw_txn)
-        assert txn_hash == async_w3.to_bytes(hexstr=expected_hash)
+    async def test_async_eth_send_raw_transaction(
+        self, async_w3: "AsyncWeb3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
+        txn = {
+            "chainId": 131277322940537,  # the chainId set for the fixture
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+            "nonce": await async_w3.eth.get_transaction_count(
+                keyfile_account.address, "pending"
+            ),
+            "gasPrice": 10**9,
+        }
+        signed = keyfile_account.sign_transaction(txn)
+        txn_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
+        assert txn_hash == HexBytes(signed.hash)
+
+    @pytest.mark.asyncio
+    async def test_async_sign_and_send_raw_middleware(
+        self, async_w3: "AsyncWeb3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
+        txn: TxParams = {
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+        }
+        async_w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(keyfile_account), "signing", layer=0
+        )
+        txn_hash = await async_w3.eth.send_transaction(txn)
+        assert isinstance(txn_hash, HexBytes)
+
+        # clean up
+        async_w3.middleware_onion.remove("signing")
 
     @pytest.mark.asyncio
     async def test_GasPriceStrategyMiddleware(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -710,11 +771,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_gas_price_strategy_middleware_hex_value(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -738,13 +801,13 @@ class AsyncEthModuleTest:
     async def test_gas_price_from_strategy_bypassed_for_dynamic_fee_txn(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
         max_fee: Wei,
     ) -> None:
         max_priority_fee = async_w3.to_wei(1, "gwei")
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": max_priority_fee,
@@ -767,7 +830,7 @@ class AsyncEthModuleTest:
             else 2 * latest_block["baseFeePerGas"] + max_priority_fee
         )
         assert txn["maxPriorityFeePerGas"] == max_priority_fee
-        assert txn["gasPrice"] == txn["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
@@ -775,11 +838,11 @@ class AsyncEthModuleTest:
     async def test_gas_price_from_strategy_bypassed_for_dynamic_fee_txn_no_tip(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(1000000000),
@@ -799,12 +862,14 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_estimate_gas(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         gas_estimate = await async_w3.eth.estimate_gas(
             {
-                "from": async_unlocked_account_dual_type,
-                "to": async_unlocked_account_dual_type,
+                "from": async_keyfile_account_address_dual_type,
+                "to": async_keyfile_account_address_dual_type,
                 "value": Wei(1),
             }
         )
@@ -834,10 +899,11 @@ 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}
+        accounts = await async_w3.eth.accounts
+        txn_params: TxParams = {"from": accounts[0]}
 
         # assert does not raise
         await async_w3.eth.estimate_gas(
@@ -933,9 +999,8 @@ class AsyncEthModuleTest:
     async def test_eth_getBlockByNumber_latest(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        current_block_number = await async_w3.eth.block_number
         block = await async_w3.eth.get_block("latest")
-        assert block["number"] == current_block_number
+        assert block["hash"] is not None
 
     @pytest.mark.asyncio
     async def test_eth_getBlockByNumber_not_found(
@@ -948,9 +1013,8 @@ class AsyncEthModuleTest:
     async def test_eth_getBlockByNumber_pending(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        current_block_number = await async_w3.eth.block_number
         block = await async_w3.eth.get_block("pending")
-        assert block["number"] == current_block_number + 1
+        assert block["hash"] is None
 
     @pytest.mark.asyncio
     async def test_eth_getBlockByNumber_earliest(
@@ -977,6 +1041,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
@@ -1006,22 +1103,26 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_block_with_txn: BlockData,
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         # eth_getRawTransactionByBlockNumberAndIndex: block identifier
-        # send a txn to make sure pending block has at least one txn
         await async_w3.eth.send_transaction(
             {
-                "from": async_unlocked_account_dual_type,
-                "to": async_unlocked_account_dual_type,
+                "from": async_keyfile_account_address_dual_type,
+                "to": async_keyfile_account_address_dual_type,
                 "value": Wei(1),
             }
         )
-        pending_block = await async_w3.eth.get_block("pending")
-        last_pending_txn_index = len(pending_block["transactions"]) - 1
-        raw_txn = await async_w3.eth.get_raw_transaction_by_block(
-            "pending", last_pending_txn_index
-        )
+
+        async def wait_for_block_with_txn() -> HexBytes:
+            while True:
+                try:
+                    return await async_w3.eth.get_raw_transaction_by_block("latest", 0)
+                except TransactionNotFound:
+                    await asyncio.sleep(0.1)
+                    continue
+
+        raw_txn = await asyncio.wait_for(wait_for_block_with_txn(), timeout=5)
         assert is_bytes(raw_txn)
 
         # eth_getRawTransactionByBlockNumberAndIndex: block number
@@ -1061,26 +1162,26 @@ class AsyncEthModuleTest:
     ) -> None:
         unknown_identifier = "unknown"
         with pytest.raises(
-            ValueError,
+            Web3ValueError,
             match=(
                 "Value did not match any of the recognized block identifiers: "
                 f"{unknown_identifier}"
             ),
         ):
-            await async_w3.eth.get_raw_transaction_by_block(
-                unknown_identifier, 0  # type: ignore
-            )
+            # type ignored because we are testing an invalid block identifier
+            await async_w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)  # type: ignore  # noqa: E501
 
     @pytest.mark.asyncio
     async def test_eth_get_balance(self, async_w3: "AsyncWeb3") -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
 
         with pytest.raises(InvalidAddress):
             await async_w3.eth.get_balance(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower())))
+                ChecksumAddress(HexAddress(HexStr(account.lower())))
             )
 
-        balance = await async_w3.eth.get_balance(coinbase)
+        balance = await async_w3.eth.get_balance(account)
 
         assert is_integer(balance)
         assert balance >= 0
@@ -1097,7 +1198,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 +1207,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)
@@ -1117,57 +1218,55 @@ class AsyncEthModuleTest:
     async def test_eth_create_access_list(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
-        async_math_contract: "Contract",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
+        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_keyfile_account_address_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"]
         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
+        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
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         transaction_count = await async_w3.eth.get_transaction_count(
-            async_unlocked_account_dual_type
+            async_keyfile_account_address_dual_type
         )
         assert is_integer(transaction_count)
         assert transaction_count >= 0
 
     @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
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
+
         txn_params = async_math_contract._prepare_transaction(
-            fn_name="add",
+            abi_element_identifier="add",
             fn_args=(7, 11),
-            transaction={"from": coinbase, "to": async_math_contract.address},
+            transaction={"from": account, "to": async_math_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -1178,12 +1277,13 @@ 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
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
         txn_params = async_revert_contract._prepare_transaction(
-            fn_name="normalFunction",
-            transaction={"from": coinbase, "to": async_revert_contract.address},
+            abi_element_identifier="normalFunction",
+            transaction={"from": account, "to": async_revert_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         (result,) = async_w3.codec.decode(["bool"], call_result)
@@ -1234,11 +1334,11 @@ 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
-        txn_params: TxParams = {"from": coinbase}
+        accounts = await async_w3.eth.accounts
+        txn_params: TxParams = {"from": accounts[0]}
 
         # assert does not raise
         await async_w3.eth.call(
@@ -1247,13 +1347,13 @@ 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
+        accounts = await async_w3.eth.accounts
         txn_params = async_math_contract._prepare_transaction(
-            fn_name="add",
+            abi_element_identifier="add",
             fn_args=(0, 0),
-            transaction={"from": coinbase, "to": async_math_contract.address},
+            transaction={"from": accounts[0], "to": async_math_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -1264,13 +1364,13 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_with_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_revert_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
         txn_params = async_revert_contract._prepare_transaction(
-            fn_name="revertWithMessage",
+            abi_element_identifier="revertWithMessage",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1283,14 +1383,14 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_without_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_revert_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
         with pytest.raises(ContractLogicError, match="execution reverted"):
             txn_params = async_revert_contract._prepare_transaction(
-                fn_name="revertWithoutMessage",
+                abi_element_identifier="revertWithoutMessage",
                 transaction={
-                    "from": async_unlocked_account,
+                    "from": async_keyfile_account_address,
                     "to": async_revert_contract.address,
                 },
             )
@@ -1300,16 +1400,17 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_custom_error_with_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_revert_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+        data = async_revert_contract.encode_abi(
+            abi_element_identifier="UnauthorizedWithMessage",
+            args=["You are not authorized"],
         )
         txn_params = async_revert_contract._prepare_transaction(
-            fn_name="customErrorWithMessage",
+            abi_element_identifier="customErrorWithMessage",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1320,14 +1421,14 @@ class AsyncEthModuleTest:
     async def test_eth_call_revert_custom_error_without_msg(
         self,
         async_w3: "AsyncWeb3",
-        async_revert_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_revert_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(fn_name="Unauthorized")
+        data = async_revert_contract.encode_abi(abi_element_identifier="Unauthorized")
         txn_params = async_revert_contract._prepare_transaction(
-            fn_name="customErrorWithoutMessage",
+            abi_element_identifier="customErrorWithoutMessage",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1352,7 +1453,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,8 +1470,8 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1395,7 +1496,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,8 +1534,8 @@ class AsyncEthModuleTest:
     async def test_eth_call_offchain_lookup_call_flag_overrides_provider_flag(
         self,
         async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1461,13 +1562,13 @@ 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
 
         async_w3.provider.ccip_read_max_redirects = max_redirects
-        with pytest.raises(ValueError, match="at least 4"):
+        with pytest.raises(Web3ValueError, match="at least 4"):
             await async_offchain_lookup_contract.caller().testOffchainLookup(
                 OFFCHAIN_LOOKUP_TEST_DATA
             )
@@ -1478,8 +1579,8 @@ 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_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1502,8 +1603,8 @@ 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_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
         status_code_non_4xx_error: int,
     ) -> None:
@@ -1525,7 +1626,7 @@ class AsyncEthModuleTest:
         async_mock_offchain_lookup_request_response(
             monkeypatch,
             http_method="POST",
-            mocked_request_url=f"https://web3.py/gateway/{normalized_contract_address}.json",  # noqa: E501
+            mocked_request_url="https://web3.py/gateway",
             mocked_status_code=200,
             mocked_json_data=WEB3PY_AS_HEXBYTES,
             sender=normalized_contract_address,
@@ -1540,8 +1641,8 @@ 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_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1562,8 +1663,7 @@ class AsyncEthModuleTest:
     @pytest.mark.asyncio
     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(
@@ -1576,9 +1676,7 @@ class AsyncEthModuleTest:
     @pytest.mark.asyncio
     async def test_eth_call_continuous_offchain_lookup_raises_with_too_many_requests(
         self,
-        async_w3: "AsyncWeb3",
-        async_offchain_lookup_contract: "Contract",
-        async_unlocked_account: ChecksumAddress,
+        async_offchain_lookup_contract: "AsyncContract",
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1592,23 +1690,12 @@ class AsyncEthModuleTest:
         with pytest.raises(TooManyRequests, match="Too many CCIP read redirects"):
             await async_offchain_lookup_contract.caller().continuousOffchainLookup()  # noqa: E501 type: ignore
 
-    @pytest.mark.asyncio
-    async def test_async_eth_hashrate(self, async_w3: "AsyncWeb3") -> None:
-        hashrate = await async_w3.eth.hashrate
-        assert is_integer(hashrate)
-        assert hashrate >= 0
-
     @pytest.mark.asyncio
     async def test_async_eth_chain_id(self, async_w3: "AsyncWeb3") -> None:
         chain_id = await async_w3.eth.chain_id
         # chain id value from geth fixture genesis file
         assert chain_id == 131277322940537
 
-    @pytest.mark.asyncio
-    async def test_async_eth_mining(self, async_w3: "AsyncWeb3") -> None:
-        mining = await async_w3.eth.mining
-        assert is_boolean(mining)
-
     @pytest.mark.asyncio
     async def test_async_eth_get_transaction_receipt_mined(
         self,
@@ -1630,14 +1717,17 @@ class AsyncEthModuleTest:
         assert isinstance(effective_gas_price, int)
         assert effective_gas_price > 0
 
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_get_transaction_receipt_unmined(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_hash = await async_w3.eth.send_transaction(
             {
-                "from": async_unlocked_account_dual_type,
-                "to": async_unlocked_account_dual_type,
+                "from": async_keyfile_account_address_dual_type,
+                "to": async_keyfile_account_address_dual_type,
                 "value": Wei(1),
                 "gas": 21000,
                 "maxFeePerGas": async_w3.to_wei(3, "gwei"),
@@ -1652,7 +1742,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)
@@ -1693,14 +1783,17 @@ class AsyncEthModuleTest:
         assert isinstance(effective_gas_price, int)
         assert effective_gas_price > 0
 
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_wait_for_transaction_receipt_unmined(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_hash = await async_w3.eth.send_transaction(
             {
-                "from": async_unlocked_account_dual_type,
-                "to": async_unlocked_account_dual_type,
+                "from": async_keyfile_account_address_dual_type,
+                "to": async_keyfile_account_address_dual_type,
                 "value": Wei(1),
                 "gas": 21000,
                 "maxFeePerGas": async_w3.to_wei(3, "gwei"),
@@ -1719,7 +1812,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,8 +1837,13 @@ 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 await async_w3.eth.coinbase in accounts
+        assert all(is_checksum_address(account) for account in accounts)
+
+    @pytest.mark.asyncio
+    async def test_async_eth_blob_base_fee(self, async_w3: "AsyncWeb3") -> None:
+        blob_base_fee = await async_w3.eth.blob_base_fee
+        assert is_integer(blob_base_fee)
+        assert blob_base_fee >= 0
 
     @pytest.mark.asyncio
     async def test_async_eth_get_logs_without_logs(
@@ -1765,7 +1863,7 @@ class AsyncEthModuleTest:
             "fromBlock": async_block_with_txn_with_log["number"],
             "toBlock": BlockNumber(async_block_with_txn_with_log["number"] - 1),
         }
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3RPCError):
             result = await async_w3.eth.get_logs(filter_params)
 
         # Test with `address`
@@ -1891,9 +1989,8 @@ class AsyncEthModuleTest:
         # Test with None overflowing
         filter_params: FilterParams = {
             "fromBlock": BlockNumber(0),
-            "topics": [None, None, None],
+            "topics": [None, None, None, None],
         }
-
         result = await async_w3.eth.get_logs(filter_params)
         assert len(result) == 0
 
@@ -1917,7 +2014,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 +2042,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)
@@ -1955,26 +2052,26 @@ class AsyncEthModuleTest:
     async def test_async_eth_get_storage_at_invalid_address(
         self, async_w3: "AsyncWeb3"
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
         with pytest.raises(InvalidAddress):
             await async_w3.eth.get_storage_at(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower()))), 0
+                ChecksumAddress(HexAddress(HexStr(accounts[0].lower()))), 0
             )
 
     def test_async_provider_default_account(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
-        # check defaults to empty
-        default_account = async_w3.eth.default_account
-        assert default_account is empty
+        current_default_account = async_w3.eth.default_account
 
         # check setter
-        async_w3.eth.default_account = async_unlocked_account_dual_type
+        async_w3.eth.default_account = async_keyfile_account_address_dual_type
         default_account = async_w3.eth.default_account
-        assert default_account == async_unlocked_account_dual_type
+        assert default_account == async_keyfile_account_address_dual_type
 
         # reset to default
-        async_w3.eth.default_account = empty
+        async_w3.eth.default_account = current_default_account
 
     def test_async_provider_default_block(
         self,
@@ -2056,17 +2153,20 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_eth_sign(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         signature = await async_w3.eth.sign(
-            async_unlocked_account_dual_type, text="Message tö sign. Longer than hash!"
+            async_keyfile_account_address_dual_type,
+            text="Message tö sign. Longer than hash!",
         )
         assert is_bytes(signature)
         assert len(signature) == 32 + 32 + 1
 
         # test other formats
         hexsign = await async_w3.eth.sign(
-            async_unlocked_account_dual_type,
+            async_keyfile_account_address_dual_type,
             hexstr=HexStr(
                 "0x4d6573736167652074c3b6207369676e2e204c6f6e676572207468616e206861736821"  # noqa: E501
             ),
@@ -2074,19 +2174,20 @@ class AsyncEthModuleTest:
         assert hexsign == signature
 
         intsign = await async_w3.eth.sign(
-            async_unlocked_account_dual_type,
+            async_keyfile_account_address_dual_type,
             0x4D6573736167652074C3B6207369676E2E204C6F6E676572207468616E206861736821,
         )
         assert intsign == signature
 
         bytessign = await async_w3.eth.sign(
-            async_unlocked_account_dual_type,
+            async_keyfile_account_address_dual_type,
             b"Message t\xc3\xb6 sign. Longer than hash!",
         )
         assert bytessign == signature
 
         new_signature = await async_w3.eth.sign(
-            async_unlocked_account_dual_type, text="different message is different"
+            async_keyfile_account_address_dual_type,
+            text="different message is different",
         )
         assert new_signature != signature
 
@@ -2095,10 +2196,12 @@ class AsyncEthModuleTest:
         reason="Async middleware to convert ENS names to addresses is missing"
     )
     async def test_async_eth_sign_ens_names(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         with ens_addresses(
-            async_w3, {"unlocked-acct.eth": async_unlocked_account_dual_type}
+            async_w3, {"unlocked-acct.eth": async_keyfile_account_address_dual_type}
         ):
             signature = await async_w3.eth.sign(
                 ENS("unlocked-acct.eth"), text="Message tö sign. Longer than hash!"
@@ -2109,11 +2212,13 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_legacy(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": async_w3.to_wei(1, "gwei"),
@@ -2137,14 +2242,16 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         two_gwei_in_wei = async_w3.to_wei(2, "gwei")
         three_gwei_in_wei = async_w3.to_wei(3, "gwei")
 
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": two_gwei_in_wei,
@@ -2172,11 +2279,13 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_underpriced(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(3, "gwei"),
@@ -2188,17 +2297,19 @@ class AsyncEthModuleTest:
         txn_params["maxFeePerGas"] = one_gwei_in_wei
         txn_params["maxPriorityFeePerGas"] = one_gwei_in_wei
 
-        with pytest.raises(ValueError, match="replacement transaction underpriced"):
+        with pytest.raises(Web3RPCError, match="replacement transaction underpriced"):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_non_existing_transaction(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(3, "gwei"),
@@ -2215,11 +2326,13 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_already_mined(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(2, "gwei"),
@@ -2230,17 +2343,17 @@ class AsyncEthModuleTest:
 
         txn_params["maxFeePerGas"] = async_w3.to_wei(3, "gwei")
         txn_params["maxPriorityFeePerGas"] = async_w3.to_wei(2, "gwei")
-        with pytest.raises(ValueError, match="Supplied transaction with hash"):
+        with pytest.raises(Web3ValueError, match="Supplied transaction with hash"):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_incorrect_nonce(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(2, "gwei"),
@@ -2252,17 +2365,19 @@ class AsyncEthModuleTest:
         txn_params["maxFeePerGas"] = async_w3.to_wei(3, "gwei")
         txn_params["maxPriorityFeePerGas"] = async_w3.to_wei(2, "gwei")
         txn_params["nonce"] = Nonce(txn["nonce"] + 1)
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3ValueError):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_too_low(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": async_w3.to_wei(2, "gwei"),
@@ -2270,19 +2385,18 @@ class AsyncEthModuleTest:
         txn_hash = await async_w3.eth.send_transaction(txn_params)
 
         txn_params["gasPrice"] = async_w3.to_wei(1, "gwei")
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3ValueError):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_minimum(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = async_w3.to_wei(1, "gwei")
 
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -2297,14 +2411,13 @@ class AsyncEthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_higher(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": async_w3.to_wei(1, "gwei"),
@@ -2313,7 +2426,7 @@ class AsyncEthModuleTest:
 
         two_gwei_in_wei = async_w3.to_wei(2, "gwei")
 
-        def higher_gas_price_strategy(async_w3: "AsyncWeb3", txn: TxParams) -> Wei:
+        def higher_gas_price_strategy(_async_w3: "AsyncWeb3", _txn: TxParams) -> Wei:
             return two_gwei_in_wei
 
         async_w3.eth.set_gas_price_strategy(higher_gas_price_strategy)
@@ -2326,16 +2439,14 @@ class AsyncEthModuleTest:
         )  # Strategy provides higher gas price
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_lower(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = async_w3.to_wei(2, "gwei")
-
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -2424,19 +2535,6 @@ class EthModuleTest:
             assert is_integer(sync_dict["currentBlock"])
             assert is_integer(sync_dict["highestBlock"])
 
-    def test_eth_coinbase(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
-        assert is_checksum_address(coinbase)
-
-    def test_eth_mining(self, w3: "Web3") -> None:
-        mining = w3.eth.mining
-        assert is_boolean(mining)
-
-    def test_eth_hashrate(self, w3: "Web3") -> None:
-        hashrate = w3.eth.hashrate
-        assert is_integer(hashrate)
-        assert hashrate >= 0
-
     def test_eth_chain_id(self, w3: "Web3") -> None:
         chain_id = w3.eth.chain_id
         # chain id value from geth fixture genesis file
@@ -2503,8 +2601,12 @@ 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 w3.eth.coinbase in accounts
+        assert all(is_checksum_address(account) for account in accounts)
+
+    def test_eth_blob_base_fee(self, w3: "Web3") -> None:
+        blob_base_fee = w3.eth.blob_base_fee
+        assert is_integer(blob_base_fee)
+        assert blob_base_fee >= 0
 
     def test_eth_block_number(self, w3: "Web3") -> None:
         block_number = w3.eth.block_number
@@ -2517,12 +2619,12 @@ class EthModuleTest:
         assert block_number >= 0
 
     def test_eth_get_balance(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
 
         with pytest.raises(InvalidAddress):
-            w3.eth.get_balance(ChecksumAddress(HexAddress(HexStr(coinbase.lower()))))
+            w3.eth.get_balance(ChecksumAddress(HexAddress(HexStr(account.lower()))))
 
-        balance = w3.eth.get_balance(coinbase)
+        balance = w3.eth.get_balance(account)
 
         assert is_integer(balance)
         assert balance >= 0
@@ -2584,24 +2686,26 @@ class EthModuleTest:
             assert storage == HexBytes(f"0x{'00' * 31}01")
 
     def test_eth_get_storage_at_invalid_address(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
         with pytest.raises(InvalidAddress):
             w3.eth.get_storage_at(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower()))), 0
+                ChecksumAddress(HexAddress(HexStr(account.lower()))), 0
             )
 
     def test_eth_get_transaction_count(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
-        transaction_count = w3.eth.get_transaction_count(unlocked_account_dual_type)
+        transaction_count = w3.eth.get_transaction_count(
+            keyfile_account_address_dual_type
+        )
         assert is_integer(transaction_count)
         assert transaction_count >= 0
 
     def test_eth_get_transaction_count_ens_name(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         with ens_addresses(
-            w3, {"unlocked-acct-dual-type.eth": unlocked_account_dual_type}
+            w3, {"unlocked-acct-dual-type.eth": keyfile_account_address_dual_type}
         ):
             transaction_count = w3.eth.get_transaction_count(
                 ENS("unlocked-acct-dual-type.eth")
@@ -2610,10 +2714,10 @@ class EthModuleTest:
             assert transaction_count >= 0
 
     def test_eth_get_transaction_count_invalid_address(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
         with pytest.raises(InvalidAddress):
             w3.eth.get_transaction_count(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower())))
+                ChecksumAddress(HexAddress(HexStr(account.lower())))
             )
 
     def test_eth_getBlockTransactionCountByHash_empty_block(
@@ -2699,47 +2803,44 @@ class EthModuleTest:
     def test_eth_create_access_list(
         self,
         w3: "Web3",
-        unlocked_account_dual_type: ChecksumAddress,
+        keyfile_account_address_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": keyfile_account_address_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
         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
+        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
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         signature = w3.eth.sign(
-            unlocked_account_dual_type, text="Message tö sign. Longer than hash!"
+            keyfile_account_address_dual_type, text="Message tö sign. Longer than hash!"
         )
         assert is_bytes(signature)
         assert len(signature) == 32 + 32 + 1
 
         # test other formats
         hexsign = w3.eth.sign(
-            unlocked_account_dual_type,
+            keyfile_account_address_dual_type,
             hexstr=HexStr(
                 "0x4d6573736167652074c3b6207369676e2e204c6f6e676572207468616e206861736821"  # noqa: E501
             ),
@@ -2747,25 +2848,28 @@ class EthModuleTest:
         assert hexsign == signature
 
         intsign = w3.eth.sign(
-            unlocked_account_dual_type,
+            keyfile_account_address_dual_type,
             0x4D6573736167652074C3B6207369676E2E204C6F6E676572207468616E206861736821,
         )
         assert intsign == signature
 
         bytessign = w3.eth.sign(
-            unlocked_account_dual_type, b"Message t\xc3\xb6 sign. Longer than hash!"
+            keyfile_account_address_dual_type,
+            b"Message t\xc3\xb6 sign. Longer than hash!",
         )
         assert bytessign == signature
 
         new_signature = w3.eth.sign(
-            unlocked_account_dual_type, text="different message is different"
+            keyfile_account_address_dual_type, text="different message is different"
         )
         assert new_signature != signature
 
     def test_eth_sign_ens_names(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
-        with ens_addresses(w3, {"unlocked-acct.eth": unlocked_account_dual_type}):
+        with ens_addresses(
+            w3, {"unlocked-acct.eth": keyfile_account_address_dual_type}
+        ):
             signature = w3.eth.sign(
                 "unlocked-acct.eth", text="Message tö sign. Longer than hash!"
             )
@@ -2775,7 +2879,7 @@ class EthModuleTest:
     def test_eth_sign_typed_data(
         self,
         w3: "Web3",
-        unlocked_account_dual_type: ChecksumAddress,
+        keyfile_account_address_dual_type: ChecksumAddress,
         skip_if_testrpc: Callable[["Web3"], None],
     ) -> None:
         validJSONMessage = """
@@ -2820,7 +2924,7 @@ class EthModuleTest:
         skip_if_testrpc(w3)
         signature = HexBytes(
             w3.eth.sign_typed_data(
-                unlocked_account_dual_type, json.loads(validJSONMessage)
+                keyfile_account_address_dual_type, json.loads(validJSONMessage)
             )
         )
         assert len(signature) == 32 + 32 + 1
@@ -2828,7 +2932,7 @@ class EthModuleTest:
     def test_invalid_eth_sign_typed_data(
         self,
         w3: "Web3",
-        unlocked_account_dual_type: ChecksumAddress,
+        keyfile_account_address_dual_type: ChecksumAddress,
         skip_if_testrpc: Callable[["Web3"], None],
     ) -> None:
         skip_if_testrpc(w3)
@@ -2872,19 +2976,19 @@ class EthModuleTest:
             }
         """
         with pytest.raises(
-            ValueError,
+            Web3ValueError,
             match=r".*Expected 2 items for array type Person\[2\], got 1 items.*",
         ):
             w3.eth.sign_typed_data(
-                unlocked_account_dual_type, json.loads(invalid_typed_message)
+                keyfile_account_address_dual_type, json.loads(invalid_typed_message)
             )
 
     def test_eth_sign_transaction_legacy(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.eth.gas_price,
@@ -2892,7 +2996,7 @@ class EthModuleTest:
         }
         result = w3.eth.sign_transaction(txn_params)
         signatory_account = w3.eth.account.recover_transaction(result["raw"])
-        assert unlocked_account == signatory_account
+        assert keyfile_account_address == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -2900,11 +3004,11 @@ class EthModuleTest:
         assert result["tx"]["nonce"] == txn_params["nonce"]
 
     def test_eth_sign_transaction(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(2, "gwei"),
@@ -2913,7 +3017,7 @@ class EthModuleTest:
         }
         result = w3.eth.sign_transaction(txn_params)
         signatory_account = w3.eth.account.recover_transaction(result["raw"])
-        assert unlocked_account == signatory_account
+        assert keyfile_account_address == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -2924,11 +3028,11 @@ class EthModuleTest:
         assert result["tx"]["nonce"] == txn_params["nonce"]
 
     def test_eth_sign_transaction_hex_fees(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": hex(w3.to_wei(2, "gwei")),
@@ -2937,7 +3041,7 @@ class EthModuleTest:
         }
         result = w3.eth.sign_transaction(txn_params)
         signatory_account = w3.eth.account.recover_transaction(result["raw"])
-        assert unlocked_account == signatory_account
+        assert keyfile_account_address == signatory_account
         assert result["tx"]["to"] == txn_params["to"]
         assert result["tx"]["value"] == txn_params["value"]
         assert result["tx"]["gas"] == txn_params["gas"]
@@ -2948,9 +3052,9 @@ class EthModuleTest:
         assert result["tx"]["nonce"] == txn_params["nonce"]
 
     def test_eth_sign_transaction_ens_names(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
-        with ens_addresses(w3, {"unlocked-account.eth": unlocked_account}):
+        with ens_addresses(w3, {"unlocked-account.eth": keyfile_account_address}):
             txn_params: TxParams = {
                 "from": "unlocked-account.eth",
                 "to": "unlocked-account.eth",
@@ -2962,8 +3066,8 @@ class EthModuleTest:
             }
             result = w3.eth.sign_transaction(txn_params)
             signatory_account = w3.eth.account.recover_transaction(result["raw"])
-            assert unlocked_account == signatory_account
-            assert result["tx"]["to"] == unlocked_account
+            assert keyfile_account_address == signatory_account
+            assert result["tx"]["to"] == keyfile_account_address
             assert result["tx"]["value"] == txn_params["value"]
             assert result["tx"]["gas"] == txn_params["gas"]
             assert result["tx"]["maxFeePerGas"] == txn_params["maxFeePerGas"]
@@ -2974,12 +3078,12 @@ class EthModuleTest:
             assert result["tx"]["nonce"] == txn_params["nonce"]
 
     def test_eth_send_transaction_addr_checksum_required(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
-        non_checksum_addr = unlocked_account.lower()
+        non_checksum_addr = keyfile_account_address.lower()
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(2, "gwei"),
@@ -2999,11 +3103,11 @@ class EthModuleTest:
             w3.eth.send_transaction(invalid_params)
 
     def test_eth_send_transaction_legacy(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.to_wei(
@@ -3020,16 +3124,17 @@ class EthModuleTest:
         assert txn["gasPrice"] == txn_params["gasPrice"]
 
     def test_eth_send_transaction(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(3, "gwei"),
             "maxPriorityFeePerGas": w3.to_wei(1, "gwei"),
         }
+
         txn_hash = w3.eth.send_transaction(txn_params)
         txn = w3.eth.get_transaction(txn_hash)
 
@@ -3039,23 +3144,25 @@ class EthModuleTest:
         assert txn["gas"] == 21000
         assert txn["maxFeePerGas"] == txn_params["maxFeePerGas"]
         assert txn["maxPriorityFeePerGas"] == txn_params["maxPriorityFeePerGas"]
-        assert txn["gasPrice"] == txn_params["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
     def test_eth_send_transaction_with_nonce(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         max_priority_fee_per_gas = w3.to_wei(1.234, "gwei")
         max_fee_per_gas = Wei(
             w3.eth.get_block("latest")["baseFeePerGas"] + max_priority_fee_per_gas
         )
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": max_fee_per_gas,
             "maxPriorityFeePerGas": max_priority_fee_per_gas,
-            "nonce": Nonce(w3.eth.get_transaction_count(unlocked_account, "pending")),
+            "nonce": Nonce(
+                w3.eth.get_transaction_count(keyfile_account_address, "pending")
+            ),
         }
         txn_hash = w3.eth.send_transaction(txn_params)
         txn = w3.eth.get_transaction(txn_hash)
@@ -3071,11 +3178,11 @@ class EthModuleTest:
         assert is_integer(txn_params["maxFeePerGas"])
 
     def test_eth_send_transaction_default_fees(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -3088,14 +3195,14 @@ class EthModuleTest:
         assert txn["gas"] == 21000
         assert is_integer(txn["maxPriorityFeePerGas"])
         assert is_integer(txn["maxFeePerGas"])
-        assert txn["gasPrice"] == txn["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
     def test_eth_send_transaction_hex_fees(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": hex(250 * 10**9),
@@ -3112,11 +3219,11 @@ class EthModuleTest:
         assert txn["maxPriorityFeePerGas"] == 2 * 10**9
 
     def test_eth_send_transaction_no_gas(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "maxFeePerGas": Wei(250 * 10**9),
             "maxPriorityFeePerGas": Wei(2 * 10**9),
@@ -3130,11 +3237,11 @@ class EthModuleTest:
         assert txn["gas"] == 121000  # 21000 + buffer
 
     def test_eth_send_transaction_with_gas_price(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": Wei(1),
@@ -3145,11 +3252,11 @@ class EthModuleTest:
             w3.eth.send_transaction(txn_params)
 
     def test_eth_send_transaction_no_priority_fee(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(250 * 10**9),
@@ -3160,12 +3267,12 @@ class EthModuleTest:
             w3.eth.send_transaction(txn_params)
 
     def test_eth_send_transaction_no_max_fee(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         max_priority_fee_per_gas = w3.to_wei(2, "gwei")
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": max_priority_fee_per_gas,
@@ -3182,11 +3289,11 @@ class EthModuleTest:
         assert is_integer(txn["maxFeePerGas"])
 
     def test_eth_send_transaction_max_fee_less_than_tip(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(1 * 10**9),
@@ -3198,14 +3305,14 @@ class EthModuleTest:
             w3.eth.send_transaction(txn_params)
 
     def test_validation_middleware_chain_id_mismatch(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         wrong_chain_id = 1234567890
         actual_chain_id = w3.eth.chain_id
 
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": Wei(21000),
             "maxFeePerGas": w3.to_wei(2, "gwei"),
@@ -3223,12 +3330,15 @@ class EthModuleTest:
         "max_fee", (1000000000, None), ids=["with_max_fee", "without_max_fee"]
     )
     def test_gas_price_from_strategy_bypassed_for_dynamic_fee_txn(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress, max_fee: Wei
+        self,
+        w3: "Web3",
+        keyfile_account_address_dual_type: ChecksumAddress,
+        max_fee: Wei,
     ) -> None:
         max_priority_fee = w3.to_wei(1, "gwei")
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": max_priority_fee,
@@ -3251,18 +3361,18 @@ class EthModuleTest:
             else 2 * latest_block["baseFeePerGas"] + max_priority_fee
         )
         assert txn["maxPriorityFeePerGas"] == max_priority_fee
-        assert txn["gasPrice"] == txn["maxFeePerGas"]
+        assert txn["gasPrice"] <= txn["maxFeePerGas"]  # effective gas price
 
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
     def test_gas_price_from_strategy_bypassed_for_dynamic_fee_txn_no_tip(
         self,
         w3: "Web3",
-        unlocked_account_dual_type: ChecksumAddress,
+        keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(1000000000),
@@ -3281,11 +3391,11 @@ class EthModuleTest:
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
     def test_gas_price_strategy_hex_value(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -3304,11 +3414,11 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_legacy(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.to_wei(
@@ -3333,14 +3443,14 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         two_gwei_in_wei = w3.to_wei(2, "gwei")
         three_gwei_in_wei = w3.to_wei(3, "gwei")
 
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": two_gwei_in_wei,
@@ -3367,11 +3477,11 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_underpriced(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(3, "gwei"),
@@ -3383,16 +3493,16 @@ class EthModuleTest:
         txn_params["maxFeePerGas"] = one_gwei_in_wei
         txn_params["maxPriorityFeePerGas"] = one_gwei_in_wei
 
-        with pytest.raises(ValueError, match="replacement transaction underpriced"):
+        with pytest.raises(Web3RPCError, match="replacement transaction underpriced"):
             w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_non_existing_transaction(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(3, "gwei"),
@@ -3408,11 +3518,11 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_already_mined(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(2, "gwei"),
@@ -3423,16 +3533,16 @@ class EthModuleTest:
 
         txn_params["maxFeePerGas"] = w3.to_wei(3, "gwei")
         txn_params["maxPriorityFeePerGas"] = w3.to_wei(2, "gwei")
-        with pytest.raises(ValueError, match="Supplied transaction with hash"):
+        with pytest.raises(Web3ValueError, match="Supplied transaction with hash"):
             w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_incorrect_nonce(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": w3.to_wei(2, "gwei"),
@@ -3444,16 +3554,16 @@ class EthModuleTest:
         txn_params["maxFeePerGas"] = w3.to_wei(3, "gwei")
         txn_params["maxPriorityFeePerGas"] = w3.to_wei(2, "gwei")
         txn_params["nonce"] = Nonce(txn["nonce"] + 1)
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3ValueError):
             w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_too_low(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.to_wei(2, "gwei"),
@@ -3461,18 +3571,18 @@ class EthModuleTest:
         txn_hash = w3.eth.send_transaction(txn_params)
 
         txn_params["gasPrice"] = w3.to_wei(1, "gwei")
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3ValueError):
             w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_defaulting_minimum(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = w3.to_wei(1, "gwei")
 
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -3489,11 +3599,11 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_defaulting_strategy_higher(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.to_wei(1, "gwei"),
@@ -3517,13 +3627,12 @@ class EthModuleTest:
 
     @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_defaulting_strategy_lower(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = w3.to_wei(2, "gwei")
-
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -3543,11 +3652,11 @@ class EthModuleTest:
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
     def test_eth_modify_transaction_legacy(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": w3.to_wei(
@@ -3557,7 +3666,7 @@ class EthModuleTest:
         txn_hash = w3.eth.send_transaction(txn_params)
 
         modified_txn_hash = w3.eth.modify_transaction(
-            txn_hash, gasPrice=(cast(int, txn_params["gasPrice"]) * 2), value=2
+            txn_hash, gasPrice=(cast(Wei, txn_params["gasPrice"] * 2)), value=Wei(2)
         )
         modified_txn = w3.eth.get_transaction(modified_txn_hash)
 
@@ -3572,11 +3681,11 @@ class EthModuleTest:
         assert modified_txn["gasPrice"] == cast(int, txn_params["gasPrice"]) * 2
 
     def test_eth_modify_transaction(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account,
-            "to": unlocked_account,
+            "from": keyfile_account_address,
+            "to": keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": w3.to_wei(1, "gwei"),
@@ -3586,9 +3695,9 @@ class EthModuleTest:
 
         modified_txn_hash = w3.eth.modify_transaction(
             txn_hash,
-            value=2,
-            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"]) * 2),
-            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"]) * 2),
+            value=Wei(2),
+            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"] * 2)),
+            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"] * 2)),
         )
         modified_txn = w3.eth.get_transaction(modified_txn_hash)
 
@@ -3607,30 +3716,46 @@ class EthModuleTest:
         assert modified_txn["maxFeePerGas"] == cast(Wei, txn_params["maxFeePerGas"]) * 2
 
     def test_eth_send_raw_transaction(
-        self, w3: "Web3", unlocked_account: ChecksumAddress
-    ) -> None:
-        signed_tx = w3.eth.account.sign_transaction(
-            {
-                "to": "0x0000000000000000000000000000000000000000",
-                "value": 0,
-                "nonce": w3.eth.get_transaction_count(unlocked_account),
-                "gas": 21000,
-                "maxFeePerGas": 1000000000,
-                "maxPriorityFeePerGas": 1000000000,
-                "chainId": 131277322940537,
-            },
-            # unlocked_account private key:
-            "0x392f63a79b1ff8774845f3fa69de4a13800a59e7083f5187f1558f0797ad0f01",
+        self, w3: "Web3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = w3.eth.account.from_key(keyfile_account_pkey)
+        txn = {
+            "chainId": 131277322940537,  # the chainId set for the fixture
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+            "nonce": w3.eth.get_transaction_count(keyfile_account.address, "pending"),
+            "gasPrice": 10**9,
+        }
+        signed = keyfile_account.sign_transaction(txn)
+        txn_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        assert txn_hash == HexBytes(signed.hash)
+
+    def test_sign_and_send_raw_middleware(
+        self, w3: "Web3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = w3.eth.account.from_key(keyfile_account_pkey)
+        txn: TxParams = {
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+        }
+        w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(keyfile_account), "signing", layer=0
         )
-        txn_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
-        assert txn_hash == signed_tx.hash
+        txn_hash = w3.eth.send_transaction(txn)
+        assert isinstance(txn_hash, HexBytes)
+
+        # cleanup
+        w3.middleware_onion.remove("signing")
 
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:
-        coinbase = w3.eth.coinbase
         txn_params = math_contract._prepare_transaction(
-            fn_name="add",
+            abi_element_identifier="add",
             fn_args=(7, 11),
-            transaction={"from": coinbase, "to": math_contract.address},
+            transaction={"from": w3.eth.accounts[0], "to": math_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -3640,10 +3765,9 @@ class EthModuleTest:
     def test_eth_call_with_override_code(
         self, w3: "Web3", revert_contract: "Contract"
     ) -> None:
-        coinbase = w3.eth.coinbase
         txn_params = revert_contract._prepare_transaction(
-            fn_name="normalFunction",
-            transaction={"from": coinbase, "to": revert_contract.address},
+            abi_element_identifier="normalFunction",
+            transaction={"from": w3.eth.accounts[0], "to": revert_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         (result,) = w3.codec.decode(["bool"], call_result)
@@ -3694,7 +3818,7 @@ class EthModuleTest:
         math_contract: "Contract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": w3.eth.coinbase}
+        txn_params: TxParams = {"from": w3.eth.accounts[0]}
 
         # assert does not raise
         w3.eth.call(txn_params, "latest", {math_contract.address: params})
@@ -3702,11 +3826,10 @@ class EthModuleTest:
     def test_eth_call_with_0_result(
         self, w3: "Web3", math_contract: "Contract"
     ) -> None:
-        coinbase = w3.eth.coinbase
         txn_params = math_contract._prepare_transaction(
-            fn_name="add",
+            abi_element_identifier="add",
             fn_args=(0, 0),
-            transaction={"from": coinbase, "to": math_contract.address},
+            transaction={"from": w3.eth.accounts[0], "to": math_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -3717,12 +3840,12 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         txn_params = revert_contract._prepare_transaction(
-            fn_name="revertWithMessage",
+            abi_element_identifier="revertWithMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3737,13 +3860,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         with pytest.raises(ContractLogicError, match="execution reverted"):
             txn_params = revert_contract._prepare_transaction(
-                fn_name="revertWithoutMessage",
+                abi_element_identifier="revertWithoutMessage",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -3753,15 +3876,16 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+        data = revert_contract.encode_abi(
+            abi_element_identifier="UnauthorizedWithMessage",
+            args=["You are not authorized"],
         )
         txn_params = revert_contract._prepare_transaction(
-            fn_name="customErrorWithMessage",
+            abi_element_identifier="customErrorWithMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3773,13 +3897,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(abi_element_identifier="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
-            fn_name="customErrorWithoutMessage",
+            abi_element_identifier="customErrorWithoutMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3821,7 +3945,7 @@ class EthModuleTest:
         self,
         w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -3876,7 +4000,7 @@ class EthModuleTest:
         self,
         w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -3907,7 +4031,7 @@ class EthModuleTest:
         default_max_redirects = w3.provider.ccip_read_max_redirects
 
         w3.provider.ccip_read_max_redirects = max_redirects
-        with pytest.raises(ValueError, match="at least 4"):
+        with pytest.raises(Web3ValueError, match="at least 4"):
             offchain_lookup_contract.functions.testOffchainLookup(
                 OFFCHAIN_LOOKUP_TEST_DATA
             ).call()
@@ -3918,7 +4042,7 @@ class EthModuleTest:
         self,
         w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -3940,7 +4064,7 @@ class EthModuleTest:
         self,
         w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
         status_code_non_4xx_error: int,
     ) -> None:
@@ -3962,7 +4086,7 @@ class EthModuleTest:
         mock_offchain_lookup_request_response(
             monkeypatch,
             http_method="POST",
-            mocked_request_url=f"https://web3.py/gateway/{normalized_contract_address}.json",  # noqa: E501
+            mocked_request_url="https://web3.py/gateway",
             mocked_status_code=200,
             mocked_json_data=WEB3PY_AS_HEXBYTES,
             sender=normalized_contract_address,
@@ -3977,7 +4101,7 @@ class EthModuleTest:
         self,
         w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -3996,7 +4120,6 @@ class EthModuleTest:
 
     def test_eth_call_offchain_lookup_raises_when_all_supplied_urls_fail(
         self,
-        w3: "Web3",
         offchain_lookup_contract: "Contract",
     ) -> None:
         # GET and POST requests should fail since responses are not mocked
@@ -4009,9 +4132,7 @@ class EthModuleTest:
 
     def test_eth_call_continuous_offchain_lookup_raises_with_too_many_requests(
         self,
-        w3: "Web3",
         offchain_lookup_contract: "Contract",
-        unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -4028,15 +4149,15 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         with pytest.raises(
             ContractLogicError, match="execution reverted: Function has been reverted"
         ):
             txn_params = revert_contract._prepare_transaction(
-                fn_name="revertWithMessage",
+                abi_element_identifier="revertWithMessage",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -4046,13 +4167,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         with pytest.raises(ContractLogicError, match="execution reverted"):
             txn_params = revert_contract._prepare_transaction(
-                fn_name="revertWithoutMessage",
+                abi_element_identifier="revertWithoutMessage",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -4062,15 +4183,16 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+        data = revert_contract.encode_abi(
+            abi_element_identifier="UnauthorizedWithMessage",
+            args=["You are not authorized"],
         )
         txn_params = revert_contract._prepare_transaction(
-            fn_name="customErrorWithMessage",
+            abi_element_identifier="customErrorWithMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -4082,13 +4204,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(abi_element_identifier="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
-            fn_name="customErrorWithoutMessage",
+            abi_element_identifier="customErrorWithoutMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -4097,12 +4219,12 @@ class EthModuleTest:
         assert excinfo.value.data == data
 
     def test_eth_estimate_gas(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         gas_estimate = w3.eth.estimate_gas(
             {
-                "from": unlocked_account_dual_type,
-                "to": unlocked_account_dual_type,
+                "from": keyfile_account_address_dual_type,
+                "to": keyfile_account_address_dual_type,
                 "value": Wei(1),
             }
         )
@@ -4110,12 +4232,12 @@ class EthModuleTest:
         assert gas_estimate > 0
 
     def test_eth_estimate_gas_with_block(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         gas_estimate = w3.eth.estimate_gas(
             {
-                "from": unlocked_account_dual_type,
-                "to": unlocked_account_dual_type,
+                "from": keyfile_account_address_dual_type,
+                "to": keyfile_account_address_dual_type,
                 "value": Wei(1),
             },
             "latest",
@@ -4148,7 +4270,7 @@ class EthModuleTest:
         math_contract: "Contract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": w3.eth.coinbase}
+        txn_params: TxParams = {"from": w3.eth.accounts[0]}
 
         # assert does not raise
         w3.eth.estimate_gas(txn_params, None, {math_contract.address: params})
@@ -4175,12 +4297,9 @@ class EthModuleTest:
         block = w3.eth.get_block(empty_block["number"])
         assert block["number"] == empty_block["number"]
 
-    def test_eth_getBlockByNumber_latest(
-        self, w3: "Web3", empty_block: BlockData
-    ) -> None:
-        current_block_number = w3.eth.block_number
+    def test_eth_getBlockByNumber_latest(self, w3: "Web3") -> None:
         block = w3.eth.get_block("latest")
-        assert block["number"] == current_block_number
+        assert block["hash"] is not None
 
     def test_eth_getBlockByNumber_not_found(
         self, w3: "Web3", empty_block: BlockData
@@ -4221,8 +4340,36 @@ class EthModuleTest:
         self, w3: "Web3", block_with_txn: BlockData
     ) -> 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
+        transaction = cast(TxData, block["transactions"][0])
+        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)
@@ -4267,13 +4414,14 @@ class EthModuleTest:
         assert isinstance(effective_gas_price, int)
         assert effective_gas_price > 0
 
+    @flaky_geth_dev_mining
     def test_eth_get_transaction_receipt_unmined(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_hash = w3.eth.send_transaction(
             {
-                "from": unlocked_account_dual_type,
-                "to": unlocked_account_dual_type,
+                "from": keyfile_account_address_dual_type,
+                "to": keyfile_account_address_dual_type,
                 "value": Wei(1),
                 "gas": 21000,
                 "maxFeePerGas": w3.to_wei(3, "gwei"),
@@ -4324,13 +4472,14 @@ class EthModuleTest:
         assert isinstance(effective_gas_price, int)
         assert effective_gas_price > 0
 
+    @flaky_geth_dev_mining
     def test_eth_wait_for_transaction_receipt_unmined(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_hash = w3.eth.send_transaction(
             {
-                "from": unlocked_account_dual_type,
-                "to": unlocked_account_dual_type,
+                "from": keyfile_account_address_dual_type,
+                "to": keyfile_account_address_dual_type,
                 "value": Wei(1),
                 "gas": 21000,
                 "maxFeePerGas": w3.to_wei(3, "gwei"),
@@ -4428,7 +4577,7 @@ class EthModuleTest:
             "fromBlock": block_with_txn_with_log["number"],
             "toBlock": BlockNumber(block_with_txn_with_log["number"] - 1),
         }
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3RPCError):
             w3.eth.get_logs(filter_params)
 
         # Test with `address`
@@ -4537,44 +4686,47 @@ class EthModuleTest:
         assert len(result) == 0
 
     def test_eth_call_old_contract_state(
-        self, w3: "Web3", math_contract: "Contract", unlocked_account: ChecksumAddress
+        self,
+        w3: "Web3",
+        math_contract: "Contract",
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        start_block = w3.eth.get_block("latest")
-        block_num = start_block["number"]
-        block_hash = start_block["hash"]
+        current_block = w3.eth.get_block("latest")
+        block_num = current_block["number"]
+        block_hash = current_block["hash"]
+
+        default_call_result = math_contract.functions.counter().call()
+        latest_call_result = math_contract.functions.counter().call(
+            block_identifier="latest"
+        )
+
+        # increment counter and get tx receipt
+        tx_hash = math_contract.functions.incrementCounter().transact(
+            {"from": keyfile_account_address}
+        )
+        tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
 
-        math_contract.functions.incrementCounter().transact({"from": unlocked_account})
+        # get new state value
+        post_state_block_num_call_result = math_contract.functions.counter().call(
+            block_identifier=tx_receipt["blockNumber"]
+        )
 
-        # This isn't an incredibly convincing test since we can't mine, and
-        # the default resolved block is latest, So if block_identifier was ignored
-        # we would get the same result. For now, we mostly depend on core tests.
-        # Ideas to improve this test:
-        #  - Enable on-demand mining in more clients
-        #  - Increment the math contract in all of the fixtures, and check the
-        #    value in an old block
+        # call old state values with different block identifiers
         block_hash_call_result = math_contract.functions.counter().call(
             block_identifier=block_hash
         )
-        block_num_call_result = math_contract.functions.counter().call(
+        pre_state_block_num_call_result = math_contract.functions.counter().call(
             block_identifier=block_num
         )
-        latest_call_result = math_contract.functions.counter().call(
-            block_identifier="latest"
-        )
-        default_call_result = math_contract.functions.counter().call()
-        pending_call_result = math_contract.functions.counter().call(
-            block_identifier="pending"
-        )
-
-        assert block_hash_call_result == 0
-        assert block_num_call_result == 0
-        assert latest_call_result == 0
-        assert default_call_result == 0
 
-        if pending_call_result != 1:
-            raise AssertionError(
-                f"pending call result was {pending_call_result} instead of 1"
-            )
+        # assert old state values before incrementing counter
+        assert pre_state_block_num_call_result == post_state_block_num_call_result - 1
+        assert (
+            pre_state_block_num_call_result
+            == block_hash_call_result
+            == default_call_result
+            == latest_call_result
+        )
 
     def test_eth_uninstall_filter(self, w3: "Web3") -> None:
         filter = w3.eth.filter({})
@@ -4599,22 +4751,24 @@ class EthModuleTest:
     def test_eth_get_raw_transaction_by_block(
         self,
         w3: "Web3",
-        unlocked_account_dual_type: ChecksumAddress,
+        keyfile_account_address_dual_type: ChecksumAddress,
         block_with_txn: BlockData,
     ) -> None:
         # eth_getRawTransactionByBlockNumberAndIndex: block identifier
-        # send a txn to make sure pending block has at least one txn
         w3.eth.send_transaction(
             {
-                "from": unlocked_account_dual_type,
-                "to": unlocked_account_dual_type,
+                "from": keyfile_account_address_dual_type,
+                "to": keyfile_account_address_dual_type,
                 "value": Wei(1),
             }
         )
-        last_pending_txn_index = len(w3.eth.get_block("pending")["transactions"]) - 1
-        raw_transaction = w3.eth.get_raw_transaction_by_block(
-            "pending", last_pending_txn_index
-        )
+        raw_transaction = None
+        while not raw_transaction:
+            try:
+                raw_transaction = w3.eth.get_raw_transaction_by_block("latest", 0)
+            except TransactionNotFound:
+                continue
+
         assert is_bytes(raw_transaction)
 
         # eth_getRawTransactionByBlockNumberAndIndex: block number
@@ -4647,28 +4801,27 @@ class EthModuleTest:
     ) -> None:
         unknown_identifier = "unknown"
         with pytest.raises(
-            ValueError,
+            Web3ValueError,
             match=(
                 "Value did not match any of the recognized block identifiers: "
                 f"{unknown_identifier}"
             ),
         ):
+            # type ignored because we are testing an invalid input
             w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)  # type: ignore
 
     def test_default_account(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
-        # check defaults to empty
-        default_account = w3.eth.default_account
-        assert default_account is empty
+        current_default = w3.eth.default_account
 
         # check setter
-        w3.eth.default_account = unlocked_account_dual_type
+        w3.eth.default_account = keyfile_account_address_dual_type
         default_account = w3.eth.default_account
-        assert default_account == unlocked_account_dual_type
+        assert default_account == keyfile_account_address_dual_type
 
         # reset to default
-        w3.eth.default_account = empty
+        w3.eth.default_account = current_default
 
     def test_default_block(
         self,