web3 7.5.0__tar.gz → 7.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.5.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
@@ -33,11 +33,11 @@ Requires-Dist: pywin32>=223; platform_system == "Windows"
 Requires-Dist: requests>=2.23.0
 Requires-Dist: typing-extensions>=4.0.1
 Requires-Dist: types-requests>=2.0.0
-Requires-Dist: websockets>=10.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.5.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.5.0",
+    version="7.6.1",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -78,7 +78,7 @@ setup(
         "requests>=2.23.0",
         "typing-extensions>=4.0.1",
         "types-requests>=2.0.0",
-        "websockets>=10.0.0",
+        "websockets>=10.0.0,<14.0.0",
         "pyunormalize>=15.0.0",
     ],
     python_requires=">=3.8, <4",

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

@@ -10,6 +10,12 @@ from tests.core.contracts.utils import (
 from tests.utils import (
     async_partial,
 )
+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,
 )
@@ -22,6 +28,7 @@ from web3._utils.contract_sources.contract_data.contract_caller_tester import (
     CONTRACT_CALLER_TESTER_DATA,
 )
 from web3._utils.contract_sources.contract_data.event_contracts import (
+    AMBIGUOUS_EVENT_NAME_CONTRACT_DATA,
     EVENT_CONTRACT_DATA,
     INDEXED_EVENT_CONTRACT_DATA,
 )
@@ -61,6 +68,10 @@ from web3._utils.contract_sources.contract_data.tuple_contracts import (
 from web3.exceptions import (
     Web3ValueError,
 )
+from web3.utils.abi import (
+    abi_to_signature,
+    get_abi_element,
+)
 
 # --- function name tester contract --- #
 
@@ -187,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 --- #
 
 
@@ -283,6 +314,30 @@ def indexed_event_contract(
     return indexed_event_contract
 
 
+@pytest.fixture
+def ambiguous_event_contract(
+    w3, wait_for_block, wait_for_transaction, address_conversion_func
+):
+    wait_for_block(w3)
+
+    ambiguous_event_contract_factory = w3.eth.contract(
+        **AMBIGUOUS_EVENT_NAME_CONTRACT_DATA
+    )
+    deploy_txn_hash = ambiguous_event_contract_factory.constructor().transact(
+        {"gas": 1000000}
+    )
+    deploy_receipt = wait_for_transaction(w3, deploy_txn_hash)
+    contract_address = address_conversion_func(deploy_receipt["contractAddress"])
+
+    bytecode = w3.eth.get_code(contract_address)
+    assert bytecode == ambiguous_event_contract_factory.bytecode_runtime
+    ambiguous_event_name_contract = ambiguous_event_contract_factory(
+        address=contract_address
+    )
+    assert ambiguous_event_name_contract.address == contract_address
+    return ambiguous_event_name_contract
+
+
 # --- arrays contract --- #
 
 
@@ -470,6 +525,11 @@ def invoke_contract(
     func_kwargs=None,
     tx_params=None,
 ):
+    function_signature = contract_function
+    function_arg_count = len(func_args or ()) + len(func_kwargs or {})
+    if function_arg_count == 0:
+        function_signature = get_abi_element_signature(contract_function)
+
     if func_args is None:
         func_args = []
     if func_kwargs is None:
@@ -482,7 +542,14 @@ def invoke_contract(
             f"allowable_invoke_method must be one of: {allowable_call_desig}"
         )
 
-    function = contract.functions[contract_function]
+    fn_abi = get_abi_element(
+        contract.abi,
+        function_signature,
+        *func_args,
+        abi_codec=contract.w3.codec,
+        **func_kwargs,
+    )
+    function = contract.functions[abi_to_signature(fn_abi)]
     result = getattr(function(*func_args, **func_kwargs), api_call_desig)(tx_params)
 
     return result
@@ -736,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,
@@ -744,6 +822,11 @@ async def async_invoke_contract(
     func_kwargs=None,
     tx_params=None,
 ):
+    function_signature = contract_function
+    function_arg_count = len(func_args or ()) + len(func_kwargs or {})
+    if function_arg_count == 0:
+        function_signature = get_abi_element_signature(contract_function)
+
     if func_args is None:
         func_args = []
     if func_kwargs is None:
@@ -756,7 +839,14 @@ async def async_invoke_contract(
             f"allowable_invoke_method must be one of: {allowable_call_desig}"
         )
 
-    function = contract.functions[contract_function]
+    fn_abi = get_abi_element(
+        contract.abi,
+        function_signature,
+        *func_args,
+        abi_codec=contract.w3.codec,
+        **func_kwargs,
+    )
+    function = contract.functions[abi_to_signature(fn_abi)]
     result = await getattr(function(*func_args, **func_kwargs), api_call_desig)(
         tx_params
     )

web3-7.6.1/tests/core/contracts/test_contract_ambiguous_events.py

@@ -0,0 +1,401 @@
+import pytest
+from typing import (
+    cast,
+)
+
+from eth_typing import (
+    ABI,
+)
+
+from web3.contract.async_contract import (
+    AsyncContract,
+)
+from web3.contract.contract import (
+    Contract,
+    ContractEvent,
+)
+from web3.exceptions import (
+    MismatchedABI,
+)
+from web3.main import (
+    AsyncWeb3,
+    Web3,
+)
+from web3.utils.abi import (
+    get_abi_element,
+)
+
+ABI_EVENT_TRANSFER = {
+    "anonymous": False,
+    "inputs": [
+        {
+            "indexed": True,
+            "internalType": "address",
+            "name": "from",
+            "type": "address",
+        },
+        {
+            "indexed": True,
+            "internalType": "address",
+            "name": "to",
+            "type": "address",
+        },
+        {
+            "indexed": False,
+            "internalType": "uint256",
+            "name": "value",
+            "type": "uint256",
+        },
+    ],
+    "name": "Transfer",
+    "type": "event",
+}
+ABI_EVENT_DEPOSIT_WITH_TUPLE = {
+    "anonymous": False,
+    "inputs": [
+        {
+            "indexed": True,
+            "internalType": "address",
+            "name": "from",
+            "type": "address",
+        },
+        {
+            "indexed": True,
+            "internalType": "bytes32",
+            "name": "id",
+            "type": "bytes32",
+        },
+        {
+            "components": [
+                {"internalType": "uint256", "name": "x", "type": "uint256"},
+                {"internalType": "uint256", "name": "y", "type": "uint256"},
+            ],
+            "indexed": False,
+            "internalType": "struct DepositEventContract.T",
+            "name": "value",
+            "type": "tuple",
+        },
+    ],
+    "name": "Deposit",
+    "type": "event",
+}
+
+ABI_EVENT_DEPOSIT = {
+    "anonymous": False,
+    "inputs": [
+        {
+            "indexed": True,
+            "internalType": "address",
+            "name": "from",
+            "type": "address",
+        },
+        {
+            "indexed": True,
+            "internalType": "bytes32",
+            "name": "id",
+            "type": "bytes32",
+        },
+        {
+            "indexed": False,
+            "internalType": "uint256",
+            "name": "value",
+            "type": "uint256",
+        },
+    ],
+    "name": "Deposit",
+    "type": "event",
+}
+ABI_FUNCTION_DEPOSIT_STRUCT = {
+    "inputs": [{"internalType": "bytes32", "name": "id", "type": "bytes32"}],
+    "name": "depositStruct",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function",
+}
+ABI_FUNCTION_DEPOSIT_VALUE = {
+    "inputs": [{"internalType": "bytes32", "name": "id", "type": "bytes32"}],
+    "name": "depositValue",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function",
+}
+AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI = [
+    ABI_EVENT_DEPOSIT_WITH_TUPLE,
+    ABI_EVENT_DEPOSIT,
+    ABI_EVENT_TRANSFER,
+    ABI_FUNCTION_DEPOSIT_STRUCT,
+    ABI_FUNCTION_DEPOSIT_VALUE,
+]
+
+
+def test_get_abi_from_event_signature(ambiguous_event_contract: "Contract") -> None:
+    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(uint256)"].abi
+    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),
+        "Deposit",
+        *[
+            "0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7",
+            b"0x0",
+        ],
+        **{"value": {"x": 1, "y": 2}},
+    )
+
+    assert event_abi == ABI_EVENT_DEPOSIT_WITH_TUPLE
+
+    event_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI),
+        "Deposit",
+        *[
+            "0xFe89cc7aBB2C4183683ab71653C4cdc9B02D44b7",
+            b"0x0",
+            1,
+        ],
+    )
+
+    assert event_abi == ABI_EVENT_DEPOSIT
+
+
+def test_get_abi_element_with_signature_for_ambiguous_tuple_events() -> None:
+    event_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI),
+        "Deposit(address,bytes32,(uint256,uint256))",
+    )
+
+    assert event_abi == ABI_EVENT_DEPOSIT_WITH_TUPLE
+
+    event_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_EVENT_WITH_TUPLE_CONTRACT_ABI),
+        "Deposit(address,bytes32,uint256)",
+    )
+
+    assert event_abi == ABI_EVENT_DEPOSIT
+
+
+def test_get_abi_element_by_name_and_arguments_errors(
+    ambiguous_event_contract: "Contract",
+) -> None:
+    with pytest.raises(
+        MismatchedABI,
+        match=r"ABI Not Found!\nNo element named `NotAnEvent` with 0 argument\(s\).",
+    ):
+        get_abi_element(ambiguous_event_contract.abi, "NotAnEvent")
+
+
+def test_contract_event_methods(
+    w3: "Web3", ambiguous_event_contract: "Contract"
+) -> None:
+    log_arg_event = cast(
+        ContractEvent, 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.name == "LogSingleArg"
+    assert log_arg_event.abi_element_identifier == "LogSingleArg(uint256)"
+    assert 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 = filter_builder.deploy(w3)
+
+    assert filter_instance.filter_params == {
+        "fromBlock": "latest",
+        "toBlock": "latest",
+        "address": ambiguous_event_contract.address,
+        "topics": (
+            "0x56d2ef3c5228bf5d88573621e325a4672ab50e033749a601e4f4a5e1dce905d4",
+        ),
+    }
+
+    log_filter = log_arg_event.create_filter(from_block="latest")
+    log_entry = {
+        "address": 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": ambiguous_event_contract.address,
+        "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,
+    }