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

web3/_utils/module_testing/web3_module.py

@@ -1,12 +1,14 @@
 import pytest
 from typing import (
+    TYPE_CHECKING,
     Any,
     NoReturn,
     Sequence,
-    Union,
+    cast,
 )
 
 from eth_typing import (
+    Address,
     ChecksumAddress,
     HexAddress,
     HexStr,
@@ -23,10 +25,23 @@ from web3 import (
 from web3._utils.ens import (
     ens_addresses,
 )
+from web3.contract import (
+    Contract,
+)
 from web3.exceptions import (
     InvalidAddress,
+    MethodNotSupported,
+    Web3ValueError,
+)
+from web3.types import (
+    BlockData,
 )
 
+if TYPE_CHECKING:
+    from web3.contract import (  # noqa: F401
+        AsyncContract,
+    )
+
 
 class Web3ModuleTest:
     def test_web3_client_version(self, w3: Web3) -> None:
@@ -223,16 +238,9 @@ class Web3ModuleTest:
             ),
         ),
     )
-    @pytest.mark.parametrize(
-        "w3",
-        (
-            Web3,
-            AsyncWeb3,
-        ),
-    )
     def test_solidity_keccak(
         self,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: "Web3",
         types: Sequence[TypeStr],
         values: Sequence[Any],
         expected: HexBytes,
@@ -264,16 +272,9 @@ class Web3ModuleTest:
             ),
         ),
     )
-    @pytest.mark.parametrize(
-        "w3",
-        (
-            Web3(),
-            AsyncWeb3(),
-        ),
-    )
     def test_solidity_keccak_ens(
         self,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: "Web3",
         types: Sequence[TypeStr],
         values: Sequence[str],
         expected: HexBytes,
@@ -313,3 +314,423 @@ class Web3ModuleTest:
 
     def test_is_connected(self, w3: "Web3") -> None:
         assert w3.is_connected()
+
+    def test_batch_requests(self, w3: "Web3", math_contract: Contract) -> None:
+        with w3.batch_requests() as batch:
+            batch.add(w3.eth.get_block(6))
+            batch.add(w3.eth.get_block(4))
+            batch.add(w3.eth.get_block(2))
+            batch.add(w3.eth.get_block(0))
+            batch.add(math_contract.functions.multiply7(0))
+
+            batch.add_mapping(
+                {
+                    math_contract.functions.multiply7: [1, 2, 3],
+                    w3.eth.get_block: [1, 3, 5],
+                }
+            )
+
+            assert len(batch._requests_info) == 11
+            responses = batch.execute()
+            assert len(responses) == 11
+
+            # assert proper batch cleanup after execution
+            assert batch._requests_info == []
+            assert not batch._provider._is_batching
+
+            # assert batch cannot be added to after execution
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.add(w3.eth.get_block(5))
+
+            # assert batch cannot be executed again
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.execute()
+
+        # assert can make a request after executing
+        block_num = w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        first_four_responses: Sequence[BlockData] = cast(
+            Sequence[BlockData], responses[:4]
+        )
+        assert first_four_responses[0]["number"] == 6
+        assert first_four_responses[1]["number"] == 4
+        assert first_four_responses[2]["number"] == 2
+        assert first_four_responses[3]["number"] == 0
+
+        responses_five_through_eight: Sequence[int] = cast(
+            Sequence[int], responses[4:8]
+        )
+        assert responses_five_through_eight[0] == 0
+        assert responses_five_through_eight[1] == 7
+        assert responses_five_through_eight[2] == 14
+        assert responses_five_through_eight[3] == 21
+
+        last_three_responses: Sequence[BlockData] = cast(
+            Sequence[BlockData], responses[8:]
+        )
+        assert last_three_responses[0]["number"] == 1
+        assert last_three_responses[1]["number"] == 3
+        assert last_three_responses[2]["number"] == 5
+
+    def test_batch_requests_initialized_as_object(
+        self, w3: "Web3", math_contract: Contract
+    ) -> None:
+        batch = w3.batch_requests()
+        batch.add(w3.eth.get_block(1))
+        batch.add(w3.eth.get_block(2))
+        batch.add(math_contract.functions.multiply7(0))
+        batch.add_mapping(
+            {math_contract.functions.multiply7: [1, 2], w3.eth.get_block: [3, 4]}
+        )
+
+        assert len(batch._requests_info) == 7
+        b1, b2, m0, m1, m2, b3, b4 = batch.execute()
+
+        # assert proper batch cleanup after execution
+        assert batch._requests_info == []
+        assert not batch._provider._is_batching
+
+        # assert batch cannot be added to after execution
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            batch.add(w3.eth.get_block(5))
+
+        # assert batch cannot be executed again
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            batch.execute()
+
+        # assert can make a request after executing
+        block_num = w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        assert cast(BlockData, b1)["number"] == 1
+        assert cast(BlockData, b2)["number"] == 2
+        assert cast(int, m0) == 0
+        assert cast(int, m1) == 7
+        assert cast(int, m2) == 14
+        assert cast(BlockData, b3)["number"] == 3
+        assert cast(BlockData, b4)["number"] == 4
+
+    def test_batch_requests_clear(self, w3: "Web3") -> None:
+        with w3.batch_requests() as batch:
+            batch.add(w3.eth.get_block(1))
+            batch.add(w3.eth.get_block(2))
+
+            assert len(batch._requests_info) == 2
+            batch.clear()
+            assert batch._requests_info == []
+
+            batch.add(w3.eth.get_block(3))
+            batch.add(w3.eth.get_block(4))
+
+            r1, r2 = batch.execute()
+
+            assert cast(BlockData, r1)["number"] == 3
+            assert cast(BlockData, r2)["number"] == 4
+
+        new_batch = w3.batch_requests()
+        new_batch.add(w3.eth.get_block(5))
+
+        assert len(new_batch._requests_info) == 1
+        new_batch.clear()
+        assert new_batch._requests_info == []
+
+        new_batch.add(w3.eth.get_block(6))
+        (r3,) = new_batch.execute()
+        assert cast(BlockData, r3)["number"] == 6
+
+    def test_batch_requests_cancel(self, w3: "Web3") -> None:
+        # as context manager
+        with w3.batch_requests() as batch:
+            batch.add(w3.eth.get_block(1))
+            batch.cancel()
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.add(w3.eth.get_block(2))
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.execute()
+
+        # can make a request after cancelling
+        block_num = w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        # as obj
+        new_batch = w3.batch_requests()
+        new_batch.add(w3.eth.get_block(1))
+        new_batch.cancel()
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            new_batch.add(w3.eth.get_block(2))
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            new_batch.execute()
+
+        # assert can make a request after cancelling
+        block_num = w3.eth.block_number
+        assert isinstance(block_num, int)
+
+    def test_batch_requests_raises_for_common_unsupported_methods(
+        self, w3: "Web3", math_contract: Contract
+    ) -> None:
+        with w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
+                batch.add(w3.eth.send_transaction({}))
+                batch.execute()
+
+        with w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
+                batch.add(math_contract.functions.multiply7(1).transact({}))
+                batch.execute()
+
+        with w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendRawTransaction"):
+                batch.add(w3.eth.send_raw_transaction(b""))
+                batch.execute()
+
+        with w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sign"):
+                batch.add(w3.eth.sign(Address(b"\x00" * 20)))
+                batch.execute()
+
+
+# -- async -- #
+
+
+class AsyncWeb3ModuleTest(Web3ModuleTest):
+    # Note: Any test that overrides the synchronous test from `Web3ModuleTest` with
+    # an asynchronous test should have the exact same name.
+
+    @pytest.mark.asyncio
+    async def test_web3_client_version(self, async_w3: AsyncWeb3) -> None:
+        client_version = await async_w3.client_version
+        self._check_web3_client_version(client_version)
+
+    @pytest.mark.asyncio
+    async def test_batch_requests(
+        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    ) -> None:
+        async with async_w3.batch_requests() as batch:
+            batch.add(async_w3.eth.get_block(6))
+            batch.add(async_w3.eth.get_block(4))
+            batch.add(async_w3.eth.get_block(2))
+            batch.add(async_w3.eth.get_block(0))
+
+            batch.add(async_math_contract.functions.multiply7(0))
+
+            batch.add_mapping(
+                {
+                    async_math_contract.functions.multiply7: [1, 2, 3],
+                    async_w3.eth.get_block: [1, 3, 5],
+                }
+            )
+
+            assert len(batch._async_requests_info) == 11
+            responses = await batch.async_execute()
+            assert len(responses) == 11
+
+            # assert proper batch cleanup after execution
+            assert batch._async_requests_info == []
+            assert not batch._provider._is_batching
+
+            # assert batch cannot be added to after execution
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.add(async_w3.eth.get_block(5))
+
+            # assert batch cannot be executed again
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                await batch.async_execute()
+
+        # assert can make a request after executing
+        block_num = await async_w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        first_four_responses: Sequence[BlockData] = cast(
+            Sequence[BlockData], responses[:4]
+        )
+        assert first_four_responses[0]["number"] == 6
+        assert first_four_responses[1]["number"] == 4
+        assert first_four_responses[2]["number"] == 2
+        assert first_four_responses[3]["number"] == 0
+
+        responses_five_through_eight: Sequence[int] = cast(
+            Sequence[int], responses[4:8]
+        )
+        assert responses_five_through_eight[0] == 0
+        assert responses_five_through_eight[1] == 7
+        assert responses_five_through_eight[2] == 14
+        assert responses_five_through_eight[3] == 21
+
+        last_three_responses: Sequence[BlockData] = cast(
+            Sequence[BlockData], responses[8:]
+        )
+        assert last_three_responses[0]["number"] == 1
+        assert last_three_responses[1]["number"] == 3
+        assert last_three_responses[2]["number"] == 5
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_initialized_as_object(
+        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    ) -> None:
+        batch = async_w3.batch_requests()
+        batch.add(async_w3.eth.get_block(1))
+        batch.add(async_w3.eth.get_block(2))
+        batch.add(async_math_contract.functions.multiply7(0))
+        batch.add_mapping(
+            {
+                async_math_contract.functions.multiply7: [1, 2],
+                async_w3.eth.get_block: [3, 4],
+            }
+        )
+
+        assert len(batch._async_requests_info) == 7
+        b1, b2, m0, m1, m2, b3, b4 = await batch.async_execute()
+
+        # assert proper batch cleanup after execution
+        assert batch._async_requests_info == []
+        assert not batch._provider._is_batching
+
+        # assert batch cannot be added to after execution
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            batch.add(async_w3.eth.get_block(5))
+
+        # assert batch cannot be executed again
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            await batch.async_execute()
+
+        # assert can make a request after executing
+        block_num = await async_w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        assert cast(BlockData, b1)["number"] == 1
+        assert cast(BlockData, b2)["number"] == 2
+        assert cast(int, m0) == 0
+        assert cast(int, m1) == 7
+        assert cast(int, m2) == 14
+        assert cast(BlockData, b3)["number"] == 3
+        assert cast(BlockData, b4)["number"] == 4
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_clear(self, async_w3: AsyncWeb3) -> None:
+        async with async_w3.batch_requests() as batch:
+            batch.add(async_w3.eth.get_block(1))
+            batch.add(async_w3.eth.get_block(2))
+
+            assert len(batch._async_requests_info) == 2
+            batch.clear()
+            assert batch._async_requests_info == []
+
+            batch.add(async_w3.eth.get_block(3))
+            batch.add(async_w3.eth.get_block(4))
+
+            r1, r2 = await batch.async_execute()
+
+            assert cast(BlockData, r1)["number"] == 3
+            assert cast(BlockData, r2)["number"] == 4
+
+        new_batch = async_w3.batch_requests()
+        new_batch.add(async_w3.eth.get_block(5))
+
+        assert len(new_batch._async_requests_info) == 1
+        new_batch.clear()
+        assert new_batch._async_requests_info == []
+
+        new_batch.add(async_w3.eth.get_block(6))
+        (r3,) = await new_batch.async_execute()
+        assert cast(BlockData, r3)["number"] == 6
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_cancel(self, async_w3: AsyncWeb3) -> None:
+        # as context manager
+        async with async_w3.batch_requests() as batch:
+            batch.add(async_w3.eth.get_block(1))
+            batch.cancel()
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                batch.add(async_w3.eth.get_block(2))
+            with pytest.raises(
+                Web3ValueError,
+                match="Batch has already been executed or cancelled",
+            ):
+                await batch.async_execute()
+
+        # can make a request after cancelling
+        block_num = await async_w3.eth.block_number
+        assert isinstance(block_num, int)
+
+        # as obj
+        new_batch = async_w3.batch_requests()
+        new_batch.add(async_w3.eth.get_block(1))
+        new_batch.cancel()
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            new_batch.add(async_w3.eth.get_block(2))
+        with pytest.raises(
+            Web3ValueError,
+            match="Batch has already been executed or cancelled",
+        ):
+            await new_batch.async_execute()
+
+        # can make a request after cancelling
+        block_num = await async_w3.eth.block_number
+        assert isinstance(block_num, int)
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_raises_for_common_unsupported_methods(
+        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    ) -> None:
+        async with async_w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
+                batch.add(async_w3.eth.send_transaction({}))
+                await batch.async_execute()
+
+        async with async_w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
+                batch.add(async_math_contract.functions.multiply7(1).transact({}))
+                await batch.async_execute()
+
+        async with async_w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sendRawTransaction"):
+                batch.add(async_w3.eth.send_raw_transaction(b""))
+                await batch.async_execute()
+
+        async with async_w3.batch_requests() as batch:
+            with pytest.raises(MethodNotSupported, match="eth_sign"):
+                batch.add(async_w3.eth.sign(Address(b"\x00" * 20)))
+                await batch.async_execute()

web3/contract/utils.py

@@ -9,6 +9,7 @@ from typing import (
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 from eth_abi.exceptions import (
@@ -16,6 +17,11 @@ from eth_abi.exceptions import (
 )
 from eth_typing import (
     ChecksumAddress,
+    TypeStr,
+)
+from eth_utils.toolz import (
+    compose,
+    curry,
 )
 from hexbytes import (
     HexBytes,
@@ -60,10 +66,50 @@ if TYPE_CHECKING:
         AsyncWeb3,
         Web3,
     )
+    from web3.providers.persistent import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
 
 ACCEPTABLE_EMPTY_STRINGS = ["0x", b"0x", "", b""]
 
 
+@curry
+def format_contract_call_return_data_curried(
+    async_w3: Union["AsyncWeb3", "Web3"],
+    decode_tuples: bool,
+    fn_abi: ABIFunction,
+    function_identifier: FunctionIdentifier,
+    normalizers: Tuple[Callable[..., Any], ...],
+    output_types: Sequence[TypeStr],
+    return_data: Any,
+) -> Any:
+    """
+    Helper function for formatting contract call return data for batch requests. Curry
+    with all arguments except `return_data` and process `return_data` once it is
+    available.
+    """
+    try:
+        output_data = async_w3.codec.decode(output_types, return_data)
+    except DecodingError as e:
+        msg = (
+            f"Could not decode contract function call to {function_identifier} "
+            f"with return data: {str(return_data)}, output_types: {output_types}"
+        )
+        raise BadFunctionCallOutput(msg) from e
+
+    _normalizers = itertools.chain(
+        BASE_RETURN_NORMALIZERS,
+        normalizers,
+    )
+    normalized_data = map_abi_data(_normalizers, output_types, output_data)
+
+    if decode_tuples:
+        decoded = named_tree(fn_abi["outputs"], normalized_data)
+        normalized_data = recursive_dict_to_namedtuple(decoded)
+
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
+
+
 def call_contract_function(
     w3: "Web3",
     address: ChecksumAddress,
@@ -108,6 +154,34 @@ def call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    provider = w3.provider
+    if hasattr(provider, "_is_batching") and provider._is_batching:
+        # request_information == ((method, params), response_formatters)
+        request_information = tuple(return_data)
+        method_and_params = request_information[0]
+
+        # append return data formatting 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
+            format_contract_call_return_data_curried(
+                w3,
+                decode_tuples,
+                fn_abi,
+                function_identifier,
+                normalizers,
+                output_types,
+            ),
+            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 = w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -319,6 +393,43 @@ async def async_call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    if async_w3.provider._is_batching:
+        contract_call_return_data_formatter = format_contract_call_return_data_curried(
+            async_w3,
+            decode_tuples,
+            fn_abi,
+            function_identifier,
+            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:
+            # request_information == ((method, params), response_formatters)
+            request_information = tuple(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
+
     try:
         output_data = async_w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -350,10 +461,7 @@ async def async_call_contract_function(
         decoded = named_tree(fn_abi["outputs"], normalized_data)
         normalized_data = recursive_dict_to_namedtuple(decoded)
 
-    if len(normalized_data) == 1:
-        return normalized_data[0]
-    else:
-        return normalized_data
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
 
 
 async def async_transact_with_contract_function(

web3/eth/async_eth.py

@@ -35,6 +35,9 @@ from web3._utils.async_transactions import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     async_fee_history_priority_fee,
 )
@@ -594,10 +597,8 @@ class AsyncEth(BaseEth):
             self.w3, current_transaction, new_transaction
         )
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     async def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
 
@@ -765,7 +766,7 @@ class AsyncEth(BaseEth):
 
     @overload
     # mypy error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[overload-overlap]  # noqa: E501
         ...
 
     @overload