web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/_utils/contracts.py

@@ -1,13 +1,14 @@
+import copy
 import functools
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
-    Type,
     Union,
     cast,
 )
@@ -19,6 +20,14 @@ from eth_abi.registry import (
     registry as default_registry,
 )
 from eth_typing import (
+    ABI,
+    ABICallable,
+    ABIConstructor,
+    ABIElement,
+    ABIEvent,
+    ABIFallback,
+    ABIFunction,
+    ABIReceive,
     ChecksumAddress,
     HexStr,
     TypeStr,
@@ -26,11 +35,9 @@ from eth_typing import (
 from eth_utils import (
     add_0x_prefix,
     encode_hex,
-    function_abi_to_4byte_selector,
-    is_binary_address,
-    is_checksum_address,
-    is_list_like,
-    is_text,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    get_abi_input_types,
 )
 from eth_utils.toolz import (
     pipe,
@@ -40,19 +47,10 @@ from hexbytes import (
 )
 
 from web3._utils.abi import (
-    abi_to_signature,
-    check_if_arguments_can_be_encoded,
-    filter_by_argument_count,
     filter_by_argument_name,
-    filter_by_encodability,
-    filter_by_name,
-    filter_by_type,
-    get_abi_input_types,
-    get_aligned_abi_inputs,
-    get_fallback_func_abi,
-    get_receive_func_abi,
+    get_abi_element_signature,
+    get_name_from_abi_element_identifier,
     map_abi_data,
-    merge_args_and_kwargs,
     named_tree,
 )
 from web3._utils.blocks import (
@@ -61,10 +59,6 @@ from web3._utils.blocks import (
 from web3._utils.encoding import (
     to_hex,
 )
-from web3._utils.function_identifiers import (
-    FallbackFn,
-    ReceiveFn,
-)
 from web3._utils.method_formatters import (
     to_integer_if_hex,
 )
@@ -75,17 +69,24 @@ from web3._utils.normalizers import (
     abi_string_to_text,
 )
 from web3.exceptions import (
-    BlockNumberOutofRange,
+    BlockNumberOutOfRange,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
-    ABI,
-    ABIEvent,
-    ABIFunction,
+    ABIElementIdentifier,
     BlockIdentifier,
     BlockNumber,
+    TContractEvent,
+    TContractFn,
     TxParams,
 )
+from web3.utils.abi import (
+    check_if_arguments_can_be_encoded,
+    get_abi_element,
+    get_abi_element_info,
+)
 
 if TYPE_CHECKING:
     from web3 import (  # noqa: F401
@@ -94,130 +95,50 @@ if TYPE_CHECKING:
     )
 
 
-def extract_argument_types(*args: Sequence[Any]) -> str:
-    """
-    Takes a list of arguments and returns a string representation of the argument types,
-    appropriately collapsing `tuple` types into the respective nested types.
-    """
-    collapsed_args = []
-
-    for arg in args:
-        if is_list_like(arg):
-            collapsed_nested = []
-            for nested in arg:
-                if is_list_like(nested):
-                    collapsed_nested.append(f"({extract_argument_types(nested)})")
-                else:
-                    collapsed_nested.append(_get_argument_readable_type(nested))
-            collapsed_args.append(",".join(collapsed_nested))
-        else:
-            collapsed_args.append(_get_argument_readable_type(arg))
-
-    return ",".join(collapsed_args)
-
-
 def find_matching_event_abi(
     abi: ABI,
     event_name: Optional[str] = None,
     argument_names: Optional[Sequence[str]] = None,
 ) -> ABIEvent:
-    filters = [
-        functools.partial(filter_by_type, "event"),
+    filters: List[functools.partial[Sequence[ABIElement]]] = [
+        functools.partial(filter_abi_by_type, "event"),
     ]
 
     if event_name is not None:
-        filters.append(functools.partial(filter_by_name, event_name))
+        filters.append(functools.partial(filter_abi_by_name, event_name))
 
     if argument_names is not None:
         filters.append(functools.partial(filter_by_argument_name, argument_names))
 
-    event_abi_candidates = pipe(abi, *filters)
+    event_abi_candidates: Sequence[ABIEvent] = pipe(abi, *filters)
 
     if len(event_abi_candidates) == 1:
         return event_abi_candidates[0]
     elif not event_abi_candidates:
-        raise ValueError("No matching events found")
+        raise Web3ValueError("No matching events found")
     else:
-        raise ValueError("Multiple events found")
-
-
-def find_matching_fn_abi(
-    abi: ABI,
-    abi_codec: ABICodec,
-    fn_identifier: Optional[Union[str, Type[FallbackFn], Type[ReceiveFn]]] = None,
-    args: Optional[Sequence[Any]] = None,
-    kwargs: Optional[Any] = None,
-) -> ABIFunction:
-    args = args or tuple()
-    kwargs = kwargs or dict()
-    num_arguments = len(args) + len(kwargs)
-
-    if fn_identifier is FallbackFn:
-        return get_fallback_func_abi(abi)
-
-    if fn_identifier is ReceiveFn:
-        return get_receive_func_abi(abi)
-
-    if not is_text(fn_identifier):
-        raise TypeError("Unsupported function identifier")
-
-    name_filter = functools.partial(filter_by_name, fn_identifier)
-    arg_count_filter = functools.partial(filter_by_argument_count, num_arguments)
-    encoding_filter = functools.partial(filter_by_encodability, abi_codec, args, kwargs)
-
-    function_candidates = pipe(abi, name_filter, arg_count_filter, encoding_filter)
-
-    if len(function_candidates) == 1:
-        return function_candidates[0]
-    else:
-        matching_identifiers = name_filter(abi)
-        matching_function_signatures = [
-            abi_to_signature(func) for func in matching_identifiers
-        ]
-
-        arg_count_matches = len(arg_count_filter(matching_identifiers))
-        encoding_matches = len(encoding_filter(matching_identifiers))
-
-        if arg_count_matches == 0:
-            diagnosis = (
-                "\nFunction invocation failed due to improper number of arguments."
-            )
-        elif encoding_matches == 0:
-            diagnosis = (
-                "\nFunction invocation failed due to no matching argument types."
-            )
-        elif encoding_matches > 1:
-            diagnosis = (
-                "\nAmbiguous argument encoding. "
-                "Provided arguments can be encoded to multiple functions "
-                "matching this call."
-            )
-
-        collapsed_args = extract_argument_types(args)
-        collapsed_kwargs = dict(
-            {(k, extract_argument_types([v])) for k, v in kwargs.items()}
-        )
-        message = (
-            f"\nCould not identify the intended function with name `{fn_identifier}`, "
-            f"positional arguments with type(s) `{collapsed_args}` and "
-            f"keyword arguments with type(s) `{collapsed_kwargs}`."
-            f"\nFound {len(matching_identifiers)} function(s) with "
-            f"the name `{fn_identifier}`: {matching_function_signatures}{diagnosis}"
-        )
-
-        raise Web3ValidationError(message)
+        raise Web3ValueError("Multiple events found")
 
 
 def encode_abi(
     w3: Union["AsyncWeb3", "Web3"],
-    abi: ABIFunction,
+    abi: ABIElement,
     arguments: Sequence[Any],
     data: Optional[HexStr] = None,
 ) -> HexStr:
-    argument_types = get_abi_input_types(abi)
-
-    if not check_if_arguments_can_be_encoded(abi, w3.codec, arguments, {}):
-        raise TypeError(
+    argument_types = []
+    try:
+        argument_types = get_abi_input_types(abi)
+    except ValueError:
+        # Use the default argument_types if the abi doesn't have inputs
+        pass
+
+    if not check_if_arguments_can_be_encoded(
+        abi,
+        *arguments,
+        abi_codec=w3.codec,
+    ):
+        raise Web3TypeError(
             "One or more arguments could not be encoded to the necessary "
             f"ABI type. Expected types are: {', '.join(argument_types)}"
         )
@@ -248,25 +169,45 @@ def encode_abi(
 def prepare_transaction(
     address: ChecksumAddress,
     w3: Union["AsyncWeb3", "Web3"],
-    fn_identifier: Union[str, Type[FallbackFn], Type[ReceiveFn]],
+    abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
+    abi_callable: Optional[ABICallable] = None,
     transaction: Optional[TxParams] = None,
     fn_args: Optional[Sequence[Any]] = None,
     fn_kwargs: Optional[Any] = None,
 ) -> TxParams:
     """
-    :parameter `is_function_abi` is used to distinguish  function abi from contract abi
     Returns a dictionary of the transaction that could be used to call this
     TODO: make this a public API
     TODO: add new prepare_deploy_transaction API
     """
-    if fn_abi is None:
-        fn_abi = find_matching_fn_abi(
-            contract_abi, w3.codec, fn_identifier, fn_args, fn_kwargs
+    fn_args = fn_args or []
+    fn_kwargs = fn_kwargs or {}
+
+    if not fn_args and not fn_kwargs and "(" not in str(abi_element_identifier):
+        abi_element_identifier = get_abi_element_signature(abi_element_identifier)
+
+    if abi_element_identifier in [
+        "fallback()",
+        "receive()",
+    ]:
+        abi_element_identifier = get_name_from_abi_element_identifier(
+            abi_element_identifier
         )
 
-    validate_payable(transaction, fn_abi)
+    if abi_callable is None:
+        abi_callable = cast(
+            ABICallable,
+            get_abi_element(
+                contract_abi,
+                abi_element_identifier,
+                *fn_args,
+                abi_codec=w3.codec,
+                **fn_kwargs,
+            ),
+        )
+
+    validate_payable(transaction, abi_callable)
 
     if transaction is None:
         prepared_transaction: TxParams = {}
@@ -274,16 +215,16 @@ def prepare_transaction(
         prepared_transaction = cast(TxParams, dict(**transaction))
 
     if "data" in prepared_transaction:
-        raise ValueError("Transaction parameter may not contain a 'data' key")
+        raise Web3ValueError("Transaction parameter may not contain a 'data' key")
 
     if address:
         prepared_transaction.setdefault("to", address)
 
     prepared_transaction["data"] = encode_transaction_data(
         w3,
-        fn_identifier,
+        abi_element_identifier,
         contract_abi,
-        fn_abi,
+        abi_callable,
         fn_args,
         fn_kwargs,
     )
@@ -292,34 +233,37 @@ def prepare_transaction(
 
 def encode_transaction_data(
     w3: Union["AsyncWeb3", "Web3"],
-    fn_identifier: Union[str, Type[FallbackFn], Type[ReceiveFn]],
+    abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
+    abi_callable: Optional[ABICallable] = None,
     args: Optional[Sequence[Any]] = None,
     kwargs: Optional[Any] = None,
 ) -> HexStr:
-    if fn_identifier is FallbackFn:
-        fn_abi, fn_selector, fn_arguments = get_fallback_function_info(
-            contract_abi, fn_abi
+    info_abi: ABIElement
+    abi_element_name = get_name_from_abi_element_identifier(abi_element_identifier)
+    if abi_element_name == "fallback":
+        info_abi, info_selector, info_arguments = get_fallback_function_info(
+            contract_abi, cast(ABIFallback, abi_callable)
         )
-    elif fn_identifier is ReceiveFn:
-        fn_abi, fn_selector, fn_arguments = get_receive_function_info(
-            contract_abi, fn_abi
+    elif abi_element_name == "receive":
+        info_abi, info_selector, info_arguments = get_receive_function_info(
+            contract_abi, cast(ABIReceive, abi_callable)
         )
-    elif is_text(fn_identifier):
-        fn_abi, fn_selector, fn_arguments = get_function_info(
-            # type ignored b/c fn_id here is always str b/c FallbackFn is handled above
-            fn_identifier,  # type: ignore
-            w3.codec,
+    elif isinstance(abi_element_identifier, str):
+        fn_info = get_abi_element_info(
             contract_abi,
-            fn_abi,
-            args,
-            kwargs,
+            abi_element_identifier,
+            *args,
+            abi_codec=w3.codec,
+            **kwargs,
         )
+        info_abi = fn_info["abi"]
+        info_selector = fn_info["selector"]
+        info_arguments = fn_info["arguments"]
     else:
-        raise TypeError("Unsupported function identifier")
+        raise Web3TypeError("Unsupported function identifier")
 
-    return add_0x_prefix(encode_abi(w3, fn_abi, fn_arguments, fn_selector))
+    return add_0x_prefix(encode_abi(w3, info_abi, info_arguments, info_selector))
 
 
 def decode_transaction_data(
@@ -327,91 +271,71 @@ def decode_transaction_data(
     data: HexStr,
     normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]] = None,
 ) -> Dict[str, Any]:
-    # type ignored b/c expects data arg to be HexBytes
-    data = HexBytes(data)  # type: ignore
+    data_bytes = HexBytes(data)
     types = get_abi_input_types(fn_abi)
     abi_codec = ABICodec(default_registry)
-    decoded = abi_codec.decode(types, HexBytes(data[4:]))
+    decoded = abi_codec.decode(types, data_bytes[4:])
     if normalizers:
         decoded = map_abi_data(normalizers, types, decoded)
     return named_tree(fn_abi["inputs"], decoded)
 
 
-def get_fallback_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIFunction] = None
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_fallback_func_abi(contract_abi)
+def get_constructor_function_info(
+    contract_abi: Optional[ABI] = None, constructor_abi: Optional[ABIConstructor] = None
+) -> Tuple[ABIConstructor, HexStr, Tuple[Any, ...]]:
+    if constructor_abi is None:
+        constructor_abi = cast(
+            ABIConstructor, get_abi_element(contract_abi, "constructor")
+        )
     fn_selector = encode_hex(b"")
     fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
+    return constructor_abi, fn_selector, fn_arguments
 
 
-def get_receive_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIFunction] = None
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_receive_func_abi(contract_abi)
+def get_fallback_function_info(
+    contract_abi: Optional[ABI] = None, fallback_abi: Optional[ABIFallback] = None
+) -> Tuple[ABIFallback, HexStr, Tuple[Any, ...]]:
+    if fallback_abi is None:
+        fallback_abi = cast(ABIFallback, get_abi_element(contract_abi, "fallback"))
     fn_selector = encode_hex(b"")
     fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
+    return fallback_abi, fn_selector, fn_arguments
 
 
-def get_function_info(
-    fn_name: str,
-    abi_codec: ABICodec,
-    contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
-    args: Optional[Sequence[Any]] = None,
-    kwargs: Optional[Any] = None,
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if args is None:
-        args = tuple()
-    if kwargs is None:
-        kwargs = {}
-
-    if fn_abi is None:
-        fn_abi = find_matching_fn_abi(contract_abi, abi_codec, fn_name, args, kwargs)
-
-    # typed dict cannot be used w/ a normal Dict
-    # https://github.com/python/mypy/issues/4976
-    fn_selector = encode_hex(function_abi_to_4byte_selector(fn_abi))  # type: ignore
-
-    fn_arguments = merge_args_and_kwargs(fn_abi, args, kwargs)
-
-    _, aligned_fn_arguments = get_aligned_abi_inputs(fn_abi, fn_arguments)
-
-    return fn_abi, fn_selector, aligned_fn_arguments
+def get_receive_function_info(
+    contract_abi: Optional[ABI] = None, receive_abi: Optional[ABIReceive] = None
+) -> Tuple[ABIReceive, HexStr, Tuple[Any, ...]]:
+    if receive_abi is None:
+        receive_abi = cast(ABIReceive, get_abi_element(contract_abi, "receive"))
+    fn_selector = encode_hex(b"")
+    fn_arguments: Tuple[Any, ...] = tuple()
+    return receive_abi, fn_selector, fn_arguments
 
 
-def validate_payable(transaction: TxParams, abi: ABIFunction) -> None:
-    """Raise Web3ValidationError if non-zero ether
+def validate_payable(transaction: TxParams, abi_callable: ABICallable) -> None:
+    """
+    Raise Web3ValidationError if non-zero ether
     is sent to a non-payable function.
     """
-    if "value" in transaction:
-        if to_integer_if_hex(transaction["value"]) != 0:
-            if (
-                "payable" in abi
-                and not abi["payable"]
-                or "stateMutability" in abi
-                and abi["stateMutability"] == "nonpayable"
-            ):
-                raise Web3ValidationError(
-                    "Sending non-zero ether to a contract function "
-                    "with payable=False. Please ensure that "
-                    "transaction's value is 0."
-                )
-
-
-def _get_argument_readable_type(arg: Any) -> str:
-    if is_checksum_address(arg) or is_binary_address(arg):
-        return "address"
-
-    return arg.__class__.__name__
+    if (
+        "value" in transaction
+        and to_integer_if_hex(transaction["value"]) != 0
+        and (
+            "payable" in abi_callable
+            and not abi_callable["payable"]
+            or "stateMutability" in abi_callable
+            and abi_callable["stateMutability"] == "nonpayable"
+        )
+    ):
+        raise Web3ValidationError(
+            "Sending non-zero ether to a contract function "
+            "with payable=False. Please ensure that "
+            "transaction's value is 0."
+        )
 
 
 def parse_block_identifier(
-    w3: "Web3", block_identifier: BlockIdentifier
+    w3: "Web3", block_identifier: Optional[BlockIdentifier]
 ) -> BlockIdentifier:
     if block_identifier is None:
         return w3.eth.default_block
@@ -424,7 +348,7 @@ def parse_block_identifier(
     ):
         return w3.eth.get_block(block_identifier)["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNumber:
@@ -434,7 +358,7 @@ def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNu
         last_block = w3.eth.get_block("latest")["number"]
         block_num = last_block + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)
 
 
@@ -453,7 +377,7 @@ async def async_parse_block_identifier(
         requested_block = await async_w3.eth.get_block(block_identifier)
         return requested_block["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 async def async_parse_block_identifier_int(
@@ -466,5 +390,33 @@ async def async_parse_block_identifier_int(
         last_block_num = last_block["number"]
         block_num = last_block_num + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)
+
+
+def copy_contract_function(
+    contract_function: TContractFn, *args: Any, **kwargs: Any
+) -> TContractFn:
+    """
+    Copy a contract function instance.
+    """
+    clone = copy.copy(contract_function)
+    clone.args = args or tuple()
+    clone.kwargs = kwargs or dict()
+
+    clone._set_function_info()
+    return clone
+
+
+def copy_contract_event(
+    contract_event: TContractEvent, *args: Any, **kwargs: Any
+) -> TContractEvent:
+    """
+    Copy a contract function instance.
+    """
+    clone = copy.copy(contract_event)
+    clone.args = args or tuple()
+    clone.kwargs = kwargs or dict()
+
+    clone._set_event_info()
+    return clone

web3/_utils/datatypes.py

@@ -14,10 +14,14 @@ from eth_utils.toolz import (
     concat,
 )
 
+from web3.exceptions import (
+    Web3AttributeError,
+)
+
 
 def verify_attr(class_name: str, key: str, namespace: Collection[str]) -> None:
     if key not in namespace:
-        raise AttributeError(
+        raise Web3AttributeError(
             f"Property {key} not found on {class_name} class. "
             f"`{class_name}.factory` only accepts keyword arguments which are "
             f"present on the {class_name} class"

web3/_utils/decorators.py

@@ -8,6 +8,10 @@ from typing import (
 )
 import warnings
 
+from web3.exceptions import (
+    Web3ValueError,
+)
+
 TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
@@ -24,7 +28,7 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
         thread_id = threading.get_ident()
         thread_local_args = (thread_id,) + arg_instances
         if thread_local_args in to_wrap.__already_called:  # type: ignore
-            raise ValueError(f"Recursively called {to_wrap} with {args!r}")
+            raise Web3ValueError(f"Recursively called {to_wrap} with {args!r}")
         to_wrap.__already_called[thread_local_args] = True  # type: ignore
         try:
             wrapped_val = to_wrap(*args)
@@ -50,6 +54,7 @@ def deprecated_for(replace_message: str) -> Callable[..., Any]:
             warnings.warn(
                 f"{to_wrap.__name__} is deprecated in favor of {replace_message}",
                 category=DeprecationWarning,
+                stacklevel=2,
             )
             return to_wrap(*args, **kwargs)
 

web3/_utils/empty.py

@@ -1,4 +1,4 @@
-from web3._utils.compat import (
+from typing import (
     Literal,
 )