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

web3/geth.py

@@ -1,26 +1,17 @@
 from typing import (
-    Any,
     Awaitable,
     Callable,
-    Dict,
     List,
     Optional,
+    Protocol,
     Tuple,
+    Union,
 )
 
-from eth_typing.encoding import (
-    HexStr,
-)
 from eth_typing.evm import (
     ChecksumAddress,
 )
-from hexbytes.main import (
-    HexBytes,
-)
 
-from web3._utils.compat import (
-    Protocol,
-)
 from web3._utils.rpc_abi import (
     RPC,
 )
@@ -32,14 +23,19 @@ from web3.module import (
     Module,
 )
 from web3.types import (
+    CallTrace,
+    DiffModeTrace,
     EnodeURI,
-    GethWallet,
+    FourByteTrace,
     NodeInfo,
+    OpcodeTrace,
     Peer,
-    TxParams,
+    PrestateTrace,
+    TraceConfig,
     TxPoolContent,
     TxPoolInspect,
     TxPoolStatus,
+    _Hash32,
 )
 
 
@@ -53,66 +49,6 @@ class UnlockAccountWrapper(Protocol):
         pass
 
 
-class GethPersonal(Module):
-    """
-    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-personal
-    """
-
-    is_async = False
-
-    ec_recover: Method[Callable[[str, HexStr], ChecksumAddress]] = Method(
-        RPC.personal_ecRecover,
-        mungers=[default_root_munger],
-    )
-
-    import_raw_key: Method[Callable[[str, str], ChecksumAddress]] = Method(
-        RPC.personal_importRawKey,
-        mungers=[default_root_munger],
-    )
-
-    list_accounts: Method[Callable[[], List[ChecksumAddress]]] = Method(
-        RPC.personal_listAccounts,
-        is_property=True,
-    )
-
-    list_wallets: Method[Callable[[], List[GethWallet]]] = Method(
-        RPC.personal_listWallets,
-        is_property=True,
-    )
-
-    send_transaction: Method[Callable[[TxParams, str], HexBytes]] = Method(
-        RPC.personal_sendTransaction,
-        mungers=[default_root_munger],
-    )
-
-    sign: Method[Callable[[str, ChecksumAddress, Optional[str]], HexStr]] = Method(
-        RPC.personal_sign,
-        mungers=[default_root_munger],
-    )
-
-    sign_typed_data: Method[
-        Callable[[Dict[str, Any], ChecksumAddress, str], HexStr]
-    ] = Method(
-        RPC.personal_signTypedData,
-        mungers=[default_root_munger],
-    )
-
-    new_account: Method[Callable[[str], ChecksumAddress]] = Method(
-        RPC.personal_newAccount,
-        mungers=[default_root_munger],
-    )
-
-    lock_account: Method[Callable[[ChecksumAddress], bool]] = Method(
-        RPC.personal_lockAccount,
-        mungers=[default_root_munger],
-    )
-
-    unlock_account: Method[UnlockAccountWrapper] = Method(
-        RPC.personal_unlockAccount,
-        mungers=[default_root_munger],
-    )
-
-
 class GethTxPool(Module):
     """
     https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-txpool
@@ -205,10 +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):
-    personal: GethPersonal
     admin: GethAdmin
     txpool: GethTxPool
+    debug: GethDebug
 
 
 # --- async --- #
@@ -334,125 +293,35 @@ class AsyncGethAdmin(Module):
         return await self._stop_ws()
 
 
-class AsyncGethPersonal(Module):
+class AsyncGethDebug(Module):
     """
-    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-personal
+    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-debug
     """
 
     is_async = True
 
-    # ec_recover
-
-    _ec_recover: Method[Callable[[str, HexStr], Awaitable[ChecksumAddress]]] = Method(
-        RPC.personal_ecRecover,
-        mungers=[default_root_munger],
-    )
-
-    async def ec_recover(self, message: str, signature: HexStr) -> ChecksumAddress:
-        return await self._ec_recover(message, signature)
-
-    # import_raw_key
-
-    _import_raw_key: Method[Callable[[str, str], Awaitable[ChecksumAddress]]] = Method(
-        RPC.personal_importRawKey,
-        mungers=[default_root_munger],
-    )
-
-    async def import_raw_key(
-        self, private_key: str, passphrase: str
-    ) -> ChecksumAddress:
-        return await self._import_raw_key(private_key, passphrase)
-
-    # list_accounts and list_wallets
-
-    _list_accounts: Method[Callable[[], Awaitable[List[ChecksumAddress]]]] = Method(
-        RPC.personal_listAccounts,
-        is_property=True,
-    )
-
-    _list_wallets: Method[Callable[[], Awaitable[List[GethWallet]]]] = Method(
-        RPC.personal_listWallets,
-        is_property=True,
-    )
-
-    async def list_accounts(self) -> List[ChecksumAddress]:
-        return await self._list_accounts()
-
-    async def list_wallets(self) -> List[GethWallet]:
-        return await self._list_wallets()
-
-    # send_transaction
-
-    _send_transaction: Method[Callable[[TxParams, str], Awaitable[HexBytes]]] = Method(
-        RPC.personal_sendTransaction,
-        mungers=[default_root_munger],
-    )
-
-    async def send_transaction(
-        self, transaction: TxParams, passphrase: str
-    ) -> HexBytes:
-        return await self._send_transaction(transaction, passphrase)
-
-    # sign and sign_typed_data
-
-    _sign: Method[
-        Callable[[str, ChecksumAddress, Optional[str]], Awaitable[HexStr]]
-    ] = Method(
-        RPC.personal_sign,
-        mungers=[default_root_munger],
-    )
-
-    _sign_typed_data: Method[
-        Callable[[Dict[str, Any], ChecksumAddress, str], Awaitable[HexStr]]
-    ] = Method(
-        RPC.personal_signTypedData,
-        mungers=[default_root_munger],
-    )
-
-    async def sign(
-        self, message: str, account: ChecksumAddress, passphrase: str
-    ) -> HexStr:
-        return await self._sign(message, account, passphrase)
-
-    async def sign_typed_data(
-        self, message: Dict[str, Any], account: ChecksumAddress, passphrase: str
-    ) -> HexStr:
-        return await self._sign_typed_data(message, account, passphrase)
-
-    # new_account, lock_account, and unlock_account
-
-    _new_account: Method[Callable[[str], Awaitable[ChecksumAddress]]] = Method(
-        RPC.personal_newAccount,
-        mungers=[default_root_munger],
-    )
-
-    _lock_account: Method[Callable[[ChecksumAddress], Awaitable[bool]]] = Method(
-        RPC.personal_lockAccount,
-        mungers=[default_root_munger],
-    )
-
-    _unlock_account: Method[
-        Callable[[ChecksumAddress, str, Optional[int]], Awaitable[bool]]
-    ] = Method(
-        RPC.personal_unlockAccount,
-        mungers=[default_root_munger],
-    )
-
-    async def new_account(self, passphrase: str) -> ChecksumAddress:
-        return await self._new_account(passphrase)
-
-    async def lock_account(self, account: ChecksumAddress) -> bool:
-        return await self._lock_account(account)
-
-    async def unlock_account(
-        self, account: ChecksumAddress, passphrase: str, duration: Optional[int] = None
-    ) -> bool:
-        return await self._unlock_account(account, passphrase, duration)
+    _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
 
-    personal: AsyncGethPersonal
     admin: AsyncGethAdmin
     txpool: AsyncGethTxPool
+    debug: AsyncGethDebug

web3/main.py

@@ -1,5 +1,4 @@
 import decimal
-import warnings
 from types import (
     TracebackType,
 )
@@ -35,6 +34,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterator,
+    Callable,
     Dict,
     Generator,
     List,
@@ -85,20 +85,28 @@ from web3.eth import (
     AsyncEth,
     Eth,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValidationError,
+    Web3ValueError,
+)
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
-    AsyncGethPersonal,
+    AsyncGethDebug,
     AsyncGethTxPool,
     Geth,
     GethAdmin,
-    GethPersonal,
+    GethDebug,
     GethTxPool,
 )
 from web3.manager import (
     RequestManager as DefaultRequestManager,
 )
 from web3.middleware.base import MiddlewareOnion
+from web3.method import (
+    Method,
+)
 from web3.module import (
     Module,
 )
@@ -140,10 +148,14 @@ from web3.tracing import (
 from web3.types import (
     Wei,
 )
+from web3.providers.persistent.subscription_manager import (
+    SubscriptionManager,
+)
 
 if TYPE_CHECKING:
-    from web3.pm import PM  # noqa: F401
+    from web3._utils.batching import RequestBatcher  # noqa: F401
     from web3._utils.empty import Empty  # noqa: F401
+    from web3.providers.persistent import PersistentConnectionProvider  # noqa: F401
 
 
 def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
@@ -154,8 +166,8 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
             AsyncGeth,
             {
                 "admin": AsyncGethAdmin,
-                "personal": AsyncGethPersonal,
                 "txpool": AsyncGethTxPool,
+                "debug": AsyncGethDebug,
             },
         ),
     }
@@ -169,8 +181,8 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
             Geth,
             {
                 "admin": GethAdmin,
-                "personal": GethPersonal,
                 "txpool": GethTxPool,
+                "debug": GethDebug,
             },
         ),
         "tracing": Tracing,
@@ -285,7 +297,7 @@ class BaseWeb3:
             input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
             return eth_utils_keccak(input_bytes)
 
-        raise TypeError(
+        raise Web3TypeError(
             f"You called keccak with first arg {primitive!r} and keywords "
             f"{{'text': {text!r}, 'hexstr': {hexstr!r}}}. You must call it with "
             "one of these approaches: keccak(text='txt'), keccak(hexstr='0x747874'), "
@@ -306,7 +318,7 @@ class BaseWeb3:
         and list of corresponding values  -- `[20, [-1, 5, 0], True]`
         """
         if len(abi_types) != len(values):
-            raise ValueError(
+            raise Web3ValueError(
                 "Length mismatch between provided abi types and values.  Got "
                 f"{len(abi_types)} types and {len(values)} values."
             )
@@ -338,29 +350,30 @@ class BaseWeb3:
     def is_encodable(self, _type: TypeStr, value: Any) -> bool:
         return self.codec.is_encodable(_type, value)
 
-    @property
-    def pm(self) -> "PM":
-        if hasattr(self, "_pm"):
-            # ignored b/c property is dynamically set
-            # via enable_unstable_package_management_api
-            return self._pm
-        else:
-            raise AttributeError(
-                "The Package Management feature is disabled by default until "
-                "its API stabilizes. To use these features, please enable them by "
-                "running `w3.enable_unstable_package_management_api()` and try again."
-            )
+    # -- APIs for high-level requests -- #
 
-    def enable_unstable_package_management_api(self) -> None:
-        if not hasattr(self, "_pm"):
-            warnings.warn(
-                "The ``ethPM`` module is no longer being maintained and will be "
-                "deprecated with ``web3.py`` version 7",
-                UserWarning,
+    def batch_requests(
+        self,
+    ) -> "RequestBatcher[Method[Callable[..., Any]]]":
+        return self.manager._batch_requests()
+
+
+def _validate_provider(
+    w3: Union["Web3", "AsyncWeb3"],
+    provider: Optional[Union[BaseProvider, AsyncBaseProvider]],
+) -> None:
+    if provider is not None:
+        if isinstance(w3, AsyncWeb3) and not isinstance(provider, AsyncBaseProvider):
+            raise Web3ValidationError(
+                "Provider must be an instance of `AsyncBaseProvider` for "
+                f"`AsyncWeb3`, got {type(provider)}."
             )
-            from web3.pm import PM  # noqa: F811
 
-            self.attach_modules({"_pm": PM})
+        if isinstance(w3, Web3) and not isinstance(provider, BaseProvider):
+            raise Web3ValidationError(
+                "Provider must be an instance of `BaseProvider` for `Web3`, "
+                f"got {type(provider)}."
+            )
 
 
 class Web3(BaseWeb3):
@@ -378,14 +391,16 @@ class Web3(BaseWeb3):
     def __init__(
         self,
         provider: Optional[BaseProvider] = None,
-        middlewares: Optional[Sequence[Any]] = None,
+        middleware: Optional[Sequence[Any]] = None,
         modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
         external_modules: Optional[
             Dict[str, Union[Type[Module], Sequence[Any]]]
         ] = None,
         ens: Union[ENS, "Empty"] = empty,
     ) -> None:
-        self.manager = self.RequestManager(self, provider, middlewares)
+        _validate_provider(self, provider)
+
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         if modules is None:
@@ -446,14 +461,16 @@ class AsyncWeb3(BaseWeb3):
     def __init__(
         self,
         provider: Optional[AsyncBaseProvider] = None,
-        middlewares: Optional[Sequence[Any]] = None,
+        middleware: Optional[Sequence[Any]] = None,
         modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
         external_modules: Optional[
             Dict[str, Union[Type[Module], Sequence[Any]]]
         ] = None,
         ens: Union[AsyncENS, "Empty"] = empty,
     ) -> None:
-        self.manager = self.RequestManager(self, provider, middlewares)
+        _validate_provider(self, provider)
+
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         self._modules = get_async_default_modules() if modules is None else modules
@@ -494,12 +511,27 @@ class AsyncWeb3(BaseWeb3):
             new_ens.w3 = self  # set self object reference for ``AsyncENS.w3``
         self._ens = new_ens
 
-        # -- persistent connection methods -- #
+    # -- persistent connection settings -- #
+
+    _subscription_manager: Optional[SubscriptionManager] = None
+    _persistent_connection: Optional["PersistentConnection"] = None
+
+    @property
+    @persistent_connection_provider_method()
+    def subscription_manager(self) -> SubscriptionManager:
+        """
+        Access the subscription manager for the current PersistentConnectionProvider.
+        """
+        if not self._subscription_manager:
+            self._subscription_manager = SubscriptionManager(self)
+        return self._subscription_manager
 
     @property
     @persistent_connection_provider_method()
     def socket(self) -> PersistentConnection:
-        return PersistentConnection(self)
+        if self._persistent_connection is None:
+            self._persistent_connection = PersistentConnection(self)
+        return self._persistent_connection
 
     # w3 = await AsyncWeb3(PersistentConnectionProvider(...))
     @persistent_connection_provider_method(
@@ -508,7 +540,10 @@ class AsyncWeb3(BaseWeb3):
     )
     def __await__(self) -> Generator[Any, None, Self]:
         async def __async_init__() -> Self:
-            await self.provider.connect()
+            provider = cast("PersistentConnectionProvider", self.provider)
+            await provider.connect()
+            # set signal handlers since not within a context manager
+            provider._set_signal_handlers()
             return self
 
         return __async_init__().__await__()
@@ -537,12 +572,11 @@ class AsyncWeb3(BaseWeb3):
         "when instantiating via ``async for``."
     )
     async def __aiter__(self) -> AsyncIterator[Self]:
-        if not await self.provider.is_connected():
-            await self.provider.connect()
-
+        provider = self.provider
         while True:
-            try:
-                yield self
-            except Exception:
-                # provider should handle connection / reconnection
-                continue
+            await provider.connect()
+            yield self
+            cast("PersistentConnectionProvider", provider).logger.error(
+                "Connection interrupted, attempting to reconnect..."
+            )
+            await provider.disconnect()