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

web3/_utils/module_testing/eth_module.py

@@ -5,6 +5,7 @@ from random import (
     randint,
 )
 import re
+import time
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -82,7 +83,9 @@ from web3.exceptions import (
     TooManyRequests,
     TransactionNotFound,
     TransactionTypeMismatch,
+    Web3RPCError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.middleware import (
     ExtraDataToPOAMiddleware,
@@ -179,11 +182,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,
@@ -199,11 +204,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(
@@ -213,7 +220,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)
 
@@ -229,11 +236,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"),
@@ -243,9 +252,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)
 
@@ -265,11 +274,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"),
@@ -278,7 +289,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"]
@@ -292,7 +303,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 = """
@@ -337,7 +348,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
@@ -346,7 +357,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)
@@ -390,20 +401,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,
@@ -411,7 +423,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"]
@@ -420,11 +432,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")),
@@ -433,7 +445,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"]
@@ -448,9 +460,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",
@@ -462,8 +476,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"]
@@ -475,11 +489,13 @@ 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"),
@@ -498,11 +514,13 @@ class AsyncEthModuleTest:
 
     @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,
         }
@@ -519,11 +537,13 @@ class AsyncEthModuleTest:
 
     @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),
@@ -541,11 +561,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_gas(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "maxFeePerGas": Wei(250 * 10**9),
             "maxPriorityFeePerGas": Wei(2 * 10**9),
@@ -560,11 +582,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_with_gas_price(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": Wei(1),
@@ -576,11 +600,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_priority_fee(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(250 * 10**9),
@@ -592,12 +618,14 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_no_max_fee(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         maxPriorityFeePerGas = async_w3.to_wei(2, "gwei")
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxPriorityFeePerGas": maxPriorityFeePerGas,
@@ -615,11 +643,13 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_send_transaction_max_fee_less_than_tip(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": Wei(1 * 10**9),
@@ -632,14 +662,16 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_validation_middleware_chain_id_mismatch(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         wrong_chain_id = 1234567890
         actual_chain_id = await async_w3.eth.chain_id
 
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
             "maxFeePerGas": async_w3.to_wei(2, "gwei"),
@@ -673,29 +705,34 @@ class AsyncEthModuleTest:
         async_w3.middleware_onion.remove("poa")
 
     @pytest.mark.asyncio
-    async def test_eth_send_raw_transaction(self, async_w3: "AsyncWeb3") -> None:
-        # private key 0x3c2ab4e8f17a7dea191b8c991522660126d681039509dc3bb31af7c9bdb63518
-        # This is an unfunded account, but the transaction has a 0 gas price, so is
-        # valid. It never needs to be mined, we just want the transaction hash back
-        # to confirm.
-        # tx = {'to': '0x0000000000000000000000000000000000000000', 'value': 0,  'nonce': 1, 'gas': 21000, 'gasPrice': 0, 'chainId': 131277322940537}  # noqa: E501
-        # NOTE: nonce=1 to make txn unique from the non-async version of this test
-        raw_txn = HexBytes(
-            "0xf8650180825208940000000000000000000000000000000000000000808086eecac466e115a0ffdd42d7dee4ac85427468bc616812e49432e285e4e8f5cd9381163ac3b28108a04ec6b0d89ecbd5e89b0399f336ad50f283fafd70e86593250bf5a2adfb93d17e"  # noqa: E501
-        )
-        expected_hash = HexStr(
-            "0x52b0ff9cb472f25872fa8ec6a62fa59454fc2ae7901cfcc6cc89d096f49b8fc1"
-        )
-        txn_hash = await async_w3.eth.send_raw_transaction(raw_txn)
-        assert txn_hash == async_w3.to_bytes(hexstr=expected_hash)
+    async def test_async_eth_send_raw_transaction(
+        self, async_w3: "AsyncWeb3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
+        txn = {
+            "chainId": 131277322940537,  # the chainId set for the fixture
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+            "nonce": await async_w3.eth.get_transaction_count(
+                keyfile_account.address, "pending"
+            ),
+            "gasPrice": 10**9,
+        }
+        signed = keyfile_account.sign_transaction(txn)
+        txn_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
+        assert txn_hash == HexBytes(signed.hash)
 
     @pytest.mark.asyncio
     async def test_GasPriceStrategyMiddleware(
-        self, async_w3: "AsyncWeb3", async_unlocked_account_dual_type: ChecksumAddress
+        self,
+        async_w3: "AsyncWeb3",
+        async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account_dual_type,
-            "to": async_unlocked_account_dual_type,
+            "from": async_keyfile_account_address_dual_type,
+            "to": async_keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -714,11 +751,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,
         }
@@ -742,13 +781,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,
@@ -779,11 +818,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),
@@ -803,12 +842,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),
             }
         )
@@ -1043,14 +1084,14 @@ 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),
             }
         )
@@ -1098,7 +1139,7 @@ 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}"
@@ -1152,12 +1193,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
@@ -1180,10 +1221,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
@@ -1294,12 +1337,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",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1313,13 +1356,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",
                 transaction={
-                    "from": async_unlocked_account,
+                    "from": async_keyfile_account_address,
                     "to": async_revert_contract.address,
                 },
             )
@@ -1330,7 +1373,7 @@ 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"]
@@ -1338,7 +1381,7 @@ class AsyncEthModuleTest:
         txn_params = async_revert_contract._prepare_transaction(
             fn_name="customErrorWithMessage",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1350,13 +1393,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")
         txn_params = async_revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
-                "from": async_unlocked_account,
+                "from": async_keyfile_account_address,
                 "to": async_revert_contract.address,
             },
         )
@@ -1399,7 +1442,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(
@@ -1463,7 +1506,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(
@@ -1496,7 +1539,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
             )
@@ -1508,7 +1551,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(
@@ -1532,7 +1575,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:
@@ -1570,7 +1613,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(
@@ -1591,7 +1634,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
@@ -1605,9 +1647,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(
@@ -1661,12 +1701,14 @@ class AsyncEthModuleTest:
 
     @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"),
@@ -1724,12 +1766,14 @@ class AsyncEthModuleTest:
 
     @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"),
@@ -1794,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`
@@ -1991,16 +2035,18 @@ class AsyncEthModuleTest:
             )
 
     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
 
         # 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
@@ -2085,17 +2131,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
             ),
@@ -2103,19 +2152,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
 
@@ -2124,10 +2174,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!"
@@ -2138,11 +2190,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"),
@@ -2166,14 +2220,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,
@@ -2201,11 +2257,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"),
@@ -2217,17 +2275,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"),
@@ -2244,11 +2304,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"),
@@ -2259,17 +2321,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"),
@@ -2281,17 +2343,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"),
@@ -2299,19 +2363,19 @@ class AsyncEthModuleTest:
         txn_hash = await async_w3.eth.send_transaction(txn_params)
 
         txn_params["gasPrice"] = async_w3.to_wei(1, "gwei")
-        with pytest.raises(ValueError):
+        with pytest.raises(Web3ValueError):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_minimum(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = async_w3.to_wei(1, "gwei")
 
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -2329,11 +2393,11 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_higher(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": async_w3.to_wei(1, "gwei"),
@@ -2358,13 +2422,13 @@ class AsyncEthModuleTest:
     @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_lower(
-        self, async_w3: "AsyncWeb3", async_unlocked_account: ChecksumAddress
+        self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = async_w3.to_wei(2, "gwei")
 
         txn_params: TxParams = {
-            "from": async_unlocked_account,
-            "to": async_unlocked_account,
+            "from": async_keyfile_account_address,
+            "to": async_keyfile_account_address,
             "value": Wei(1),
             "gas": 21000,
             "gasPrice": gas_price,
@@ -2620,17 +2684,19 @@ class EthModuleTest:
             )
 
     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")
@@ -2728,12 +2794,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
@@ -2755,17 +2821,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
             ),
@@ -2773,25 +2839,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!"
             )
@@ -2801,7 +2870,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 = """
@@ -2846,7 +2915,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
@@ -2854,7 +2923,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)
@@ -2898,19 +2967,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,
@@ -2918,7 +2987,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"]
@@ -2926,11 +2995,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"),
@@ -2939,7 +3008,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"]
@@ -2950,11 +3019,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")),
@@ -2963,7 +3032,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"]
@@ -2974,9 +3043,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",
@@ -2988,8 +3057,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"]
@@ -3000,12 +3069,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"),
@@ -3025,11 +3094,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(
@@ -3046,11 +3115,11 @@ 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"),
@@ -3068,20 +3137,22 @@ class EthModuleTest:
         assert txn["gasPrice"] == txn_params["maxFeePerGas"]
 
     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)
@@ -3097,11 +3168,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,
         }
@@ -3117,11 +3188,11 @@ class EthModuleTest:
         assert txn["gasPrice"] == txn["maxFeePerGas"]
 
     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),
@@ -3138,11 +3209,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),
@@ -3156,11 +3227,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),
@@ -3171,11 +3242,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),
@@ -3186,12 +3257,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,
@@ -3208,11 +3279,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),
@@ -3224,14 +3295,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"),
@@ -3249,12 +3320,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,
@@ -3284,11 +3358,11 @@ class EthModuleTest:
     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),
@@ -3307,11 +3381,11 @@ class EthModuleTest:
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
     def test_gas_price_strategy_hex_value(
-        self, w3: "Web3", unlocked_account_dual_type: ChecksumAddress
+        self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
         txn_params: TxParams = {
-            "from": unlocked_account_dual_type,
-            "to": unlocked_account_dual_type,
+            "from": keyfile_account_address_dual_type,
+            "to": keyfile_account_address_dual_type,
             "value": Wei(1),
             "gas": 21000,
         }
@@ -3330,11 +3404,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(
@@ -3359,14 +3433,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,
@@ -3393,11 +3467,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"),
@@ -3409,16 +3483,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"),
@@ -3434,11 +3508,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"),
@@ -3449,16 +3523,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"),
@@ -3470,16 +3544,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"),
@@ -3487,18 +3561,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,
@@ -3515,11 +3589,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"),
@@ -3543,13 +3617,13 @@ 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,
@@ -3569,11 +3643,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(
@@ -3583,7 +3657,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)
 
@@ -3598,11 +3672,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"),
@@ -3612,9 +3686,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)
 
@@ -3633,23 +3707,21 @@ 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
@@ -3743,12 +3815,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",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3763,13 +3835,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",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -3779,7 +3851,7 @@ 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"]
@@ -3787,7 +3859,7 @@ class EthModuleTest:
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3799,13 +3871,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")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -3847,7 +3919,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(
@@ -3902,7 +3974,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(
@@ -3933,7 +4005,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()
@@ -3944,7 +4016,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(
@@ -3966,7 +4038,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:
@@ -4003,7 +4075,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(
@@ -4022,7 +4094,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
@@ -4035,9 +4106,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(
@@ -4054,7 +4123,7 @@ 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"
@@ -4062,7 +4131,7 @@ class EthModuleTest:
             txn_params = revert_contract._prepare_transaction(
                 fn_name="revertWithMessage",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -4072,13 +4141,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",
                 transaction={
-                    "from": unlocked_account,
+                    "from": keyfile_account_address,
                     "to": revert_contract.address,
                 },
             )
@@ -4088,7 +4157,7 @@ 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"]
@@ -4096,7 +4165,7 @@ class EthModuleTest:
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -4108,13 +4177,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")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
-                "from": unlocked_account,
+                "from": keyfile_account_address,
                 "to": revert_contract.address,
             },
         )
@@ -4123,12 +4192,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),
             }
         )
@@ -4136,12 +4205,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",
@@ -4322,12 +4391,12 @@ class EthModuleTest:
         assert effective_gas_price > 0
 
     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"),
@@ -4379,12 +4448,12 @@ class EthModuleTest:
         assert effective_gas_price > 0
 
     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"),
@@ -4482,7 +4551,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`
@@ -4591,35 +4660,35 @@ 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"]
-
-        math_contract.functions.incrementCounter().transact({"from": unlocked_account})
+        latest_block = w3.eth.get_block("latest")
+        block_num = latest_block["number"]
+        block_hash = latest_block["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
+        latest_call_result = math_contract.functions.counter().call(
+            block_identifier="latest"
+        )
         block_hash_call_result = math_contract.functions.counter().call(
             block_identifier=block_hash
         )
         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()
+
+        # send and wait 1 second to mine
+        math_contract.functions.incrementCounter().transact(
+            {"from": keyfile_account_address}
+        )
+        time.sleep(1)
+
         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
@@ -4653,15 +4722,15 @@ 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),
             }
         )
@@ -4701,7 +4770,7 @@ 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}"
@@ -4710,16 +4779,16 @@ class EthModuleTest:
             w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)
 
     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
 
         # 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