web3 7.11.0__py3-none-any.whl → 7.12.0__py3-none-any.whl

web3/_utils/module_testing/eth_module.py

@@ -37,6 +37,7 @@ from eth_utils import (
 )
 from eth_utils.toolz import (
     assoc,
+    merge,
 )
 from hexbytes import (
     HexBytes,
@@ -717,12 +718,14 @@ class AsyncEthModuleTest:
         async_w3.middleware_onion.remove("signing")
 
     @pytest.mark.asyncio
-    async def test_async_sign_authorization_and_send_raw_set_code_transaction(
+    async def test_async_sign_authorization_send_raw_and_send_set_code_transactions(
         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
@@ -737,9 +740,7 @@ class AsyncEthModuleTest:
 
         # get current math counter and increase it only in the delegation by n
         math_counter = await async_math_contract.functions.counter().call()
-        built_tx = await async_math_contract.functions.incrementCounter(
-            math_counter + 1337
-        ).build_transaction({})
+        data = async_math_contract.encode_abi("incrementCounter", [math_counter + 1337])
         txn: TxParams = {
             "chainId": chain_id,
             "to": keyfile_account.address,
@@ -748,23 +749,31 @@ class AsyncEthModuleTest:
             "nonce": nonce,
             "maxPriorityFeePerGas": Wei(10**9),
             "maxFeePerGas": Wei(10**9),
-            "data": built_tx["data"],
+            "data": data,
             "authorizationList": [signed_auth],
         }
 
+        # test eth_sendRawTransaction
         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)
-        await async_w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+        tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
+            tx_hash, timeout=10
+        )
 
-        code = await async_w3.eth.get_code(keyfile_account.address)
+        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()
+        delegated_call = await delegated.functions.counter().call(
+            block_identifier=tx_receipt["blockNumber"]
+        )
         assert delegated_call == math_counter + 1337
 
         assert len(get_tx["authorizationList"]) == 1
@@ -783,17 +792,24 @@ class AsyncEthModuleTest:
             "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
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "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
+        # test eth_sendTransaction
+        reset_tx_hash = await async_w3.eth.send_transaction(reset_code_txn)
+        reset_tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
+            reset_tx_hash, timeout=10
         )
-        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_code = await async_w3.eth.get_code(
+            keyfile_account.address, reset_tx_receipt["blockNumber"]
+        )
         assert reset_code == HexBytes("0x")
 
     @pytest.mark.asyncio
@@ -1881,6 +1897,10 @@ class AsyncEthModuleTest:
         assert effective_gas_price > 0
 
     @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",
@@ -2221,19 +2241,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(
@@ -2718,13 +2750,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",
@@ -2843,18 +2877,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
@@ -3832,9 +3872,11 @@ class EthModuleTest:
         # cleanup
         w3.middleware_onion.remove("signing")
 
-    def test_sign_authorization_and_send_raw_set_code_transaction(
+    def test_sign_authorization_send_raw_and_send_set_code_transactions(
         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
@@ -3849,9 +3891,7 @@ class EthModuleTest:
 
         # get current math counter and increase it only in the delegation by n
         math_counter = math_contract.functions.counter().call()
-        data = math_contract.functions.incrementCounter(
-            math_counter + 1337
-        ).build_transaction({})["data"]
+        data = math_contract.encode_abi("incrementCounter", [math_counter + 1337])
         txn: TxParams = {
             "chainId": chain_id,
             "to": keyfile_account.address,
@@ -3864,19 +3904,30 @@ class EthModuleTest:
             "authorizationList": [signed_auth],
         }
 
+        # test eth_sendRawTransaction
         signed = keyfile_account.sign_transaction(txn)
         tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
         get_tx = w3.eth.get_transaction(tx_hash)
-        w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
 
-        code = w3.eth.get_code(keyfile_account.address)
+        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() == math_counter
-        assert delegated.functions.counter().call() == math_counter + 1337
+        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]
@@ -3894,15 +3945,24 @@ class EthModuleTest:
             "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
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "nonce": nonce + 2,
+            },
+        )
 
-        signed_reset = keyfile_account.sign_transaction(new_txn)
-        reset_tx_hash = w3.eth.send_raw_transaction(signed_reset.raw_transaction)
-        w3.eth.wait_for_transaction_receipt(reset_tx_hash, timeout=10)
+        # test eth_sendTransaction
+        reset_tx_hash = w3.eth.send_transaction(reset_code_txn)
+        reset_tx_receipt = w3.eth.wait_for_transaction_receipt(
+            reset_tx_hash, timeout=10
+        )
 
-        reset_code = w3.eth.get_code(keyfile_account.address)
+        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:

web3/_utils/module_testing/web3_module.py

@@ -1,4 +1,7 @@
 import pytest
+import asyncio
+import threading
+import time
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -43,6 +46,9 @@ if TYPE_CHECKING:
     )
 
 
+SOME_BLOCK_KEYS = {"number", "hash", "parentHash", "stateRoot", "transactions"}
+
+
 class Web3ModuleTest:
     def test_web3_client_version(self, w3: Web3) -> None:
         client_version = w3.client_version
@@ -336,7 +342,7 @@ class Web3ModuleTest:
 
             # assert proper batch cleanup after execution
             assert batch._requests_info == []
-            assert not batch._provider._is_batching
+            assert not w3.provider._is_batching
 
             # assert batch cannot be added to after execution
             with pytest.raises(
@@ -395,7 +401,7 @@ class Web3ModuleTest:
 
         # assert proper batch cleanup after execution
         assert batch._requests_info == []
-        assert not batch._provider._is_batching
+        assert not w3.provider._is_batching
 
         # assert batch cannot be added to after execution
         with pytest.raises(
@@ -513,6 +519,43 @@ class Web3ModuleTest:
                 batch.add(w3.eth.sign(Address(b"\x00" * 20)))
                 batch.execute()
 
+    def test_batch_requests_concurrently_with_regular_requests(
+        self, w3: "Web3"
+    ) -> None:
+        num_requests = 40
+        responses = []
+        batch_response = []
+
+        def make_regular_requests() -> None:
+            for _ in range(num_requests):
+                responses.append(w3.eth.get_block(0))
+                time.sleep(0.01)
+
+        def make_batch_request() -> None:
+            with w3.batch_requests() as batch:
+                for _ in range(num_requests):
+                    batch.add(w3.eth.get_block(0))
+                    time.sleep(0.01)
+                batch_response.extend(batch.execute())
+
+        # split into threads
+        regular_thread = threading.Thread(target=make_regular_requests)
+        batch_thread = threading.Thread(target=make_batch_request)
+
+        regular_thread.start()
+        batch_thread.start()
+
+        # wait for threads to finish
+        regular_thread.join()
+        batch_thread.join()
+        assert not regular_thread.is_alive()
+        assert not batch_thread.is_alive()
+
+        assert len(responses) == num_requests
+        assert len(batch_response) == num_requests
+        assert all(SOME_BLOCK_KEYS.issubset(response.keys()) for response in responses)
+        assert set(responses) == set(batch_response)
+
 
 # -- async -- #
 
@@ -551,7 +594,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
 
             # assert proper batch cleanup after execution
             assert batch._async_requests_info == []
-            assert not batch._provider._is_batching
+            assert not async_w3.provider._is_batching
 
             # assert batch cannot be added to after execution
             with pytest.raises(
@@ -614,7 +657,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
 
         # assert proper batch cleanup after execution
         assert batch._async_requests_info == []
-        assert not batch._provider._is_batching
+        assert not async_w3.provider._is_batching
 
         # assert batch cannot be added to after execution
         with pytest.raises(
@@ -734,3 +777,34 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
             with pytest.raises(MethodNotSupported, match="eth_sign"):
                 batch.add(async_w3.eth.sign(Address(b"\x00" * 20)))
                 await batch.async_execute()
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_concurrently_with_regular_requests(  # type: ignore[override]  # noqa: E501
+        self, async_w3: AsyncWeb3  # type: ignore[override]
+    ) -> None:
+        responses = []
+        batch_response = []
+
+        num_blocks = await async_w3.eth.block_number
+
+        async def make_regular_requests() -> None:
+            for i in range(num_blocks):
+                responses.append(await async_w3.eth.get_block(i))
+                await asyncio.sleep(0.01)
+
+        async def make_batch_request() -> None:
+            async with async_w3.batch_requests() as batch:
+                for i in range(num_blocks):
+                    batch.add(async_w3.eth.get_block(i))
+                    await asyncio.sleep(0.01)
+                batch_response.extend(await batch.async_execute())
+
+        await asyncio.gather(
+            make_regular_requests(),
+            make_batch_request(),
+        )
+
+        assert len(responses) == num_blocks
+        assert len(batch_response) == num_blocks
+        assert all(SOME_BLOCK_KEYS.issubset(response.keys()) for response in responses)
+        assert set(responses) == set(batch_response)

web3/_utils/validation.py

@@ -396,7 +396,7 @@ def validate_rpc_response_and_raise_if_error(
 
         response = apply_error_formatters(error_formatters, response)
         if logger is not None:
-            logger.debug(f"RPC error response: {response}")
+            logger.debug("RPC error response: %s", response)
 
         raise web3_rpc_error
 

web3/contract/utils.py

@@ -43,8 +43,8 @@ from web3._utils.abi import (
 from web3._utils.async_transactions import (
     async_fill_transaction_defaults,
 )
-from web3._utils.compat import (
-    TypeAlias,
+from web3._utils.batching import (
+    BatchRequestInformation,
 )
 from web3._utils.contracts import (
     prepare_transaction,
@@ -62,7 +62,6 @@ from web3.exceptions import (
 from web3.types import (
     ABIElementIdentifier,
     BlockIdentifier,
-    RPCEndpoint,
     StateOverride,
     TContractEvent,
     TContractFn,
@@ -175,10 +174,8 @@ def call_contract_function(
     if abi_callable["type"] == "function":
         output_types = get_abi_output_types(abi_callable)
 
-    provider = w3.provider
-    if hasattr(provider, "_is_batching") and provider._is_batching:
-        BatchingReturnData: TypeAlias = Tuple[Tuple[RPCEndpoint, Any], Tuple[Any, ...]]
-        request_information = tuple(cast(BatchingReturnData, return_data))
+    if w3.provider._is_batching:
+        request_information = tuple(cast(BatchRequestInformation, return_data))
         method_and_params = request_information[0]
 
         # append return data formatting to result formatters
@@ -483,35 +480,23 @@ async def async_call_contract_function(
             normalizers,
             output_types,
         )
-        if async_w3.provider.has_persistent_connection:
-            # get the current request id
-            provider = cast("PersistentConnectionProvider", async_w3.provider)
-            current_request_id = provider._batch_request_counter - 1
-            provider._request_processor.append_result_formatter_for_request(
-                current_request_id, contract_call_return_data_formatter
-            )
-        else:
-            BatchingReturnData: TypeAlias = Tuple[
-                Tuple[RPCEndpoint, Any], Tuple[Any, ...]
-            ]
-            request_information = tuple(cast(BatchingReturnData, return_data))
-            method_and_params = request_information[0]
-
-            # append return data formatter to result formatters
-            current_response_formatters = request_information[1]
-            current_result_formatters = current_response_formatters[0]
-            updated_result_formatters = compose(
-                contract_call_return_data_formatter,
-                current_result_formatters,
-            )
-            response_formatters = (
-                updated_result_formatters,  # result formatters
-                current_response_formatters[1],  # error formatters
-                current_response_formatters[2],  # null result formatters
-            )
-            return (method_and_params, response_formatters)
 
-        return return_data
+        request_information = tuple(cast(BatchRequestInformation, return_data))
+        method_and_params = request_information[0]
+
+        # append return data formatter to result formatters
+        current_response_formatters = request_information[1]
+        current_result_formatters = current_response_formatters[0]
+        updated_result_formatters = compose(
+            contract_call_return_data_formatter,
+            current_result_formatters,
+        )
+        response_formatters = (
+            updated_result_formatters,  # result formatters
+            current_response_formatters[1],  # error formatters
+            current_response_formatters[2],  # null result formatters
+        )
+        return (method_and_params, response_formatters)
 
     try:
         output_data = async_w3.codec.decode(output_types, return_data)

web3/eth/async_eth.py

@@ -39,6 +39,9 @@ from web3._utils.blocks import (
 from web3._utils.compat import (
     Unpack,
 )
+from web3._utils.decorators import (
+    deprecated_for,
+)
 from web3._utils.fee_utils import (
     async_fee_history_priority_fee,
 )
@@ -669,6 +672,7 @@ class AsyncEth(BaseEth):
         mungers=[default_root_munger],
     )
 
+    @deprecated_for("all get_uncle* methods will be removed in v8")
     async def get_uncle_count(self, block_identifier: BlockIdentifier) -> int:
         return await self._get_uncle_count(block_identifier)
 

web3/eth/eth.py

@@ -69,6 +69,7 @@ from web3.exceptions import (
     Web3ValueError,
 )
 from web3.method import (
+    DeprecatedMethod,
     Method,
     default_root_munger,
 )
@@ -566,7 +567,7 @@ class Eth(BaseEth):
     # eth_getUncleCountByBlockHash
     # eth_getUncleCountByBlockNumber
 
-    get_uncle_count: Method[Callable[[BlockIdentifier], int]] = Method(
+    _get_uncle_count: Method[Callable[[BlockIdentifier], int]] = Method(
         method_choice_depends_on_args=select_method_for_block_identifier(
             if_predefined=RPC.eth_getUncleCountByBlockNumber,
             if_hash=RPC.eth_getUncleCountByBlockHash,
@@ -574,11 +575,17 @@ class Eth(BaseEth):
         ),
         mungers=[default_root_munger],
     )
+    get_uncle_count = DeprecatedMethod(
+        _get_uncle_count,
+        old_name="_get_uncle_count",
+        new_name="get_uncle_count",
+        msg="All get_uncle* methods have been deprecated",
+    )
 
     # eth_getUncleByBlockHashAndIndex
     # eth_getUncleByBlockNumberAndIndex
 
-    get_uncle_by_block: Method[Callable[[BlockIdentifier, int], Uncle]] = Method(
+    _get_uncle_by_block: Method[Callable[[BlockIdentifier, int], Uncle]] = Method(
         method_choice_depends_on_args=select_method_for_block_identifier(
             if_predefined=RPC.eth_getUncleByBlockNumberAndIndex,
             if_hash=RPC.eth_getUncleByBlockHashAndIndex,
@@ -586,6 +593,12 @@ class Eth(BaseEth):
         ),
         mungers=[default_root_munger],
     )
+    get_uncle_by_block = DeprecatedMethod(
+        _get_uncle_by_block,
+        old_name="_get_uncle_by_block",
+        new_name="get_uncle_by_block",
+        msg="All get_uncle* methods have been deprecated",
+    )
 
     def replace_transaction(
         self, transaction_hash: _Hash32, new_transaction: TxParams