web3 7.4.0__py3-none-any.whl → 7.6.0__py3-none-any.whl

web3/contract/contract.py

@@ -1,4 +1,3 @@
-import copy
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -17,8 +16,10 @@ from eth_typing import (
     ChecksumAddress,
 )
 from eth_utils import (
+    abi_to_signature,
     combomethod,
     get_abi_input_names,
+    get_abi_input_types,
     get_all_function_abis,
 )
 from eth_utils.toolz import (
@@ -30,6 +31,9 @@ from hexbytes import (
 
 from web3._utils.abi import (
     fallback_func_abi_exists,
+    filter_by_types,
+    get_abi_element_signature,
+    get_name_from_abi_element_identifier,
     receive_func_abi_exists,
 )
 from web3._utils.abi_element_identifiers import (
@@ -40,6 +44,8 @@ from web3._utils.compat import (
     Self,
 )
 from web3._utils.contracts import (
+    copy_contract_event,
+    copy_contract_function,
     parse_block_identifier,
 )
 from web3._utils.datatypes import (
@@ -75,12 +81,16 @@ from web3.contract.utils import (
     build_transaction_for_function,
     call_contract_function,
     estimate_gas_for_function,
+    find_events_by_identifier,
     find_functions_by_identifier,
+    get_event_by_identifier,
     get_function_by_identifier,
     transact_with_contract_function,
 )
 from web3.exceptions import (
+    ABIEventNotFound,
     ABIFunctionNotFound,
+    NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
     Web3AttributeError,
@@ -94,6 +104,11 @@ from web3.types import (
     StateOverride,
     TxParams,
 )
+from web3.utils.abi import (
+    _get_any_abi_signature_with_name,
+    filter_abi_by_type,
+    get_abi_element,
+)
 
 if TYPE_CHECKING:
     from ens import ENS  # noqa: F401
@@ -104,6 +119,28 @@ class ContractEvent(BaseContractEvent):
     # mypy types
     w3: "Web3"
 
+    def __call__(self, *args: Any, **kwargs: Any) -> "ContractEvent":
+        event_abi = get_abi_element(
+            filter_abi_by_type("event", self.contract_abi),
+            self.name,
+            *args,
+            abi_codec=self.w3.codec,
+            **kwargs,
+        )
+        argument_types = get_abi_input_types(event_abi)
+        event_signature = str(
+            get_abi_element_signature(self.abi_element_identifier, argument_types)
+        )
+        contract_event = ContractEvent.factory(
+            event_signature,
+            w3=self.w3,
+            contract_abi=self.contract_abi,
+            address=self.address,
+            abi_element_identifier=event_signature,
+        )
+
+        return copy_contract_event(contract_event, *args, **kwargs)
+
     @combomethod
     def get_logs(
         self,
@@ -169,7 +206,6 @@ class ContractEvent(BaseContractEvent):
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
-
         # validate ``argument_filters`` if present
         if argument_filters is not None:
             event_arg_names = get_abi_input_names(event_abi)
@@ -211,7 +247,8 @@ class ContractEvent(BaseContractEvent):
         """
         Create filter object that tracks logs emitted by this contract event.
         """
-        filter_builder = EventFilterBuilder(self._get_event_abi(), self.w3.codec)
+        abi = self._get_event_abi()
+        filter_builder = EventFilterBuilder(abi, self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
             from_block,
@@ -221,23 +258,26 @@ class ContractEvent(BaseContractEvent):
             filter_builder,
         )
         log_filter = filter_builder.deploy(self.w3)
-        log_filter.log_entry_formatter = get_event_data(
-            self.w3.codec, self._get_event_abi()
-        )
+        log_filter.log_entry_formatter = get_event_data(self.w3.codec, abi)
         log_filter.builder = filter_builder
 
         return log_filter
 
     @combomethod
     def build_filter(self) -> EventFilterBuilder:
+        abi = self._get_event_abi()
         builder = EventFilterBuilder(
-            self._get_event_abi(),
+            abi,
             self.w3.codec,
-            formatter=get_event_data(self.w3.codec, self._get_event_abi()),
+            formatter=get_event_data(self.w3.codec, abi),
         )
         builder.address = self.address
         return builder
 
+    @classmethod
+    def factory(cls, class_name: str, **kwargs: Any) -> Self:
+        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
+
 
 class ContractEvents(BaseContractEvents):
     def __init__(
@@ -245,28 +285,81 @@ class ContractEvents(BaseContractEvents):
     ) -> None:
         super().__init__(abi, w3, ContractEvent, address)
 
+    def __getattr__(self, event_name: str) -> "ContractEvent":
+        if super().__getattribute__("abi") is None:
+            raise NoABIFound(
+                "There is no ABI found for this contract.",
+            )
+        if "_events" not in self.__dict__ or len(self._events) == 0:
+            raise NoABIEventsFound(
+                "The abi for this contract contains no event definitions. ",
+                "Are you sure you provided the correct contract abi?",
+            )
+        elif get_name_from_abi_element_identifier(event_name) not in [
+            get_name_from_abi_element_identifier(event["name"])
+            for event in self._events
+        ]:
+            raise ABIEventNotFound(
+                f"The event '{event_name}' was not found in this contract's abi. ",
+                "Are you sure you provided the correct contract abi?",
+            )
+        else:
+            event_abi = get_abi_element(self._events, event_name)
+            argument_types = get_abi_input_types(event_abi)
+            event_signature = str(get_abi_element_signature(event_name, argument_types))
+            return super().__getattribute__(event_signature)
+
+    def __getitem__(self, event_name: str) -> "ContractEvent":
+        return getattr(self, event_name)
+
+    def __iter__(self) -> Iterable["ContractEvent"]:
+        for event in self._events:
+            yield self[event["name"]]
+
 
 class ContractFunction(BaseContractFunction):
     # mypy types
     w3: "Web3"
 
     def __call__(self, *args: Any, **kwargs: Any) -> "ContractFunction":
-        clone = copy.copy(self)
-        if args is None:
-            clone.args = tuple()
-        else:
-            clone.args = args
+        element_name = self.abi_element_identifier
+        if element_name in ["fallback", "receive"] or len(args) + len(kwargs):
+            # Use only the name if a fallback, receive function
+            # or when args/kwargs are present to find the proper element
+            element_name = self.fn_name
+
+        function_abi = get_abi_element(
+            filter_by_types(
+                ["function", "constructor", "fallback", "receive"],
+                self.contract_abi,
+            ),
+            element_name,
+            *args,
+            abi_codec=self.w3.codec,
+            **kwargs,
+        )
 
-        if kwargs is None:
-            clone.kwargs = {}
-        else:
-            clone.kwargs = kwargs
-        clone._set_function_info()
-        return clone
+        argument_types = None
+        if function_abi["type"] not in ["fallback", "receive"]:
+            argument_types = get_abi_input_types(function_abi)
+
+        function_signature = str(
+            get_abi_element_signature(self.abi_element_identifier, argument_types)
+        )
+        contract_function = ContractFunction.factory(
+            function_signature,
+            w3=self.w3,
+            contract_abi=self.contract_abi,
+            address=self.address,
+            abi_element_identifier=function_signature,
+            decode_tuples=self.decode_tuples,
+        )
+
+        return copy_contract_function(contract_function, *args, **kwargs)
 
     @classmethod
     def factory(cls, class_name: str, **kwargs: Any) -> Self:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)(kwargs.get("abi"))
+        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
     def call(
         self,
@@ -306,11 +399,13 @@ class ContractFunction(BaseContractFunction):
 
         block_id = parse_block_identifier(self.w3, block_identifier)
 
+        abi_element_identifier = abi_to_signature(self.abi)
+
         return call_contract_function(
             self.w3,
             self.address,
             self._return_data_normalizers,
-            self.abi_element_identifier,
+            abi_element_identifier,
             call_transaction,
             block_id,
             self.contract_abi,
@@ -324,11 +419,12 @@ class ContractFunction(BaseContractFunction):
 
     def transact(self, transaction: Optional[TxParams] = None) -> HexBytes:
         setup_transaction = self._transact(transaction)
+        abi_element_identifier = abi_to_signature(self.abi)
 
         return transact_with_contract_function(
             self.address,
             self.w3,
-            self.abi_element_identifier,
+            abi_element_identifier,
             setup_transaction,
             self.contract_abi,
             self.abi,
@@ -343,10 +439,11 @@ class ContractFunction(BaseContractFunction):
         state_override: Optional[StateOverride] = None,
     ) -> int:
         setup_transaction = self._estimate_gas(transaction)
+        abi_element_identifier = abi_to_signature(self.abi)
         return estimate_gas_for_function(
             self.address,
             self.w3,
-            self.abi_element_identifier,
+            abi_element_identifier,
             setup_transaction,
             self.contract_abi,
             self.abi,
@@ -358,11 +455,12 @@ class ContractFunction(BaseContractFunction):
 
     def build_transaction(self, transaction: Optional[TxParams] = None) -> TxParams:
         built_transaction = self._build_transaction(transaction)
+        abi_element_identifier = abi_to_signature(self.abi)
 
         return build_transaction_for_function(
             self.address,
             self.w3,
-            self.abi_element_identifier,
+            abi_element_identifier,
             built_transaction,
             self.contract_abi,
             self.abi,
@@ -413,23 +511,45 @@ class ContractFunctions(BaseContractFunctions):
     ) -> None:
         super().__init__(abi, w3, ContractFunction, address, decode_tuples)
 
+    def __iter__(self) -> Iterable["ContractFunction"]:
+        if not hasattr(self, "_functions") or not self._functions:
+            return
+
+        for func in self._functions:
+            yield self[abi_to_signature(func)]
+
     def __getattr__(self, function_name: str) -> "ContractFunction":
-        if self.abi is None:
+        if super().__getattribute__("abi") is None:
             raise NoABIFound(
                 "There is no ABI found for this contract.",
             )
-        if "_functions" not in self.__dict__:
+        elif "_functions" not in self.__dict__ or len(self._functions) == 0:
             raise NoABIFunctionsFound(
                 "The abi for this contract contains no function definitions. ",
                 "Are you sure you provided the correct contract abi?",
             )
-        elif function_name not in self.__dict__["_functions"]:
+        elif get_name_from_abi_element_identifier(function_name) not in [
+            get_name_from_abi_element_identifier(function["name"])
+            for function in self._functions
+        ]:
             raise ABIFunctionNotFound(
-                f"The function '{function_name}' was not found in this contract's abi.",
-                " Are you sure you provided the correct contract abi?",
+                f"The function '{function_name}' was not found in this contract's "
+                "abi. Are you sure you provided the correct contract abi?",
             )
-        else:
-            return super().__getattribute__(function_name)
+
+        function_identifier = function_name
+
+        if "(" not in function_name:
+            function_identifier = _get_any_abi_signature_with_name(
+                function_name, self._functions
+            )
+
+        return super().__getattribute__(
+            function_identifier,
+        )
+
+    def __getitem__(self, function_name: str) -> "ContractFunction":
+        return getattr(self, function_name)
 
 
 class Contract(BaseContract):
@@ -503,6 +623,16 @@ class Contract(BaseContract):
                 normalizers=normalizers,
             ),
         )
+
+        if contract.abi:
+            for abi in contract.abi:
+                abi_name = abi.get("name")
+                if abi_name in ["abi", "address"]:
+                    raise Web3AttributeError(
+                        f"Contract contains a reserved word `{abi_name}` "
+                        f"and could not be instantiated."
+                    )
+
         contract.functions = ContractFunctions(
             contract.abi, contract.w3, decode_tuples=contract.decode_tuples
         )
@@ -562,6 +692,24 @@ class Contract(BaseContract):
     ) -> "ContractFunction":
         return get_function_by_identifier(fns, identifier)
 
+    @combomethod
+    def find_events_by_identifier(
+        cls,
+        contract_abi: ABI,
+        w3: "Web3",
+        address: ChecksumAddress,
+        callable_check: Callable[..., Any],
+    ) -> List["ContractEvent"]:
+        return find_events_by_identifier(
+            contract_abi, w3, address, callable_check, ContractEvent
+        )
+
+    @combomethod
+    def get_event_by_identifier(
+        cls, events: Sequence["ContractEvent"], identifier: str
+    ) -> "ContractEvent":
+        return get_event_by_identifier(events, identifier)
+
 
 class ContractCaller(BaseContractCaller):
     # mypy types
@@ -586,12 +734,12 @@ class ContractCaller(BaseContractCaller):
             self._functions = get_all_function_abis(self.abi)
 
             for func in self._functions:
+                abi_signature = abi_to_signature(func)
                 fn = ContractFunction.factory(
-                    func["name"],
+                    abi_signature,
                     w3=w3,
                     contract_abi=self.abi,
                     address=self.address,
-                    abi_element_identifier=func["name"],
                     decode_tuples=decode_tuples,
                 )
 
@@ -603,7 +751,7 @@ class ContractCaller(BaseContractCaller):
                     ccip_read_enabled=ccip_read_enabled,
                 )
 
-                setattr(self, func["name"], caller_method)
+                setattr(self, abi_signature, caller_method)
 
     def __call__(
         self,

web3/contract/utils.py

@@ -23,6 +23,7 @@ from eth_typing import (
     TypeStr,
 )
 from eth_utils.abi import (
+    abi_to_signature,
     filter_abi_by_type,
     get_abi_output_types,
 )
@@ -63,6 +64,7 @@ from web3.types import (
     BlockIdentifier,
     RPCEndpoint,
     StateOverride,
+    TContractEvent,
     TContractFn,
     TxParams,
 )
@@ -338,14 +340,17 @@ def find_functions_by_identifier(
     callable_check: Callable[..., Any],
     function_type: Type[TContractFn],
 ) -> List[TContractFn]:
+    """
+    Given a contract ABI, return a list of TContractFunction instances.
+    """
     fns_abi = filter_abi_by_type("function", contract_abi)
     return [
         function_type.factory(
-            fn_abi["name"],
+            abi_to_signature(fn_abi),
             w3=w3,
             contract_abi=contract_abi,
             address=address,
-            abi_element_identifier=fn_abi["name"],
+            abi_element_identifier=abi_to_signature(fn_abi),
             abi=fn_abi,
         )
         for fn_abi in fns_abi
@@ -356,6 +361,10 @@ def find_functions_by_identifier(
 def get_function_by_identifier(
     fns: Sequence[TContractFn], identifier: str
 ) -> TContractFn:
+    """
+    Check that the provided list of TContractFunction instances contains one element and
+    return it.
+    """
     if len(fns) > 1:
         raise Web3ValueError(
             f"Found multiple functions with matching {identifier}. " f"Found: {fns!r}"
@@ -365,6 +374,46 @@ def get_function_by_identifier(
     return fns[0]
 
 
+def find_events_by_identifier(
+    contract_abi: ABI,
+    w3: Union["Web3", "AsyncWeb3"],
+    address: ChecksumAddress,
+    callable_check: Callable[..., Any],
+    event_type: Type[TContractEvent],
+) -> List[TContractEvent]:
+    """
+    Given a contract ABI, return a list of TContractEvent instances.
+    """
+    event_abis = filter_abi_by_type("event", contract_abi)
+    return [
+        event_type.factory(
+            event_abi["name"],
+            w3=w3,
+            contract_abi=contract_abi,
+            address=address,
+            abi=event_abi,
+        )
+        for event_abi in event_abis
+        if callable_check(event_abi)
+    ]
+
+
+def get_event_by_identifier(
+    events: Sequence[TContractEvent], identifier: str
+) -> TContractEvent:
+    """
+    Check that the provided list of TContractEvent instances contains one element and
+    return it.
+    """
+    if len(events) > 1:
+        raise Web3ValueError(
+            f"Found multiple events with matching {identifier}. " f"Found: {events!r}"
+        )
+    elif len(events) == 0:
+        raise Web3ValueError(f"Could not find any event with matching {identifier}")
+    return events[0]
+
+
 # --- async --- #
 
 

web3/eth/async_eth.py

@@ -127,6 +127,17 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
+    # eth_blobBaseFee
+
+    _eth_blobBaseFee: Method[Callable[[], Awaitable[Wei]]] = Method(
+        RPC.eth_blobBaseFee,
+        is_property=True,
+    )
+
+    @property
+    async def blob_base_fee(self) -> Wei:
+        return await self._eth_blobBaseFee()
+
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], Awaitable[BlockNumber]]] = Method(

web3/eth/eth.py

@@ -119,6 +119,17 @@ class Eth(BaseEth):
     def accounts(self) -> Tuple[ChecksumAddress]:
         return self._accounts()
 
+    # eth_blobBaseFee
+
+    _eth_blobBaseFee: Method[Callable[[], Wei]] = Method(
+        RPC.eth_blobBaseFee,
+        is_property=True,
+    )
+
+    @property
+    def blob_base_fee(self) -> Wei:
+        return self._eth_blobBaseFee()
+
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], BlockNumber]] = Method(

web3/geth.py

@@ -5,6 +5,7 @@ from typing import (
     Optional,
     Protocol,
     Tuple,
+    Union,
 )
 
 from eth_typing.evm import (
@@ -22,12 +23,19 @@ from web3.module import (
     Module,
 )
 from web3.types import (
+    CallTrace,
+    DiffModeTrace,
     EnodeURI,
+    FourByteTrace,
     NodeInfo,
+    OpcodeTrace,
     Peer,
+    PrestateTrace,
+    TraceConfig,
     TxPoolContent,
     TxPoolInspect,
     TxPoolStatus,
+    _Hash32,
 )
 
 
@@ -133,9 +141,33 @@ class GethAdmin(Module):
     )
 
 
+class GethDebug(Module):
+    """
+    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-debug
+    """
+
+    def trace_transaction_munger(
+        self,
+        transaction_hash: _Hash32,
+        trace_config: Optional[TraceConfig] = None,
+    ) -> Tuple[_Hash32, TraceConfig]:
+        return (transaction_hash, trace_config)
+
+    trace_transaction: Method[
+        Callable[
+            ...,
+            Union[CallTrace, PrestateTrace, OpcodeTrace, DiffModeTrace, FourByteTrace],
+        ]
+    ] = Method(
+        RPC.debug_traceTransaction,
+        mungers=[trace_transaction_munger],
+    )
+
+
 class Geth(Module):
     admin: GethAdmin
     txpool: GethTxPool
+    debug: GethDebug
 
 
 # --- async --- #
@@ -261,8 +293,35 @@ class AsyncGethAdmin(Module):
         return await self._stop_ws()
 
 
+class AsyncGethDebug(Module):
+    """
+    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-debug
+    """
+
+    is_async = True
+
+    _trace_transaction: Method[
+        Callable[
+            ...,
+            Awaitable[
+                Union[
+                    CallTrace, PrestateTrace, OpcodeTrace, FourByteTrace, DiffModeTrace
+                ]
+            ],
+        ]
+    ] = Method(RPC.debug_traceTransaction)
+
+    async def trace_transaction(
+        self,
+        transaction_hash: _Hash32,
+        trace_config: Optional[TraceConfig] = None,
+    ) -> Union[CallTrace, PrestateTrace, OpcodeTrace, FourByteTrace, DiffModeTrace]:
+        return await self._trace_transaction(transaction_hash, trace_config)
+
+
 class AsyncGeth(Module):
     is_async = True
 
     admin: AsyncGethAdmin
     txpool: AsyncGethTxPool
+    debug: AsyncGethDebug

web3/main.py

@@ -93,9 +93,11 @@ from web3.exceptions import (
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
+    AsyncGethDebug,
     AsyncGethTxPool,
     Geth,
     GethAdmin,
+    GethDebug,
     GethTxPool,
 )
 from web3.manager import (
@@ -162,6 +164,7 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
             {
                 "admin": AsyncGethAdmin,
                 "txpool": AsyncGethTxPool,
+                "debug": AsyncGethDebug,
             },
         ),
     }
@@ -176,6 +179,7 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
             {
                 "admin": GethAdmin,
                 "txpool": GethTxPool,
+                "debug": GethDebug,
             },
         ),
         "tracing": Tracing,

web3/manager.py

@@ -39,6 +39,7 @@ from web3.exceptions import (
     ProviderConnectionError,
     RequestTimedOut,
     TaskNotRunning,
+    TransactionNotFound,
     Web3RPCError,
     Web3TypeError,
 )
@@ -150,6 +151,7 @@ def _validate_response(
     error_formatters: Optional[Callable[..., Any]],
     is_subscription_response: bool = False,
     logger: Optional[logging.Logger] = None,
+    params: Optional[Any] = None,
 ) -> None:
     if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
         _raise_bad_response_format(
@@ -210,6 +212,13 @@ def _validate_response(
             _raise_bad_response_format(
                 response, 'error["message"] is required and must be a string value.'
             )
+        elif error_message == "transaction not found":
+            transaction_hash = params[0]
+            web3_rpc_error = TransactionNotFound(
+                repr(error),
+                rpc_response=response,
+                user_message=(f"Transaction with hash {transaction_hash!r} not found."),
+            )
 
         # errors must include an integer code
         code = error.get("code")
@@ -360,6 +369,7 @@ class RequestManager:
             error_formatters,
             is_subscription_response=is_subscription_response,
             logger=self.logger,
+            params=params,
         )
 
         # format results