web3 6.20.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/_utils/module_testing/eth_module.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import math
 import pytest
@@ -10,6 +11,7 @@ from typing import (
     Any,
     Callable,
     List,
+    Type,
     Union,
     cast,
 )
@@ -40,15 +42,15 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.empty import (
-    empty,
-)
 from web3._utils.ens import (
     ens_addresses,
 )
 from web3._utils.error_formatters_utils import (
     PANIC_ERROR_CODES,
 )
+from web3._utils.fee_utils import (
+    PRIORITY_FEE_MIN,
+)
 from web3._utils.method_formatters import (
     to_hex_if_integer,
 )
@@ -56,8 +58,12 @@ from web3._utils.module_testing.module_testing_utils import (
     assert_contains_log,
     async_mock_offchain_lookup_request_response,
     flaky_geth_dev_mining,
+    flaky_with_xfail_on_exception,
     mock_offchain_lookup_request_response,
 )
+from web3._utils.module_testing.utils import (
+    RequestMocker,
+)
 from web3._utils.type_conversion import (
     to_hex_if_bytes,
 )
@@ -71,27 +77,25 @@ from web3.exceptions import (
     MultipleFailedRequests,
     NameNotFound,
     OffchainLookup,
+    RequestTimedOut,
     TimeExhausted,
     TooManyRequests,
     TransactionNotFound,
     TransactionTypeMismatch,
+    Web3RPCError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.middleware import (
-    async_geth_poa_middleware,
-)
-from web3.middleware.fixture import (
-    async_construct_error_generator_middleware,
-    async_construct_result_generator_middleware,
-    construct_error_generator_middleware,
+    ExtraDataToPOAMiddleware,
 )
 from web3.types import (
     ENS,
     BlockData,
-    CallOverrideParams,
     FilterParams,
     Nonce,
     RPCEndpoint,
+    StateOverrideParams,
     SyncStatus,
     TxData,
     TxParams,
@@ -177,11 +181,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,
@@ -197,11 +203,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(
@@ -211,7 +219,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)
 
@@ -227,11 +235,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"),
@@ -241,9 +251,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)
 
@@ -263,11 +273,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"),
@@ -276,7 +288,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"]
@@ -290,7 +302,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 = """
@@ -335,7 +347,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
@@ -344,7 +356,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)
@@ -388,20 +400,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,
@@ -409,7 +422,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"]
@@ -418,11 +431,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")),
@@ -431,7 +444,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"]
@@ -446,9 +459,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",
@@ -460,8 +475,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"]
@@ -473,16 +488,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)
 
@@ -492,18 +510,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)
 
@@ -513,15 +534,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),
@@ -539,11 +562,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),
@@ -558,11 +583,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),
@@ -574,11 +601,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),
@@ -590,12 +619,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,
@@ -613,11 +644,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),
@@ -630,14 +663,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"),
@@ -652,52 +687,53 @@ class AsyncEthModuleTest:
             await async_w3.eth.send_transaction(txn_params)
 
     @pytest.mark.asyncio
-    async def test_geth_poa_middleware(self, async_w3: "AsyncWeb3") -> None:
-        return_block_with_long_extra_data = (
-            await async_construct_result_generator_middleware(
-                {
-                    RPCEndpoint("eth_getBlockByNumber"): lambda *_: {
-                        "extraData": "0x" + "ff" * 33
-                    },
-                }
-            )
-        )
-        async_w3.middleware_onion.inject(async_geth_poa_middleware, "poa", layer=0)
-        async_w3.middleware_onion.inject(
-            return_block_with_long_extra_data, "extradata", layer=0
-        )
-        block = await async_w3.eth.get_block("latest")
+    async def test_ExtraDataToPOAMiddleware(
+        self, async_w3: "AsyncWeb3", request_mocker: Type[RequestMocker]
+    ) -> None:
+        async_w3.middleware_onion.inject(ExtraDataToPOAMiddleware, "poa", layer=0)
+        extra_data = f"0x{'ff' * 33}"
+
+        async with request_mocker(
+            async_w3,
+            mock_results={"eth_getBlockByNumber": {"extraData": extra_data}},
+        ):
+            block = await async_w3.eth.get_block("latest")
+
         assert "extraData" not in block
-        assert block["proofOfAuthorityData"] == b"\xff" * 33
+        assert block["proofOfAuthorityData"] == to_bytes(hexstr=extra_data)
 
         # clean up
         async_w3.middleware_onion.remove("poa")
-        async_w3.middleware_onion.remove("extradata")
 
     @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_gas_price_strategy_middleware(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+    async def test_GasPriceStrategyMiddleware(
+        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,
         }
@@ -716,11 +752,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,
         }
@@ -744,13 +782,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,
@@ -773,7 +811,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
 
@@ -781,11 +819,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),
@@ -805,12 +843,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),
             }
         )
@@ -841,9 +881,10 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_math_contract: "AsyncContract",
-        params: CallOverrideParams,
+        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(
@@ -891,60 +932,25 @@ class AsyncEthModuleTest:
         max_priority_fee = await async_w3.eth.max_priority_fee
         assert is_integer(max_priority_fee)
 
-    @pytest.mark.asyncio
-    async def test_eth_max_priority_fee_with_fee_history_calculation_error_dict(
-        self, async_w3: "AsyncWeb3"
-    ) -> None:
-        fail_max_prio_middleware = await async_construct_error_generator_middleware(
-            {
-                RPCEndpoint("eth_maxPriorityFeePerGas"): lambda *_: {
-                    "error": {
-                        "code": -32601,
-                        "message": (
-                            "The method eth_maxPriorityFeePerGas does "
-                            "not exist/is not available"
-                        ),
-                    }
-                }
-            }
-        )
-        async_w3.middleware_onion.add(
-            fail_max_prio_middleware, name="fail_max_prio_middleware"
-        )
-
-        with pytest.warns(
-            UserWarning,
-            match=(
-                "There was an issue with the method eth_maxPriorityFeePerGas."
-                " Calculating using eth_feeHistory."
-            ),
-        ):
-            await async_w3.eth.max_priority_fee
-
-        async_w3.middleware_onion.remove("fail_max_prio_middleware")  # clean up
-
     @pytest.mark.asyncio
     async def test_eth_max_priority_fee_with_fee_history_calculation(
-        self, async_w3: "AsyncWeb3"
+        self, async_w3: "AsyncWeb3", request_mocker: Type[RequestMocker]
     ) -> None:
-        fail_max_prio_middleware = await async_construct_error_generator_middleware(
-            {RPCEndpoint("eth_maxPriorityFeePerGas"): lambda *_: ""}
-        )
-        async_w3.middleware_onion.add(
-            fail_max_prio_middleware, name="fail_max_prio_middleware"
-        )
-
-        with pytest.warns(
-            UserWarning,
-            match=(
-                "There was an issue with the method eth_maxPriorityFeePerGas. "
-                "Calculating using eth_feeHistory."
-            ),
+        async with request_mocker(
+            async_w3,
+            mock_errors={RPCEndpoint("eth_maxPriorityFeePerGas"): {}},
+            mock_results={RPCEndpoint("eth_feeHistory"): {"reward": [[0]]}},
         ):
-            max_priority_fee = await async_w3.eth.max_priority_fee
-            assert is_integer(max_priority_fee)
-
-        async_w3.middleware_onion.remove("fail_max_prio_middleware")  # clean up
+            with pytest.warns(
+                UserWarning,
+                match=(
+                    "There was an issue with the method eth_maxPriorityFeePerGas. "
+                    "Calculating using eth_feeHistory."
+                ),
+            ):
+                priority_fee = await async_w3.eth.max_priority_fee
+                assert is_integer(priority_fee)
+                assert priority_fee == PRIORITY_FEE_MIN
 
     @pytest.mark.asyncio
     async def test_eth_getBlockByHash(
@@ -974,9 +980,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(
@@ -989,9 +994,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(
@@ -1018,6 +1022,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
@@ -1047,22 +1084,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
@@ -1102,26 +1143,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
@@ -1158,12 +1199,12 @@ class AsyncEthModuleTest:
     async def test_eth_create_access_list(
         self,
         async_w3: "AsyncWeb3",
-        async_unlocked_account_dual_type: ChecksumAddress,
+        async_keyfile_account_address_dual_type: ChecksumAddress,
         async_math_contract: "AsyncContract",
     ) -> None:
         # build txn
         txn = await async_math_contract.functions.incrementCounter(1).build_transaction(
-            {"from": async_unlocked_account_dual_type}
+            {"from": async_keyfile_account_address_dual_type}
         )
 
         # create access list
@@ -1174,7 +1215,7 @@ class AsyncEthModuleTest:
         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
@@ -1186,10 +1227,12 @@ class AsyncEthModuleTest:
 
     @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
@@ -1198,11 +1241,13 @@ class AsyncEthModuleTest:
     async def test_eth_call(
         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)
@@ -1215,10 +1260,11 @@ class AsyncEthModuleTest:
         async_w3: "AsyncWeb3",
         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)
@@ -1270,10 +1316,10 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_math_contract: "AsyncContract",
-        params: CallOverrideParams,
+        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(
@@ -1284,11 +1330,11 @@ class AsyncEthModuleTest:
     async def test_eth_call_with_0_result(
         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)
@@ -1300,12 +1346,12 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_revert_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        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,
             },
         )
@@ -1319,13 +1365,13 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_revert_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        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,
                 },
             )
@@ -1336,15 +1382,16 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_revert_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
         data = async_revert_contract.encode_abi(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+            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,
             },
         )
@@ -1356,13 +1403,13 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_revert_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encode_abi(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,
             },
         )
@@ -1405,7 +1452,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_offchain_lookup_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1469,7 +1516,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_offchain_lookup_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1502,7 +1549,7 @@ class AsyncEthModuleTest:
         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
             )
@@ -1514,7 +1561,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_offchain_lookup_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1538,7 +1585,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_offchain_lookup_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
         status_code_non_4xx_error: int,
     ) -> None:
@@ -1576,7 +1623,7 @@ class AsyncEthModuleTest:
         self,
         async_w3: "AsyncWeb3",
         async_offchain_lookup_contract: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
+        async_keyfile_account_address: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1597,7 +1644,6 @@ 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: "AsyncContract",
     ) -> None:
         # GET and POST requests should fail since responses are not mocked
@@ -1611,9 +1657,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: "AsyncContract",
-        async_unlocked_account: ChecksumAddress,
         monkeypatch: "MonkeyPatch",
     ) -> None:
         normalized_contract_address = to_hex_if_bytes(
@@ -1627,23 +1671,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,
@@ -1665,14 +1698,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"),
@@ -1728,14 +1764,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"),
@@ -1779,8 +1818,7 @@ class AsyncEthModuleTest:
         accounts = await async_w3.eth.accounts
         assert is_list_like(accounts)
         assert len(accounts) != 0
-        assert all((is_checksum_address(account) for account in accounts))
-        assert 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_get_logs_without_logs(
@@ -1800,7 +1838,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`
@@ -1990,26 +2028,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,
@@ -2091,17 +2129,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
             ),
@@ -2109,19 +2150,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
 
@@ -2130,10 +2172,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!"
@@ -2144,11 +2188,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"),
@@ -2172,14 +2218,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,
@@ -2207,11 +2255,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"),
@@ -2223,17 +2273,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"),
@@ -2250,11 +2302,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"),
@@ -2265,17 +2319,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"),
@@ -2287,17 +2341,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"),
@@ -2305,19 +2361,22 @@ 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
+    @flaky_with_xfail_on_exception(
+        reason="Very flaky on CI runs, hard to reproduce locally.",
+        exception=RequestTimedOut,
+    )
     @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,
@@ -2332,14 +2391,17 @@ class AsyncEthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
-    @flaky_geth_dev_mining
+    @flaky_with_xfail_on_exception(
+        reason="Very flaky on CI runs, hard to reproduce locally.",
+        exception=RequestTimedOut,
+    )
     @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"),
@@ -2361,16 +2423,19 @@ class AsyncEthModuleTest:
         )  # Strategy provides higher gas price
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_geth_dev_mining
+    @flaky_with_xfail_on_exception(
+        reason="Very flaky on CI runs, hard to reproduce locally.",
+        exception=RequestTimedOut,
+    )
     @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,
@@ -2459,19 +2524,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
@@ -2515,65 +2567,30 @@ class EthModuleTest:
         max_priority_fee = w3.eth.max_priority_fee
         assert is_integer(max_priority_fee)
 
-    def test_eth_max_priority_fee_with_fee_history_calculation_error_dict(
-        self, w3: "Web3"
-    ) -> None:
-        fail_max_prio_middleware = construct_error_generator_middleware(
-            {
-                RPCEndpoint("eth_maxPriorityFeePerGas"): lambda *_: {
-                    "error": {
-                        "code": -32601,
-                        "message": (
-                            "The method eth_maxPriorityFeePerGas does "
-                            "not exist/is not available"
-                        ),
-                    }
-                }
-            }
-        )
-        w3.middleware_onion.add(
-            fail_max_prio_middleware, name="fail_max_prio_middleware"
-        )
-
-        with pytest.warns(
-            UserWarning,
-            match=(
-                "There was an issue with the method eth_maxPriorityFeePerGas."
-                " Calculating using eth_feeHistory."
-            ),
-        ):
-            w3.eth.max_priority_fee
-
-        w3.middleware_onion.remove("fail_max_prio_middleware")  # clean up
-
     def test_eth_max_priority_fee_with_fee_history_calculation(
-        self, w3: "Web3"
+        self, w3: "Web3", request_mocker: Type[RequestMocker]
     ) -> None:
-        fail_max_prio_middleware = construct_error_generator_middleware(
-            {RPCEndpoint("eth_maxPriorityFeePerGas"): lambda *_: ""}
-        )
-        w3.middleware_onion.add(
-            fail_max_prio_middleware, name="fail_max_prio_middleware"
-        )
-
-        with pytest.warns(
-            UserWarning,
-            match=(
-                "There was an issue with the method eth_maxPriorityFeePerGas."
-                " Calculating using eth_feeHistory."
-            ),
+        with request_mocker(
+            w3,
+            mock_errors={RPCEndpoint("eth_maxPriorityFeePerGas"): {}},
+            mock_results={RPCEndpoint("eth_feeHistory"): {"reward": [[0]]}},
         ):
-            max_priority_fee = w3.eth.max_priority_fee
-            assert is_integer(max_priority_fee)
-
-        w3.middleware_onion.remove("fail_max_prio_middleware")  # clean up
+            with pytest.warns(
+                UserWarning,
+                match=(
+                    "There was an issue with the method eth_maxPriorityFeePerGas. "
+                    "Calculating using eth_feeHistory."
+                ),
+            ):
+                max_priority_fee = w3.eth.max_priority_fee
+                assert is_integer(max_priority_fee)
+                assert max_priority_fee == PRIORITY_FEE_MIN
 
     def test_eth_accounts(self, w3: "Web3") -> None:
         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_block_number(self, w3: "Web3") -> None:
         block_number = w3.eth.block_number
@@ -2586,12 +2603,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
@@ -2653,24 +2670,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")
@@ -2679,10 +2698,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(
@@ -2768,12 +2787,12 @@ 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:
         # build txn
         txn = math_contract.functions.incrementCounter(1).build_transaction(
-            {"from": unlocked_account_dual_type}
+            {"from": keyfile_account_address_dual_type}
         )
 
         # create access list
@@ -2784,7 +2803,7 @@ class EthModuleTest:
         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
@@ -2795,17 +2814,17 @@ class EthModuleTest:
         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
             ),
@@ -2813,25 +2832,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!"
             )
@@ -2841,7 +2863,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 = """
@@ -2886,7 +2908,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
@@ -2894,7 +2916,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)
@@ -2938,19 +2960,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,
@@ -2958,7 +2980,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"]
@@ -2966,11 +2988,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"),
@@ -2979,7 +3001,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"]
@@ -2990,11 +3012,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")),
@@ -3003,7 +3025,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"]
@@ -3014,9 +3036,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",
@@ -3028,8 +3050,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"]
@@ -3040,12 +3062,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"),
@@ -3065,11 +3087,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(
@@ -3086,16 +3108,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)
 
@@ -3105,23 +3128,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)
@@ -3137,11 +3162,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,
         }
@@ -3154,14 +3179,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),
@@ -3178,11 +3203,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),
@@ -3196,11 +3221,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),
@@ -3211,11 +3236,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),
@@ -3226,12 +3251,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,
@@ -3248,11 +3273,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),
@@ -3264,14 +3289,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"),
@@ -3289,12 +3314,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,
@@ -3317,18 +3345,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),
@@ -3346,12 +3374,12 @@ class EthModuleTest:
 
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    def test_gas_price_strategy_middleware_hex_value(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+    def test_gas_price_strategy_hex_value(
+        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,
         }
@@ -3370,11 +3398,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(
@@ -3399,14 +3427,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,
@@ -3433,11 +3461,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"),
@@ -3449,16 +3477,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"),
@@ -3474,11 +3502,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"),
@@ -3489,16 +3517,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"),
@@ -3510,16 +3538,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"),
@@ -3527,18 +3555,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,
@@ -3555,11 +3583,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"),
@@ -3583,13 +3611,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,
@@ -3609,11 +3636,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(
@@ -3623,7 +3650,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)
 
@@ -3638,11 +3665,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"),
@@ -3652,9 +3679,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)
 
@@ -3673,30 +3700,27 @@ 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",
-        )
-        txn_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
-        assert txn_hash == signed_tx.hash
+        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_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)
@@ -3706,10 +3730,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)
@@ -3758,9 +3781,9 @@ class EthModuleTest:
         self,
         w3: "Web3",
         math_contract: "Contract",
-        params: CallOverrideParams,
+        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})
@@ -3768,11 +3791,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)
@@ -3783,12 +3805,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,
             },
         )
@@ -3803,13 +3825,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,
                 },
             )
@@ -3819,15 +3841,16 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         data = revert_contract.encode_abi(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+            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,
             },
         )
@@ -3839,13 +3862,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encode_abi(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,
             },
         )
@@ -3887,7 +3910,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(
@@ -3942,7 +3965,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(
@@ -3973,7 +3996,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()
@@ -3984,7 +4007,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(
@@ -4006,7 +4029,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:
@@ -4043,7 +4066,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(
@@ -4062,7 +4085,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
@@ -4075,9 +4097,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(
@@ -4094,15 +4114,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,
                 },
             )
@@ -4112,13 +4132,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,
                 },
             )
@@ -4128,15 +4148,16 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
         data = revert_contract.encode_abi(
-            fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
+            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,
             },
         )
@@ -4148,13 +4169,13 @@ class EthModuleTest:
         self,
         w3: "Web3",
         revert_contract: "Contract",
-        unlocked_account: ChecksumAddress,
+        keyfile_account_address: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encode_abi(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,
             },
         )
@@ -4163,12 +4184,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),
             }
         )
@@ -4176,12 +4197,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",
@@ -4212,9 +4233,9 @@ class EthModuleTest:
         self,
         w3: "Web3",
         math_contract: "Contract",
-        params: CallOverrideParams,
+        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})
@@ -4241,12 +4262,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
@@ -4287,8 +4305,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)
@@ -4333,13 +4379,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"),
@@ -4390,13 +4437,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"),
@@ -4494,7 +4542,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`
@@ -4603,44 +4651,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"]
 
-        math_contract.functions.incrementCounter().transact({"from": unlocked_account})
+        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)
 
-        # 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
+        # get new state value
+        post_state_block_num_call_result = math_contract.functions.counter().call(
+            block_identifier=tx_receipt["blockNumber"]
+        )
+
+        # 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({})
@@ -4665,22 +4716,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
@@ -4713,28 +4766,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,