web3 7.5.0__tar.gz → 7.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.5.0
+Version: 7.6.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -33,7 +33,7 @@ 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"

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

@@ -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.0",
     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.0}/tests/core/contracts/conftest.py

@@ -10,6 +10,9 @@ 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.arrays_contract import (
     ARRAYS_CONTRACT_DATA,
 )
@@ -22,6 +25,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 +65,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 --- #
 
@@ -283,6 +291,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 +502,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 +519,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
@@ -744,6 +788,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 +805,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.0/tests/core/contracts/test_contract_ambiguous_events.py

@@ -0,0 +1,259 @@
+import pytest
+from typing import (
+    cast,
+)
+
+from eth_typing import (
+    ABI,
+)
+
+from web3.contract.contract import (
+    Contract,
+    ContractEvent,
+)
+from web3.exceptions import (
+    MismatchedABI,
+)
+from web3.main import (
+    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(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_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.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,
+    }

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

@@ -1,5 +1,11 @@
 import pytest
+from typing import (
+    cast,
+)
 
+from eth_typing import (
+    ABI,
+)
 from eth_utils.toolz import (
     compose,
     curry,
@@ -11,41 +17,63 @@ from hexbytes import (
 from web3.exceptions import (
     Web3ValueError,
 )
+from web3.utils.abi import (
+    get_abi_element,
+)
+
+BLOCK_HASH_ABI = {
+    "constant": False,
+    "inputs": [{"name": "input", "type": "uint256"}],
+    "name": "blockHashAmphithyronVersify",
+    "outputs": [{"name": "", "type": "uint256"}],
+    "payable": False,
+    "stateMutability": "nonpayable",
+    "type": "function",
+}
+
+IDENTITY_WITH_UINT_ABI = {
+    "constant": False,
+    "inputs": [
+        {"name": "input", "type": "uint256"},
+        {"name": "uselessFlag", "type": "bool"},
+    ],
+    "name": "identity",
+    "outputs": [{"name": "", "type": "uint256"}],
+    "payable": False,
+    "stateMutability": "nonpayable",
+    "type": "function",
+}
+
+IDENTITY_WITH_INT_ABI = {
+    "constant": False,
+    "inputs": [
+        {"name": "input", "type": "int256"},
+        {"name": "uselessFlag", "type": "bool"},
+    ],
+    "name": "identity",
+    "outputs": [{"name": "", "type": "int256"}],
+    "payable": False,
+    "stateMutability": "nonpayable",
+    "type": "function",
+}
+
+IDENTITY_WITH_BOOL_ABI = {
+    "constant": False,
+    "inputs": [
+        {"name": "valid", "type": "bool"},
+    ],
+    "name": "identity",
+    "outputs": [{"name": "valid", "type": "bool"}],
+    "payable": False,
+    "stateMutability": "nonpayable",
+    "type": "function",
+}
 
 AMBIGUOUS_CONTRACT_ABI = [
-    {
-        "constant": False,
-        "inputs": [{"name": "input", "type": "uint256"}],
-        "name": "blockHashAmphithyronVersify",
-        "outputs": [{"name": "", "type": "uint256"}],
-        "payable": False,
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "constant": False,
-        "inputs": [
-            {"name": "input", "type": "uint256"},
-            {"name": "uselessFlag", "type": "bool"},
-        ],
-        "name": "identity",
-        "outputs": [{"name": "", "type": "uint256"}],
-        "payable": False,
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
-    {
-        "constant": False,
-        "inputs": [
-            {"name": "input", "type": "int256"},
-            {"name": "uselessFlag", "type": "bool"},
-        ],
-        "name": "identity",
-        "outputs": [{"name": "", "type": "int256"}],
-        "payable": False,
-        "stateMutability": "nonpayable",
-        "type": "function",
-    },
+    BLOCK_HASH_ABI,
+    IDENTITY_WITH_UINT_ABI,
+    IDENTITY_WITH_INT_ABI,
+    IDENTITY_WITH_BOOL_ABI,
 ]
 
 
@@ -75,6 +103,7 @@ map_repr = compose(list, curry(map, repr))
                 "<Function blockHashAmphithyronVersify(uint256)>",
                 "<Function identity(uint256,bool)>",
                 "<Function identity(int256,bool)>",
+                "<Function identity(bool)>",
             ],
         ),
         (
@@ -83,11 +112,21 @@ map_repr = compose(list, curry(map, repr))
             repr,
             "<Function identity(uint256,bool)>",
         ),
+        (
+            "get_function_by_signature",
+            ("identity(int256,bool)",),
+            repr,
+            "<Function identity(int256,bool)>",
+        ),
         (
             "find_functions_by_name",
             ("identity",),
             map_repr,
-            ["<Function identity(uint256,bool)>", "<Function identity(int256,bool)>"],
+            [
+                "<Function identity(uint256,bool)>",
+                "<Function identity(int256,bool)>",
+                "<Function identity(bool)>",
+            ],
         ),
         (
             "get_function_by_name",
@@ -227,6 +266,32 @@ def test_functions_error_messages(w3, method, args, expected_message, expected_e
         getattr(contract, method)(*args)
 
 
+def test_ambiguous_functions_abi_element_identifier(w3):
+    abi = [
+        {
+            "name": "isValidSignature",
+            "type": "function",
+            "inputs": [
+                {"internalType": "bytes32", "name": "id", "type": "bytes32"},
+                {"internalType": "bytes", "name": "id", "type": "bytes"},
+            ],
+        },
+        {
+            "name": "isValidSignature",
+            "type": "function",
+            "inputs": [
+                {"internalType": "bytes", "name": "id", "type": "bytes"},
+                {"internalType": "bytes", "name": "id", "type": "bytes"},
+            ],
+        },
+    ]
+    contract = w3.eth.contract(abi=abi)
+    fn_bytes = contract.get_function_by_signature("isValidSignature(bytes,bytes)")
+    assert fn_bytes.abi_element_identifier == "isValidSignature(bytes,bytes)"
+    fn_bytes32 = contract.get_function_by_signature("isValidSignature(bytes32,bytes)")
+    assert fn_bytes32.abi_element_identifier == "isValidSignature(bytes32,bytes)"
+
+
 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()")
@@ -242,3 +307,61 @@ def test_diff_between_fn_and_fn_called(string_contract):
     assert get_value_func is not get_value_func_called
     assert repr(get_value_func) == "<Function getValue()>"
     assert repr(get_value_func_called) == "<Function getValue() bound to ()>"
+
+
+def test_get_abi_element_for_ambiguous_functions() -> None:
+    function_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_CONTRACT_ABI),
+        "identity",
+        *[
+            2**256 - 1,  # uint256 maximum
+            False,
+        ],
+    )
+
+    assert function_abi == IDENTITY_WITH_UINT_ABI
+
+    function_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_CONTRACT_ABI),
+        "identity",
+        *[
+            -1,
+            True,
+        ],
+    )
+
+    assert function_abi == IDENTITY_WITH_INT_ABI
+
+    function_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_CONTRACT_ABI),
+        "identity",
+        *[
+            False,
+        ],
+    )
+
+    assert function_abi == IDENTITY_WITH_BOOL_ABI
+
+
+def test_get_abi_element_for_ambiguous_function_arguments():
+    function_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_CONTRACT_ABI),
+        "identity(int256,bool)",
+        *[
+            1,
+            False,
+        ],
+    )
+
+    assert function_abi == IDENTITY_WITH_INT_ABI
+
+    function_abi = get_abi_element(
+        cast(ABI, AMBIGUOUS_CONTRACT_ABI),
+        "identity(uint256,bool)",
+        *[
+            1,
+            False,
+        ],
+    )
+
+    assert function_abi == IDENTITY_WITH_UINT_ABI

{web3-7.5.0 → web3-7.6.0}/tests/core/contracts/test_contract_attributes.py

@@ -11,6 +11,11 @@ def abi():
     return """[{"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"uint256"}],"name":"Increased","type":"function"}, {"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"uint256"}],"name":"Increased","type":"event"}]"""  # noqa: E501
 
 
+@pytest.fixture()
+def ambiguous_abis():
+    return """[{"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"uint256"}],"name":"Increased","type":"function"}, {"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"bytes32"}],"name":"Increased","type":"function"}, {"anonymous":false,"inputs":[{"indexed":false,"name":"value","type":"uint256"}],"name":"Increased","type":"event"}, {"anonymous":false,"inputs":[],"name":"Increased","type":"event"}]"""  # noqa: E501
+
+
 @pytest.mark.parametrize("attribute", ("functions", "events", "caller"))
 def test_getattr(w3, abi, attribute):
     contract = w3.eth.contract(abi=abi)