web3 7.6.0__tar.gz → 7.6.1__tar.gz

{web3-7.6.0/web3.egg-info → web3-7.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.6.0
+Version: 7.6.1
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -36,8 +36,8 @@ Requires-Dist: types-requests>=2.0.0
 Requires-Dist: websockets<14.0.0,>=10.0.0
 Requires-Dist: pyunormalize>=15.0.0
 Provides-Extra: tester
-Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.11.0b1; extra == "tester"
-Requires-Dist: py-geth>=5.0.0; extra == "tester"
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "tester"
+Requires-Dist: py-geth>=5.1.0; extra == "tester"
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
 Requires-Dist: bumpversion>=0.5.3; extra == "dev"
@@ -59,8 +59,8 @@ Requires-Dist: hypothesis>=3.31.2; extra == "dev"
 Requires-Dist: tox>=4.0.0; extra == "dev"
 Requires-Dist: mypy==1.10.0; extra == "dev"
 Requires-Dist: pre-commit>=3.4.0; extra == "dev"
-Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.11.0b1; extra == "dev"
-Requires-Dist: py-geth>=5.0.0; extra == "dev"
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "dev"
+Requires-Dist: py-geth>=5.1.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=6.0.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
@@ -76,8 +76,8 @@ Requires-Dist: hypothesis>=3.31.2; extra == "test"
 Requires-Dist: tox>=4.0.0; extra == "test"
 Requires-Dist: mypy==1.10.0; extra == "test"
 Requires-Dist: pre-commit>=3.4.0; extra == "test"
-Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.11.0b1; extra == "test"
-Requires-Dist: py-geth>=5.0.0; extra == "test"
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "test"
+Requires-Dist: py-geth>=5.1.0; extra == "test"
 
 # web3.py
 

{web3-7.6.0 → web3-7.6.1}/setup.py

@@ -8,8 +8,8 @@ extras_require = {
     "tester": [
         # Note: ethereum-maintained libraries in this list should be added to the
         # `install_pre_releases.py` script.
-        "eth-tester[py-evm]>=0.11.0b1,<0.13.0b1",
-        "py-geth>=5.0.0",
+        "eth-tester[py-evm]>=0.12.0b1,<0.13.0b1",
+        "py-geth>=5.1.0",
     ],
     "dev": [
         "build>=0.9.0",
@@ -55,7 +55,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
-    version="7.6.0",
+    version="7.6.1",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/conftest.py

@@ -13,6 +13,9 @@ from tests.utils import (
 from web3._utils.abi import (
     get_abi_element_signature,
 )
+from web3._utils.contract_sources.contract_data.ambiguous_function_contract import (
+    AMBIGUOUS_FUNCTION_CONTRACT_DATA,
+)
 from web3._utils.contract_sources.contract_data.arrays_contract import (
     ARRAYS_CONTRACT_DATA,
 )
@@ -195,6 +198,26 @@ def non_strict_string_contract(
     )
 
 
+# --- ambiguous function contract --- #
+
+
+@pytest.fixture(scope="session")
+def ambiguous_function_contract_data():
+    return AMBIGUOUS_FUNCTION_CONTRACT_DATA
+
+
+@pytest.fixture
+def ambiguous_function_contract_factory(w3):
+    return w3.eth.contract(**AMBIGUOUS_FUNCTION_CONTRACT_DATA)
+
+
+@pytest.fixture
+def ambiguous_function_contract(
+    w3, ambiguous_function_contract_factory, address_conversion_func
+):
+    return deploy(w3, ambiguous_function_contract_factory, address_conversion_func)
+
+
 # --- emitter contract --- #
 
 
@@ -780,6 +803,17 @@ async def async_nested_tuple_contract_with_decode_tuples(
     )
 
 
+@pytest_asyncio.fixture
+async def async_ambiguous_event_contract(async_w3, address_conversion_func):
+    async_ambiguous_event_contract_factory = async_w3.eth.contract(
+        **AMBIGUOUS_EVENT_NAME_CONTRACT_DATA
+    )
+
+    return await async_deploy(
+        async_w3, async_ambiguous_event_contract_factory, address_conversion_func
+    )
+
+
 async def async_invoke_contract(
     api_call_desig="call",
     contract=None,

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_ambiguous_events.py

@@ -7,6 +7,9 @@ from eth_typing import (
     ABI,
 )
 
+from web3.contract.async_contract import (
+    AsyncContract,
+)
 from web3.contract.contract import (
     Contract,
     ContractEvent,
@@ -15,6 +18,7 @@ from web3.exceptions import (
     MismatchedABI,
 )
 from web3.main import (
+    AsyncWeb3,
     Web3,
 )
 from web3.utils.abi import (
@@ -124,7 +128,7 @@ AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI = [
 ]
 
 
-def test_get_abi_from_event(ambiguous_event_contract: "Contract") -> None:
+def test_get_abi_from_event_signature(ambiguous_event_contract: "Contract") -> None:
     expected_event_abi = {
         "anonymous": False,
         "inputs": [
@@ -143,6 +147,78 @@ def test_get_abi_from_event(ambiguous_event_contract: "Contract") -> None:
     assert expected_event_abi == event_get_abi_result
 
 
+def test_get_abi_from_event_call_without_args(ambiguous_event_contract: "Contract"):
+    expected_event_abi = {
+        "anonymous": False,
+        "inputs": [
+            {
+                "indexed": False,
+                "internalType": "uint256",
+                "name": "arg0",
+                "type": "uint256",
+            }
+        ],
+        "name": "LogSingleArg",
+        "type": "event",
+    }
+
+    event_get_abi_result = ambiguous_event_contract.events.LogSingleArg.abi
+    assert expected_event_abi == event_get_abi_result
+
+
+def test_get_abi_from_event_call_with_any_args(ambiguous_event_contract: "Contract"):
+    expected_event_abi = {
+        "anonymous": False,
+        "inputs": [
+            {
+                "indexed": False,
+                "internalType": "uint256",
+                "name": "arg0",
+                "type": "uint256",
+            }
+        ],
+        "name": "LogSingleArg",
+        "type": "event",
+    }
+
+    event_get_abi_result = ambiguous_event_contract.events.LogSingleArg().abi
+    assert expected_event_abi == event_get_abi_result
+
+    event_get_abi_result = ambiguous_event_contract.events.LogSingleArg(1).abi
+    assert expected_event_abi == event_get_abi_result
+
+    event_get_abi_result = ambiguous_event_contract.events.LogSingleArg(
+        b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",  # noqa: E501
+    ).abi
+    assert expected_event_abi == event_get_abi_result
+
+    event_get_abi_result = ambiguous_event_contract.events.LogSingleArg("hi").abi
+    assert expected_event_abi == event_get_abi_result
+
+
+def test_async_get_abi_from_event(
+    async_ambiguous_event_contract: "AsyncContract",
+) -> None:
+    expected_event_abi = {
+        "anonymous": False,
+        "inputs": [
+            {
+                "indexed": False,
+                "internalType": "uint256",
+                "name": "arg0",
+                "type": "uint256",
+            }
+        ],
+        "name": "LogSingleArg",
+        "type": "event",
+    }
+
+    event_get_abi_result = async_ambiguous_event_contract.events[
+        "LogSingleArg(uint256)"
+    ].abi
+    assert expected_event_abi == event_get_abi_result
+
+
 def test_get_abi_element_for_ambiguous_tuple_events() -> None:
     event_abi = get_abi_element(
         cast(ABI, AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI),
@@ -215,7 +291,7 @@ def test_contract_event_methods(
         "name": "LogSingleArg",
         "type": "event",
     }
-    assert log_arg_event.event_name == "LogSingleArg"
+    assert log_arg_event.name == "LogSingleArg"
     assert log_arg_event.abi_element_identifier == "LogSingleArg(uint256)"
     assert log_arg_event.get_logs() == []
 
@@ -257,3 +333,69 @@ def test_contract_event_methods(
         "blockHash": "0x0",
         "blockNumber": 0,
     }
+
+
+@pytest.mark.asyncio
+async def test_async_contract_event_methods(
+    async_w3: "AsyncWeb3", async_ambiguous_event_contract: "AsyncContract"
+) -> None:
+    log_arg_event = cast(
+        ContractEvent, async_ambiguous_event_contract.events["LogSingleArg(uint256)"]
+    )
+
+    assert log_arg_event.abi == {
+        "anonymous": False,
+        "inputs": [
+            {
+                "indexed": False,
+                "internalType": "uint256",
+                "name": "arg0",
+                "type": "uint256",
+            }
+        ],
+        "name": "LogSingleArg",
+        "type": "event",
+    }
+    assert log_arg_event.event_name == "LogSingleArg"
+    assert log_arg_event.name == "LogSingleArg"
+    assert log_arg_event.abi_element_identifier == "LogSingleArg(uint256)"
+    assert await log_arg_event.get_logs() == []
+
+    filter_builder = log_arg_event.build_filter()
+    filter_builder.from_block = "latest"
+    filter_builder.to_block = "latest"
+    filter_builder.args.arg0.match_single(1)
+    filter_instance = await filter_builder.deploy(async_w3)
+
+    assert filter_instance.filter_params == {
+        "fromBlock": "latest",
+        "toBlock": "latest",
+        "address": async_ambiguous_event_contract.address,
+        "topics": (
+            "0x56d2ef3c5228bf5d88573621e325a4672ab50e033749a601e4f4a5e1dce905d4",
+        ),
+    }
+
+    log_filter = await log_arg_event.create_filter(from_block="latest")
+    log_entry = {
+        "address": async_ambiguous_event_contract.address,
+        "topics": (
+            "0x56d2ef3c5228bf5d88573621e325a4672ab50e033749a601e4f4a5e1dce905d4",
+        ),
+        "data": "0x0000000000000000000000000000000000000000000000000000000000000005",
+        "logIndex": 0,
+        "transactionIndex": 0,
+        "transactionHash": "0x0",
+        "blockHash": "0x0",
+        "blockNumber": 0,
+    }
+    assert log_filter.log_entry_formatter(log_entry) == {
+        "args": {"arg0": 5},
+        "event": "LogSingleArg",
+        "logIndex": 0,
+        "transactionIndex": 0,
+        "transactionHash": "0x0",
+        "address": async_ambiguous_event_contract.address,
+        "blockHash": "0x0",
+        "blockNumber": 0,
+    }

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_ambiguous_functions.py

@@ -1,4 +1,5 @@
 import pytest
+import re
 from typing import (
     cast,
 )
@@ -15,6 +16,7 @@ from hexbytes import (
 )
 
 from web3.exceptions import (
+    MismatchedABI,
     Web3ValueError,
 )
 from web3.utils.abi import (
@@ -101,9 +103,9 @@ map_repr = compose(list, curry(map, repr))
             map_repr,
             [
                 "<Function blockHashAmphithyronVersify(uint256)>",
+                "<Function identity(bool)>",
                 "<Function identity(uint256,bool)>",
                 "<Function identity(int256,bool)>",
-                "<Function identity(bool)>",
             ],
         ),
         (
@@ -123,9 +125,9 @@ map_repr = compose(list, curry(map, repr))
             ("identity",),
             map_repr,
             [
+                "<Function identity(bool)>",
                 "<Function identity(uint256,bool)>",
                 "<Function identity(int256,bool)>",
-                "<Function identity(bool)>",
             ],
         ),
         (
@@ -292,6 +294,52 @@ def test_ambiguous_functions_abi_element_identifier(w3):
     assert fn_bytes32.abi_element_identifier == "isValidSignature(bytes32,bytes)"
 
 
+def test_ambiguous_function_methods(ambiguous_function_contract):
+    is_valid_signature_func = ambiguous_function_contract.get_function_by_signature(
+        "isValidSignature()"
+    )
+    is_valid_signature_bytes_func = (
+        ambiguous_function_contract.get_function_by_signature(
+            "isValidSignature(bytes,bytes)"
+        )
+    )
+    is_valid_signature_bytes32_func = (
+        ambiguous_function_contract.get_function_by_signature(
+            "isValidSignature(bytes32,bytes)"
+        )
+    )
+    assert is_valid_signature_func().call() == "valid"
+    assert is_valid_signature_bytes_func(b"hi", b"1").call() == 1
+    assert (
+        is_valid_signature_bytes32_func(
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",  # noqa: E501
+            b"0",
+        ).call()
+        == 0
+    )
+    assert ambiguous_function_contract.functions.isValidSignature().call() == "valid"
+    assert (
+        ambiguous_function_contract.functions.isValidSignature(b"hi", b"1").call() == 1
+    )
+
+
+def test_ambiguous_function_methods_and_arguments(ambiguous_function_contract):
+    # Raises because there exists a function without arguments
+    # So the function that accepts a bytes32 argument is not set
+    # for the ContractFunctions property with just the name
+    with pytest.raises(
+        MismatchedABI,
+        match=re.escape(
+            "Found multiple elements named `isValidSignature` that accept 2 "
+            "argument(s)."
+        ),
+    ):
+        ambiguous_function_contract.functions.isValidSignature(
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",  # noqa: E501
+            b"0",
+        )
+
+
 def test_contract_function_methods(string_contract):
     set_value_func = string_contract.get_function_by_signature("setValue(string)")
     get_value_func = string_contract.get_function_by_signature("getValue()")

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_call_interface.py

@@ -805,11 +805,11 @@ def test_call_sending_ether_to_nonpayable_function(payable_tester_contract, call
     "function, value",
     (
         # minimum positive unambiguous value (larger than fixed8x1)
-        ("reflect(fixed8x1)", Decimal("12.8")),
+        ("reflect(ufixed256x1)", Decimal("25.5")),
         # maximum value (for ufixed256x1)
         ("reflect(ufixed256x1)", Decimal(2**256 - 1) / 10),
         # maximum negative unambiguous value (less than 0 from ufixed*)
-        ("reflect(ufixed256x1)", Decimal("-0.1")),
+        ("reflect(fixed8x1)", Decimal("-0.1")),
         # minimum value (for fixed8x1)
         ("reflect(fixed8x1)", Decimal("-12.8")),
         # only ufixed256x80 type supports 2-80 decimals
@@ -822,6 +822,14 @@ def test_call_sending_ether_to_nonpayable_function(payable_tester_contract, call
         ("reflect_short_u", 0),
         # maximum value (for ufixed8x1)
         ("reflect_short_u", Decimal("25.5")),
+        ("reflect(fixed8x1)", Decimal("12.1")),
+        ("reflect(fixed8x1)", Decimal(0)),
+        ("reflect(fixed8x1)", 0),
+        ("reflect(ufixed256x80)", 0),
+        ("reflect", Decimal("12.1")),
+        ("reflect", Decimal(0)),
+        ("reflect", 0),
+        ("reflect", 0),
     ),
 )
 def test_reflect_fixed_value(fixed_reflector_contract, function, value):
@@ -880,22 +888,6 @@ DEFAULT_DECIMALS = getcontext().prec
             0.1,
             "Argument 1 value `0.1` is not compatible with type `ufixed8x1`.",
         ),
-        # ambiguous
-        (
-            "reflect(ufixed256x80)",
-            Decimal("12.7"),
-            r"Found multiple elements named `reflect` that accept 1 argument\(s\).",
-        ),
-        (
-            "reflect(ufixed256x80)",
-            Decimal(0),
-            r"Found multiple elements named `reflect` that accept 1 argument\(s\).",
-        ),
-        (
-            "reflect(ufixed256x80)",
-            0,
-            r"Found multiple elements named `reflect` that accept 1 argument\(s\).",
-        ),
     ),
 )
 def test_invalid_fixed_value_reflections(
@@ -1273,7 +1265,8 @@ def test_functions_iterator(w3, math_contract):
 
     for fn, expected_fn in zip(iter(functions_iter), all_functions):
         assert isinstance(fn, ContractFunction)
-        assert fn.fn_name == expected_fn.fn_name
+        assert fn.name == expected_fn.name
+        assert fn.fn_name == expected_fn.fn_name  # alias for name
 
 
 # -- async -- #
@@ -2000,11 +1993,11 @@ async def test_async_call_sending_ether_to_nonpayable_function(
     "function, value",
     (
         # minimum positive unambiguous value (larger than fixed8x1)
-        ("reflect(fixed8x1)", Decimal("12.8")),
+        ("reflect(ufixed256x1)", Decimal("25.5")),
         # maximum value (for ufixed256x1)
         ("reflect(ufixed256x1)", Decimal(2**256 - 1) / 10),
         # maximum negative unambiguous value (less than 0 from ufixed*)
-        ("reflect(ufixed256x1)", Decimal("-0.1")),
+        ("reflect(fixed8x1)", Decimal("-0.1")),
         # minimum value (for fixed8x1)
         ("reflect(fixed8x1)", Decimal("-12.8")),
         # only ufixed256x80 type supports 2-80 decimals
@@ -2017,6 +2010,14 @@ async def test_async_call_sending_ether_to_nonpayable_function(
         ("reflect_short_u", 0),
         # maximum value (for ufixed8x1)
         ("reflect_short_u", Decimal("25.5")),
+        ("reflect(fixed8x1)", Decimal("12.1")),
+        ("reflect(fixed8x1)", Decimal(0)),
+        ("reflect(fixed8x1)", 0),
+        ("reflect(ufixed256x80)", 0),
+        ("reflect", Decimal("12.1")),
+        ("reflect", Decimal(0)),
+        ("reflect", 0),
+        ("reflect", 0),
     ),
 )
 async def test_async_reflect_fixed_value(
@@ -2059,10 +2060,6 @@ MULTIPLE_MATCHING_ELEMENTS = (
         ("reflect(ufixed256x80)", Decimal(1) / 10**81, MULTIPLE_MATCHING_ELEMENTS),
         # floats not accepted, for floating point error concerns
         ("reflect_short_u", 0.1, NO_MATCHING_ARGUMENTS),
-        # ambiguous
-        ("reflect(ufixed256x80)", Decimal("12.7"), MULTIPLE_MATCHING_ELEMENTS),
-        ("reflect(ufixed256x80)", Decimal(0), MULTIPLE_MATCHING_ELEMENTS),
-        ("reflect(ufixed256x80)", 0, MULTIPLE_MATCHING_ELEMENTS),
     ),
 )
 async def test_async_invalid_fixed_value_reflections(
@@ -2491,4 +2488,5 @@ def test_async_functions_iterator(async_w3, async_math_contract):
 
     for fn, expected_fn in zip(iter(functions_iter), all_functions):
         assert isinstance(fn, AsyncContractFunction)
-        assert fn.fn_name == expected_fn.fn_name
+        assert fn.name == expected_fn.name
+        assert fn.fn_name == expected_fn.fn_name  # alias for name

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_class_construction.py

@@ -2,9 +2,16 @@ import json
 import pytest
 
 from eth_utils import (
+    abi_to_signature,
     decode_hex,
+    filter_abi_by_type,
+    get_abi_input_names,
+    get_abi_input_types,
 )
 
+from web3._utils.abi import (
+    get_name_from_abi_element_identifier,
+)
 from web3.contract import (
     Contract,
 )
@@ -31,6 +38,7 @@ def test_class_construction_sets_class_vars(
     assert math_contract_factory.w3 == w3
     assert math_contract_factory.bytecode == decode_hex(math_contract_bytecode)
     assert math_contract_factory.bytecode_runtime == decode_hex(math_contract_runtime)
+    assert math_contract_factory.abi == math_contract_abi
 
 
 def test_error_to_instantiate_base_class():
@@ -79,6 +87,90 @@ def test_error_to_call_non_existent_fallback(
         math_contract.fallback.estimate_gas()
 
 
+def test_contract_events_init_with_class_vars(
+    w3, math_contract_abi, math_contract_bytecode, math_contract_runtime
+):
+    math_contract = w3.eth.contract(
+        abi=math_contract_abi,
+        bytecode=math_contract_bytecode,
+        bytecode_runtime=math_contract_runtime,
+    )
+
+    for event_abi in filter_abi_by_type("event", math_contract_abi):
+        # Check properties of math_contract.events.EventName
+        event_by_name = math_contract.events[event_abi["name"]]
+        if event_by_name.abi["inputs"] == event_abi["inputs"]:
+            assert event_by_name.name == get_name_from_abi_element_identifier(
+                event_abi["name"]
+            )
+            assert event_by_name.abi == event_abi
+            assert event_by_name.abi_element_identifier == abi_to_signature(event_abi)
+            assert event_by_name.signature == abi_to_signature(event_abi)
+            assert event_by_name.argument_names == tuple(get_abi_input_names(event_abi))
+            assert event_by_name.argument_types == tuple(get_abi_input_types(event_abi))
+
+        # Check properties of math_contract.events._EventName(arg_names)
+        event_by_signature = math_contract.events[f"_{abi_to_signature(event_abi)}"]
+        assert event_by_signature.name == get_name_from_abi_element_identifier(
+            abi_to_signature(event_abi)
+        )
+        assert event_by_signature.abi == event_abi
+        assert event_by_signature.abi_element_identifier == abi_to_signature(event_abi)
+        assert event_by_signature.signature == abi_to_signature(event_abi)
+        assert event_by_signature.argument_names == tuple(
+            get_abi_input_names(event_abi)
+        )
+        assert event_by_signature.argument_types == tuple(
+            get_abi_input_types(event_abi)
+        )
+
+
+def test_contract_functions_init_with_class_vars(
+    w3, math_contract_abi, math_contract_bytecode, math_contract_runtime
+):
+    math_contract = w3.eth.contract(
+        abi=math_contract_abi,
+        bytecode=math_contract_bytecode,
+        bytecode_runtime=math_contract_runtime,
+    )
+
+    for function_abi in filter_abi_by_type("function", math_contract_abi):
+        # Check properties of math_contract.functions.FunctionName
+        function_by_name = math_contract.functions[function_abi["name"]]
+        if function_by_name.abi["inputs"] == function_abi["inputs"]:
+            assert function_by_name.name == get_name_from_abi_element_identifier(
+                function_abi["name"]
+            )
+            assert function_by_name.abi == function_abi
+            assert function_by_name.abi_element_identifier == abi_to_signature(
+                function_abi
+            )
+            assert function_by_name.signature == abi_to_signature(function_abi)
+            assert function_by_name.argument_names == tuple(
+                get_abi_input_names(function_abi)
+            )
+            assert function_by_name.argument_types == tuple(
+                get_abi_input_types(function_abi)
+            )
+
+        # Check properties of math_contract.functions._functionName(arg_names)
+        function_by_signature = math_contract.functions[abi_to_signature(function_abi)]
+        assert function_by_signature.name == get_name_from_abi_element_identifier(
+            abi_to_signature(function_abi)
+        )
+        assert function_by_signature.abi == function_abi
+        assert function_by_signature.abi_element_identifier == abi_to_signature(
+            function_abi
+        )
+        assert function_by_signature.signature == abi_to_signature(function_abi)
+        assert function_by_signature.argument_names == tuple(
+            get_abi_input_names(function_abi)
+        )
+        assert function_by_signature.argument_types == tuple(
+            get_abi_input_types(function_abi)
+        )
+
+
 @pytest.mark.parametrize(
     "abi,namespace,expected_exception",
     (

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_init.py

@@ -1,4 +1,5 @@
 import pytest
+import time
 
 from web3._utils.ens import (
     contract_ens_addresses,
@@ -75,3 +76,26 @@ def test_contract_with_name_address_changing(math_contract_factory, math_addr):
     # contract works again when name resolves correctly
     with contract_ens_addresses(mc, [("thedao.eth", math_addr)]):
         assert mc.functions.return13().call({"from": caller}) == 13
+
+
+def test_init_multiple_contracts_performance(w3, emitter_contract_data):
+    start_time = time.time()
+    for _ in range(500):
+        w3.eth.contract(
+            abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
+        )
+    # assert initializing 500 contracts is within a conservative / reasonable time
+    assert (time.time() - start_time) < 1.5
+
+
+# -- async -- #
+
+
+def test_async_init_multiple_contracts_performance(async_w3, emitter_contract_data):
+    start_time = time.time()
+    for _ in range(500):
+        async_w3.eth.contract(
+            abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
+        )
+    # assert initializing 500 contracts is within a conservative / reasonable time
+    assert (time.time() - start_time) < 1.5

{web3-7.6.0 → web3-7.6.1}/tests/core/contracts/test_contract_method_abi_decoding.py

@@ -106,10 +106,10 @@ a32bytes = b"a".ljust(32, b"\x00")
 def test_contract_abi_decoding(w3, abi, data, method, expected):
     contract = w3.eth.contract(abi=abi)
     func, params = contract.decode_function_input(data)
-    assert func.fn_name == method
+    assert func.name == method
     assert params == expected
 
-    reinvoke_func = contract.functions[func.fn_name](**params)
+    reinvoke_func = contract.functions[func.name](**params)
     rebuild_txn = reinvoke_func.build_transaction(
         {"gas": 0, "nonce": 0, "to": "\x00" * 20}
     )
@@ -139,10 +139,10 @@ def test_contract_abi_decoding(w3, abi, data, method, expected):
 def test_contract_abi_encoding_kwargs(w3, abi, method, expected, data):
     contract = w3.eth.contract(abi=abi)
     func, params = contract.decode_function_input(data)
-    assert func.fn_name == method
+    assert func.name == method
     assert params == expected
 
-    reinvoke_func = contract.functions[func.fn_name](**params)
+    reinvoke_func = contract.functions[func.name](**params)
     rebuild_txn = reinvoke_func.build_transaction(
         {"gas": 0, "nonce": 0, "to": "\x00" * 20}
     )