web3 7.10.0__py3-none-any.whl → 7.11.1__py3-none-any.whl

web3/_utils/module_testing/eth_module.py

@@ -57,7 +57,6 @@ from web3._utils.method_formatters import (
 from web3._utils.module_testing.module_testing_utils import (
     assert_contains_log,
     async_mock_offchain_lookup_request_response,
-    flaky_geth_dev_mining,
     mock_offchain_lookup_request_response,
 )
 from web3._utils.module_testing.utils import (
@@ -115,27 +114,6 @@ OFFCHAIN_LOOKUP_RETURN_DATA = "0000000000000000000000000000000000000000000000000
 # "web3py" as an abi-encoded string
 WEB3PY_AS_HEXBYTES = "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000067765623370790000000000000000000000000000000000000000000000000000"  # noqa: E501
 
-RLP_ACCESS_LIST = [
-    (
-        "0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae",
-        (
-            "0x0000000000000000000000000000000000000000000000000000000000000003",
-            "0x0000000000000000000000000000000000000000000000000000000000000007",
-        ),
-    ),
-    ("0xbb9bc244d798123fde783fcc1c72d3bb8c189413", ()),
-]
-
-RPC_ACCESS_LIST = [
-    {
-        "address": "0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae",
-        "storageKeys": (
-            "0x0000000000000000000000000000000000000000000000000000000000000003",
-            "0x0000000000000000000000000000000000000000000000000000000000000007",
-        ),
-    },
-    {"address": "0xbb9bc244d798123fde783fcc1c72d3bb8c189413", "storageKeys": ()},
-]
 
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch  # noqa: F401
@@ -454,9 +432,6 @@ class AsyncEthModuleTest:
         assert result["tx"]["nonce"] == txn_params["nonce"]
 
     @pytest.mark.asyncio
-    @pytest.mark.xfail(
-        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_keyfile_account_address: ChecksumAddress
     ) -> None:
@@ -638,9 +613,6 @@ class AsyncEthModuleTest:
         assert txn["value"] == 1
         assert txn["gas"] == 21000
 
-        block = await async_w3.eth.get_block("latest")
-        assert txn["maxFeePerGas"] == maxPriorityFeePerGas + 2 * block["baseFeePerGas"]
-
     @pytest.mark.asyncio
     async def test_eth_send_transaction_max_fee_less_than_tip(
         self,
@@ -744,6 +716,97 @@ class AsyncEthModuleTest:
         # clean up
         async_w3.middleware_onion.remove("signing")
 
+    @pytest.mark.asyncio
+    async def test_async_sign_authorization_and_send_raw_set_code_transaction(
+        self,
+        async_w3: "AsyncWeb3",
+        keyfile_account_pkey: HexStr,
+        async_math_contract: "AsyncContract",
+    ) -> None:
+        # TODO: remove blockNumber block_id from eth_call and eth_getCode calls once
+        #  geth behavior for "latest" seems stable again.
+        keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
+
+        chain_id = await async_w3.eth.chain_id
+        nonce = await async_w3.eth.get_transaction_count(keyfile_account.address)
+
+        auth = {
+            "chainId": chain_id,
+            "address": async_math_contract.address,
+            "nonce": nonce + 1,
+        }
+        signed_auth = keyfile_account.sign_authorization(auth)
+
+        # get current math counter and increase it only in the delegation by n
+        math_counter = await async_math_contract.functions.counter().call()
+        data = async_math_contract.encode_abi("incrementCounter", [math_counter + 1337])
+        txn: TxParams = {
+            "chainId": chain_id,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 200_000,
+            "nonce": nonce,
+            "maxPriorityFeePerGas": Wei(10**9),
+            "maxFeePerGas": Wei(10**9),
+            "data": data,
+            "authorizationList": [signed_auth],
+        }
+
+        signed = keyfile_account.sign_transaction(txn)
+        tx_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
+        get_tx = await async_w3.eth.get_transaction(tx_hash)
+        tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
+            tx_hash, timeout=10
+        )
+
+        code = await async_w3.eth.get_code(
+            keyfile_account.address, block_identifier=tx_receipt["blockNumber"]
+        )
+        assert code.to_0x_hex() == f"0xef0100{async_math_contract.address[2:].lower()}"
+        delegated = async_w3.eth.contract(
+            address=keyfile_account.address, abi=async_math_contract.abi
+        )
+
+        # assert the math counter is increased by 1337 only in delegated acct
+        assert await async_math_contract.functions.counter().call() == math_counter
+        delegated_call = await delegated.functions.counter().call(
+            block_identifier=tx_receipt["blockNumber"]
+        )
+        assert delegated_call == math_counter + 1337
+
+        assert len(get_tx["authorizationList"]) == 1
+        get_auth = get_tx["authorizationList"][0]
+        assert get_auth["chainId"] == chain_id
+        assert get_auth["address"] == async_math_contract.address
+        assert get_auth["nonce"] == nonce + 1
+        assert isinstance(get_auth["yParity"], int)
+        assert isinstance(get_auth["r"], HexBytes)
+        assert isinstance(get_auth["s"], HexBytes)
+
+        # reset code
+        reset_auth = {
+            "chainId": chain_id,
+            "address": "0x" + ("00" * 20),
+            "nonce": nonce + 3,
+        }
+        signed_reset_auth = keyfile_account.sign_authorization(reset_auth)
+        new_txn = dict(txn)
+        new_txn["authorizationList"] = [signed_reset_auth]
+        new_txn["nonce"] = nonce + 2
+
+        signed_reset = keyfile_account.sign_transaction(new_txn)
+        reset_tx_hash = await async_w3.eth.send_raw_transaction(
+            signed_reset.raw_transaction
+        )
+        reset_tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
+            reset_tx_hash, timeout=10
+        )
+
+        reset_code = await async_w3.eth.get_code(
+            keyfile_account.address, reset_tx_receipt["blockNumber"]
+        )
+        assert reset_code == HexBytes("0x")
+
     @pytest.mark.asyncio
     async def test_GasPriceStrategyMiddleware(
         self,
@@ -1763,7 +1826,6 @@ 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,
@@ -1829,8 +1891,11 @@ class AsyncEthModuleTest:
         assert isinstance(effective_gas_price, int)
         assert effective_gas_price > 0
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
+    # TODO: Remove xfail when issue has been identified
+    @pytest.mark.xfail(
+        reason="latest geth seems to cause this to be flaky", strict=False
+    )
     async def test_async_eth_wait_for_transaction_receipt_unmined(
         self,
         async_w3: "AsyncWeb3",
@@ -2086,7 +2151,6 @@ class AsyncEthModuleTest:
         assert bytes(slot_4[:4]) == b"four"
 
     @pytest.mark.asyncio
-    @pytest.mark.xfail
     async def test_async_eth_get_storage_at_ens_name(
         self, async_w3: "AsyncWeb3", async_storage_contract: "AsyncContract"
     ) -> None:
@@ -2172,19 +2236,31 @@ class AsyncEthModuleTest:
     async def test_eth_getUncleCountByBlockHash(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        uncle_count = await async_w3.eth.get_uncle_count(async_empty_block["hash"])
+        with pytest.warns(
+            DeprecationWarning,
+            match=r"get_uncle_count is deprecated: all get_uncle\* "
+            r"methods will be removed in v8",
+        ):
+            uncle_count = await async_w3.eth.get_uncle_count(async_empty_block["hash"])
 
-        assert is_integer(uncle_count)
-        assert uncle_count == 0
+            assert is_integer(uncle_count)
+            assert uncle_count == 0
 
     @pytest.mark.asyncio
     async def test_eth_getUncleCountByBlockNumber(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        uncle_count = await async_w3.eth.get_uncle_count(async_empty_block["number"])
+        with pytest.warns(
+            DeprecationWarning,
+            match=r"get_uncle_count is deprecated: all get_uncle\* "
+            r"methods will be removed in v8",
+        ):
+            uncle_count = await async_w3.eth.get_uncle_count(
+                async_empty_block["number"]
+            )
 
-        assert is_integer(uncle_count)
-        assert uncle_count == 0
+            assert is_integer(uncle_count)
+            assert uncle_count == 0
 
     @pytest.mark.asyncio
     async def test_eth_getBlockTransactionCountByNumber_block_with_txn(
@@ -2238,9 +2314,6 @@ class AsyncEthModuleTest:
         assert new_signature != signature
 
     @pytest.mark.asyncio
-    @pytest.mark.xfail(
-        reason="Async middleware to convert ENS names to addresses is missing"
-    )
     async def test_async_eth_sign_ens_names(
         self,
         async_w3: "AsyncWeb3",
@@ -2255,7 +2328,6 @@ class AsyncEthModuleTest:
             assert is_bytes(signature)
             assert len(signature) == 32 + 32 + 1
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_legacy(
         self,
@@ -2285,7 +2357,6 @@ class AsyncEthModuleTest:
         assert replace_txn["gas"] == 21000
         assert replace_txn["gasPrice"] == txn_params["gasPrice"]
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction(
         self,
@@ -2322,7 +2393,6 @@ class AsyncEthModuleTest:
         assert replace_txn["maxFeePerGas"] == three_gwei_in_wei
         assert replace_txn["maxPriorityFeePerGas"] == two_gwei_in_wei
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_underpriced(
         self,
@@ -2349,7 +2419,6 @@ class AsyncEthModuleTest:
         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,
@@ -2372,7 +2441,6 @@ class AsyncEthModuleTest:
                 txn_params,
             )
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_already_mined(
         self,
@@ -2395,7 +2463,6 @@ class AsyncEthModuleTest:
         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_keyfile_account_address: ChecksumAddress
@@ -2417,7 +2484,6 @@ class AsyncEthModuleTest:
         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,
@@ -2437,7 +2503,6 @@ class AsyncEthModuleTest:
         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_keyfile_account_address: ChecksumAddress
@@ -2461,7 +2526,6 @@ class AsyncEthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_higher(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2490,7 +2554,6 @@ class AsyncEthModuleTest:
         )  # Strategy provides higher gas price
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_lower(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2682,13 +2745,15 @@ class EthModuleTest:
         assert balance >= 0
 
     def test_eth_get_balance_with_block_identifier(self, w3: "Web3") -> None:
-        miner_address = w3.eth.get_block(1)["miner"]
-        balance_post_genesis = w3.eth.get_balance(miner_address, 1)
+        genesis_block = w3.eth.get_block(0)
+        miner_address = genesis_block["miner"]
+
+        balance_genesis = w3.eth.get_balance(miner_address, 0)
         later_balance = w3.eth.get_balance(miner_address, "latest")
 
-        assert is_integer(balance_post_genesis)
+        assert is_integer(balance_genesis)
         assert is_integer(later_balance)
-        assert later_balance > balance_post_genesis
+        assert later_balance != balance_genesis
 
     @pytest.mark.parametrize(
         "address, expect_success",
@@ -2807,18 +2872,24 @@ class EthModuleTest:
     def test_eth_getUncleCountByBlockHash(
         self, w3: "Web3", empty_block: BlockData
     ) -> None:
-        uncle_count = w3.eth.get_uncle_count(empty_block["hash"])
+        with pytest.warns(
+            DeprecationWarning, match=r"All get_uncle\* methods have been deprecated"
+        ):
+            uncle_count = w3.eth.get_uncle_count(empty_block["hash"])
 
-        assert is_integer(uncle_count)
-        assert uncle_count == 0
+            assert is_integer(uncle_count)
+            assert uncle_count == 0
 
     def test_eth_getUncleCountByBlockNumber(
         self, w3: "Web3", empty_block: BlockData
     ) -> None:
-        uncle_count = w3.eth.get_uncle_count(empty_block["number"])
+        with pytest.warns(
+            DeprecationWarning, match=r"All get_uncle\* methods have been deprecated"
+        ):
+            uncle_count = w3.eth.get_uncle_count(empty_block["number"])
 
-        assert is_integer(uncle_count)
-        assert uncle_count == 0
+            assert is_integer(uncle_count)
+            assert uncle_count == 0
 
     def test_eth_get_code(
         self, w3: "Web3", math_contract_address: ChecksumAddress
@@ -3464,7 +3535,6 @@ class EthModuleTest:
         assert txn["gasPrice"] == two_gwei_in_wei
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction_legacy(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3493,7 +3563,6 @@ class EthModuleTest:
         assert replace_txn["gas"] == 21000
         assert replace_txn["gasPrice"] == txn_params["gasPrice"]
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3527,7 +3596,6 @@ class EthModuleTest:
         assert replace_txn["maxFeePerGas"] == three_gwei_in_wei
         assert replace_txn["maxPriorityFeePerGas"] == two_gwei_in_wei
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction_underpriced(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3551,7 +3619,6 @@ class EthModuleTest:
         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", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3571,7 +3638,6 @@ class EthModuleTest:
                 txn_params,
             )
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction_already_mined(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3591,7 +3657,6 @@ class EthModuleTest:
         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", keyfile_account_address: ChecksumAddress
     ) -> None:
@@ -3612,7 +3677,6 @@ class EthModuleTest:
         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", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -3629,7 +3693,6 @@ class EthModuleTest:
         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", keyfile_account_address: ChecksumAddress
     ) -> None:
@@ -3652,7 +3715,6 @@ class EthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_defaulting_strategy_higher(
         self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
@@ -3680,7 +3742,6 @@ class EthModuleTest:
         )  # Strategy provides higher gas price
         w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_geth_dev_mining
     def test_eth_replace_transaction_gas_price_defaulting_strategy_lower(
         self, w3: "Web3", keyfile_account_address: ChecksumAddress
     ) -> None:
@@ -3806,6 +3867,93 @@ class EthModuleTest:
         # cleanup
         w3.middleware_onion.remove("signing")
 
+    def test_sign_authorization_and_send_raw_set_code_transaction(
+        self, w3: "Web3", keyfile_account_pkey: HexStr, math_contract: "Contract"
+    ) -> None:
+        # TODO: remove blockNumber block_id from eth_call and eth_getCode calls once
+        #  geth behavior for "latest" seems stable again.
+        keyfile_account = w3.eth.account.from_key(keyfile_account_pkey)
+
+        chain_id = w3.eth.chain_id
+        nonce = w3.eth.get_transaction_count(keyfile_account.address)
+
+        auth = {
+            "chainId": chain_id,
+            "address": math_contract.address,
+            "nonce": nonce + 1,
+        }
+        signed_auth = keyfile_account.sign_authorization(auth)
+
+        # get current math counter and increase it only in the delegation by n
+        math_counter = math_contract.functions.counter().call()
+        data = math_contract.encode_abi("incrementCounter", [math_counter + 1337])
+        txn: TxParams = {
+            "chainId": chain_id,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 200_000,
+            "nonce": nonce,
+            "maxPriorityFeePerGas": Wei(10**9),
+            "maxFeePerGas": Wei(10**9),
+            "data": data,
+            "authorizationList": [signed_auth],
+        }
+
+        signed = keyfile_account.sign_transaction(txn)
+        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        get_tx = w3.eth.get_transaction(tx_hash)
+        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+
+        code = w3.eth.get_code(
+            keyfile_account.address, block_identifier=receipt["blockNumber"]
+        )
+        assert code.to_0x_hex() == f"0xef0100{math_contract.address[2:].lower()}"
+        delegated = w3.eth.contract(
+            address=keyfile_account.address, abi=math_contract.abi
+        )
+        # assert the math counter is increased by 1337 only in delegated acct
+        assert (
+            math_contract.functions.counter().call(
+                block_identifier=receipt["blockNumber"]
+            )
+            == math_counter
+        )
+        assert (
+            delegated.functions.counter().call(block_identifier=receipt["blockNumber"])
+            == math_counter + 1337
+        )
+
+        assert len(get_tx["authorizationList"]) == 1
+        get_auth = get_tx["authorizationList"][0]
+        assert get_auth["chainId"] == chain_id
+        assert get_auth["address"] == math_contract.address
+        assert get_auth["nonce"] == nonce + 1
+        assert isinstance(get_auth["yParity"], int)
+        assert isinstance(get_auth["r"], HexBytes)
+        assert isinstance(get_auth["s"], HexBytes)
+
+        # reset storage value and code
+        reset_auth = {
+            "chainId": chain_id,
+            "address": "0x" + ("00" * 20),
+            "nonce": nonce + 3,
+        }
+        signed_reset_auth = keyfile_account.sign_authorization(reset_auth)
+        new_txn = dict(txn)
+        new_txn["authorizationList"] = [signed_reset_auth]
+        new_txn["nonce"] = nonce + 2
+
+        signed_reset = keyfile_account.sign_transaction(new_txn)
+        reset_tx_hash = w3.eth.send_raw_transaction(signed_reset.raw_transaction)
+        reset_tx_receipt = w3.eth.wait_for_transaction_receipt(
+            reset_tx_hash, timeout=10
+        )
+
+        reset_code = w3.eth.get_code(
+            keyfile_account.address, block_identifier=reset_tx_receipt["blockNumber"]
+        )
+        assert reset_code == HexBytes("0x")
+
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:
         txn_params = math_contract._prepare_transaction(
             abi_element_identifier="add",
@@ -4514,7 +4662,6 @@ 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", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -4572,7 +4719,6 @@ 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", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
@@ -4617,14 +4763,6 @@ class EthModuleTest:
         assert log_entry["transactionIndex"] == 0
         assert log_entry["transactionHash"] == HexBytes(txn_hash_with_log)
 
-    def test_eth_getUncleByBlockHashAndIndex(self, w3: "Web3") -> None:
-        # TODO: how do we make uncles....
-        pass
-
-    def test_eth_getUncleByBlockNumberAndIndex(self, w3: "Web3") -> None:
-        # TODO: how do we make uncles....
-        pass
-
     def test_eth_new_filter(self, w3: "Web3") -> None:
         filter = w3.eth.filter({})
 

web3/_utils/module_testing/module_testing_utils.py

@@ -21,9 +21,6 @@ from eth_typing import (
 from eth_utils import (
     is_same_address,
 )
-from flaky import (
-    flaky,
-)
 from hexbytes import (
     HexBytes,
 )
@@ -44,20 +41,11 @@ if TYPE_CHECKING:
     )
     from requests import Response  # noqa: F401
 
-    from web3 import Web3  # noqa: F401
     from web3._utils.compat import (  # noqa: F401
         Self,
     )
 
 
-"""
-flaky_geth_dev_mining decorator for tests requiring a pending block
-for the duration of the test. This behavior can be flaky
-due to timing of the test running as a block is mined.
-"""
-flaky_geth_dev_mining = flaky(max_runs=3, min_passes=1)
-
-
 def assert_contains_log(
     result: Sequence[LogReceipt],
     block_with_txn_with_log: BlockData,

web3/_utils/module_testing/persistent_connection_provider.py

@@ -655,11 +655,11 @@ class PersistentConnectionProviderTest:
         assert all(k in pending.keys() for k in SOME_BLOCK_KEYS)
 
         assert isinstance(block_num, int)
-        assert latest["number"] == block_num
-
         assert isinstance(chain_id, int)
         assert isinstance(chain_id2, int)
         assert isinstance(chain_id3, int)
+        # chain id is set in fixture file
+        assert chain_id == chain_id2 == chain_id3 == 131277322940537
 
     @pytest.mark.asyncio
     async def test_async_public_socket_api(self, async_w3: AsyncWeb3) -> None:
@@ -854,7 +854,7 @@ class PersistentConnectionProviderTest:
         async_w3: AsyncWeb3,
     ) -> None:
         async def unsubscribe_subs(
-            subs: List[Union[NewHeadsSubscription, LogsSubscription]]
+            subs: List[Union[NewHeadsSubscription, LogsSubscription]],
         ) -> None:
             for sub in subs:
                 await sub.unsubscribe()

web3/_utils/normalizers.py

@@ -228,7 +228,7 @@ def abi_ens_resolver(
                 return type_str, validate_name_has_address(_ens, val)
             except NameNotFound as e:
                 # TODO: This try/except is to keep backwards compatibility when we
-                #  removed the mainnet requirement. Remove this in web3.py v7 and allow
+                #  removed the mainnet requirement. Remove this in web3.py v8 and allow
                 #  NameNotFound to raise.
                 if not isinstance(_ens, StaticENS):
                     raise InvalidAddress(f"{e}")

web3/_utils/rpc_abi.py

@@ -215,11 +215,12 @@ def apply_abi_formatters_to_dict(
     fields = list(abi_dict.keys() & data.keys())
     formatted_values = map_abi_data(
         normalizers,
-        [abi_dict[field] for field in fields],
-        [data[field] for field in fields],
+        (abi_dict[field] for field in fields),
+        (data[field] for field in fields),
     )
-    formatted_dict = dict(zip(fields, formatted_values))
-    return dict(data, **formatted_dict)
+    formatted_dict = data.copy()
+    formatted_dict.update(zip(fields, formatted_values))
+    return formatted_dict
 
 
 @to_dict

web3/_utils/utility_methods.py

@@ -1,7 +1,7 @@
 from typing import (
     Any,
-    Dict,
     Iterable,
+    Mapping,
     Set,
     Union,
 )
@@ -13,7 +13,7 @@ from web3.types import (
 
 
 def all_in_dict(
-    values: Iterable[Any], d: Union[Dict[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
 ) -> bool:
     """
     Returns a bool based on whether ALL of the provided values exist
@@ -24,11 +24,12 @@ def all_in_dict(
     :return:       True if ALL values exist in keys;
                    False if NOT ALL values exist in keys
     """
-    return all(_ in dict(d) for _ in values)
+    d = dict(d)
+    return all(_ in d for _ in values)
 
 
 def any_in_dict(
-    values: Iterable[Any], d: Union[Dict[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
 ) -> bool:
     """
     Returns a bool based on whether ANY of the provided values exist
@@ -39,11 +40,12 @@ def any_in_dict(
     :return:       True if ANY value exists in keys;
                    False if NONE of the values exist in keys
     """
-    return any(_ in dict(d) for _ in values)
+    d = dict(d)
+    return any(_ in d for _ in values)
 
 
 def none_in_dict(
-    values: Iterable[Any], d: Union[Dict[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
 ) -> bool:
     """
     Returns a bool based on whether NONE of the provided values exist