web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/geth.py

@@ -1,44 +1,20 @@
 from typing import (
-    Any,
     Awaitable,
     Callable,
-    Dict,
     List,
     Optional,
+    Protocol,
     Tuple,
 )
 
-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.decorators import (
-    deprecate_method,
-)
-from web3._utils.miner import (
-    make_dag,
-    set_etherbase,
-    set_extra,
-    set_gas_price,
-    start,
-    start_auto_dag,
-    stop,
-    stop_auto_dag,
-)
 from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.method import (
-    DeprecatedMethod,
     Method,
     default_root_munger,
 )
@@ -47,10 +23,8 @@ from web3.module import (
 )
 from web3.types import (
     EnodeURI,
-    GethWallet,
     NodeInfo,
     Peer,
-    TxParams,
     TxPoolContent,
     TxPoolInspect,
     TxPoolStatus,
@@ -67,90 +41,6 @@ class UnlockAccountWrapper(Protocol):
         pass
 
 
-GETH_PERSONAL_DEPRECATION_MSG = (
-    "Geth now uses `clef` for account and key management. This method will be removed "
-    "in web3.py `v7`."
-)
-
-
-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],
-    )
-    ec_recover = DeprecatedMethod(_ec_recover, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _import_raw_key: Method[Callable[[str, str], ChecksumAddress]] = Method(
-        RPC.personal_importRawKey,
-        mungers=[default_root_munger],
-    )
-    import_raw_key = DeprecatedMethod(
-        _import_raw_key, msg=GETH_PERSONAL_DEPRECATION_MSG
-    )
-
-    _list_accounts: Method[Callable[[], List[ChecksumAddress]]] = Method(
-        RPC.personal_listAccounts,
-        is_property=True,
-    )
-    list_accounts = DeprecatedMethod(_list_accounts, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _list_wallets: Method[Callable[[], List[GethWallet]]] = Method(
-        RPC.personal_listWallets,
-        is_property=True,
-    )
-    list_wallets = DeprecatedMethod(_list_wallets, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _send_transaction: Method[Callable[[TxParams, str], HexBytes]] = Method(
-        RPC.personal_sendTransaction,
-        mungers=[default_root_munger],
-    )
-    send_transaction = DeprecatedMethod(
-        _send_transaction, msg=GETH_PERSONAL_DEPRECATION_MSG
-    )
-
-    _sign: Method[Callable[[str, ChecksumAddress, Optional[str]], HexStr]] = Method(
-        RPC.personal_sign,
-        mungers=[default_root_munger],
-    )
-    sign = DeprecatedMethod(_sign, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _sign_typed_data: Method[
-        Callable[[Dict[str, Any], ChecksumAddress, str], HexStr]
-    ] = Method(
-        RPC.personal_signTypedData,
-        mungers=[default_root_munger],
-    )
-    sign_typed_data = DeprecatedMethod(
-        _sign_typed_data, msg=GETH_PERSONAL_DEPRECATION_MSG
-    )
-
-    _new_account: Method[Callable[[str], ChecksumAddress]] = Method(
-        RPC.personal_newAccount,
-        mungers=[default_root_munger],
-    )
-    new_account = DeprecatedMethod(_new_account, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _lock_account: Method[Callable[[ChecksumAddress], bool]] = Method(
-        RPC.personal_lockAccount,
-        mungers=[default_root_munger],
-    )
-    lock_account = DeprecatedMethod(_lock_account, msg=GETH_PERSONAL_DEPRECATION_MSG)
-
-    _unlock_account: Method[UnlockAccountWrapper] = Method(
-        RPC.personal_unlockAccount,
-        mungers=[default_root_munger],
-    )
-    unlock_account = DeprecatedMethod(
-        _unlock_account, msg=GETH_PERSONAL_DEPRECATION_MSG
-    )
-
-
 class GethTxPool(Module):
     """
     https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-txpool
@@ -243,23 +133,7 @@ class GethAdmin(Module):
     )
 
 
-class GethMiner(Module):
-    """
-    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-miner
-    """
-
-    make_dag = make_dag
-    set_extra = set_extra
-    set_etherbase = set_etherbase
-    set_gas_price = set_gas_price
-    start = start
-    stop = stop
-    start_auto_dag = start_auto_dag
-    stop_auto_dag = stop_auto_dag
-
-
 class Geth(Module):
-    personal: GethPersonal
     admin: GethAdmin
     txpool: GethTxPool
 
@@ -387,135 +261,8 @@ class AsyncGethAdmin(Module):
         return await self._stop_ws()
 
 
-class AsyncGethPersonal(Module):
-    """
-    https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-personal
-    """
-
-    is_async = True
-
-    # ec_recover
-
-    _ec_recover: Method[Callable[[str, HexStr], Awaitable[ChecksumAddress]]] = Method(
-        RPC.personal_ecRecover,
-        mungers=[default_root_munger],
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    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],
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    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,
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    async def list_accounts(self) -> List[ChecksumAddress]:
-        return await self._list_accounts()
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    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],
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    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],
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    async def sign(
-        self, message: str, account: ChecksumAddress, passphrase: str
-    ) -> HexStr:
-        return await self._sign(message, account, passphrase)
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    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],
-    )
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    async def new_account(self, passphrase: str) -> ChecksumAddress:
-        return await self._new_account(passphrase)
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    async def lock_account(self, account: ChecksumAddress) -> bool:
-        return await self._lock_account(account)
-
-    @deprecate_method(deprecation_msg=GETH_PERSONAL_DEPRECATION_MSG)
-    async def unlock_account(
-        self, account: ChecksumAddress, passphrase: str, duration: Optional[int] = None
-    ) -> bool:
-        return await self._unlock_account(account, passphrase, duration)
-
-
 class AsyncGeth(Module):
     is_async = True
 
-    personal: AsyncGethPersonal
     admin: AsyncGethAdmin
     txpool: AsyncGethTxPool

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,
@@ -86,22 +86,24 @@ from web3.eth import (
     Eth,
 )
 from web3.exceptions import (
-    Web3ValidationError,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
-    AsyncGethPersonal,
     AsyncGethTxPool,
     Geth,
     GethAdmin,
-    GethMiner,
-    GethPersonal,
     GethTxPool,
 )
 from web3.manager import (
     RequestManager as DefaultRequestManager,
 )
+from web3.middleware.base import MiddlewareOnion
+from web3.method import (
+    Method,
+)
 from web3.module import (
     Module,
 )
@@ -114,25 +116,25 @@ from web3.providers import (
     BaseProvider,
 )
 from web3.providers.eth_tester import (
+    AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
 from web3.providers.ipc import (
     IPCProvider,
 )
-from web3.providers.async_rpc import (
-    AsyncHTTPProvider,
-)
-from web3.providers.persistent import (
-    PersistentConnectionProvider,
+from web3.providers.persistent.utils import (
+    persistent_connection_provider_method,
 )
 from web3.providers.rpc import (
+    AsyncHTTPProvider,
     HTTPProvider,
 )
-from web3.providers.websocket import (
-    WebsocketProvider,
+from web3.providers import (
+    LegacyWebSocketProvider,
+    WebSocketProvider,
 )
-from web3.providers.websocket.websocket_connection import (
-    WebsocketConnection,
+from web3.providers.persistent import (
+    PersistentConnection,
 )
 from web3.testing import (
     Testing,
@@ -141,14 +143,13 @@ from web3.tracing import (
     Tracing,
 )
 from web3.types import (
-    AsyncMiddlewareOnion,
-    MiddlewareOnion,
     Wei,
 )
 
 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]]]:
@@ -159,7 +160,6 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
             AsyncGeth,
             {
                 "admin": AsyncGethAdmin,
-                "personal": AsyncGethPersonal,
                 "txpool": AsyncGethTxPool,
             },
         ),
@@ -174,8 +174,6 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
             Geth,
             {
                 "admin": GethAdmin,
-                "miner": GethMiner,
-                "personal": GethPersonal,
                 "txpool": GethTxPool,
             },
         ),
@@ -187,21 +185,19 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
 class BaseWeb3:
     _strict_bytes_type_checking = True
 
-    # Providers
-    HTTPProvider = HTTPProvider
-    IPCProvider = IPCProvider
-    EthereumTesterProvider = EthereumTesterProvider
-    WebsocketProvider = WebsocketProvider
-    AsyncHTTPProvider = AsyncHTTPProvider
-
     # Managers
     RequestManager = DefaultRequestManager
+    manager: DefaultRequestManager
 
     # mypy types
     eth: Union[Eth, AsyncEth]
     net: Union[Net, AsyncNet]
     geth: Union[Geth, AsyncGeth]
 
+    @property
+    def middleware_onion(self) -> MiddlewareOnion:
+        return cast(MiddlewareOnion, self.manager.middleware_onion)
+
     # Encoding and Decoding
     @staticmethod
     @wraps(to_bytes)
@@ -293,7 +289,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'), "
@@ -314,7 +310,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."
             )
@@ -346,29 +342,12 @@ 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."
-            )
-
-    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,
-            )
-            from web3.pm import PM  # noqa: F811
+    # -- APIs for high-level requests -- #
 
-            self.attach_modules({"_pm": PM})
+    def batch_requests(
+        self,
+    ) -> "RequestBatcher[Method[Callable[..., Any]]]":
+        return self.manager._batch_requests()
 
 
 class Web3(BaseWeb3):
@@ -377,17 +356,23 @@ class Web3(BaseWeb3):
     net: Net
     geth: Geth
 
+    # Providers
+    HTTPProvider = HTTPProvider
+    IPCProvider = IPCProvider
+    EthereumTesterProvider = EthereumTesterProvider
+    LegacyWebSocketProvider = LegacyWebSocketProvider
+
     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)
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         if modules is None:
@@ -403,10 +388,6 @@ class Web3(BaseWeb3):
     def is_connected(self, show_traceback: bool = False) -> bool:
         return self.provider.is_connected(show_traceback)
 
-    @property
-    def middleware_onion(self) -> MiddlewareOnion:
-        return cast(MiddlewareOnion, self.manager.middleware_onion)
-
     @property
     def provider(self) -> BaseProvider:
         return cast(BaseProvider, self.manager.provider)
@@ -444,25 +425,28 @@ class AsyncWeb3(BaseWeb3):
     net: AsyncNet
     geth: AsyncGeth
 
+    # Providers
+    AsyncHTTPProvider = AsyncHTTPProvider
+    WebSocketProvider = WebSocketProvider
+    AsyncEthereumTesterProvider = AsyncEthereumTesterProvider
+
     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,
-        **kwargs: Any,
     ) -> None:
-        self.manager = self.RequestManager(self, provider, middlewares)
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
-        if modules is None:
-            modules = get_async_default_modules()
-
-        self.attach_modules(modules)
+        self._modules = get_async_default_modules() if modules is None else modules
+        self._external_modules = None if external_modules is None else external_modules
 
+        self.attach_modules(self._modules)
         if external_modules is not None:
             self.attach_modules(external_modules)
 
@@ -471,10 +455,6 @@ class AsyncWeb3(BaseWeb3):
     async def is_connected(self, show_traceback: bool = False) -> bool:
         return await self.provider.is_connected(show_traceback)
 
-    @property
-    def middleware_onion(self) -> AsyncMiddlewareOnion:
-        return cast(AsyncMiddlewareOnion, self.manager.middleware_onion)
-
     @property
     def provider(self) -> AsyncBaseProvider:
         return cast(AsyncBaseProvider, self.manager.provider)
@@ -501,68 +481,35 @@ class AsyncWeb3(BaseWeb3):
             new_ens.w3 = self  # set self object reference for ``AsyncENS.w3``
         self._ens = new_ens
 
-    @staticmethod
-    def persistent_websocket(
-        provider: PersistentConnectionProvider,
-        middlewares: 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,
-    ) -> "_PersistentConnectionWeb3":
-        """
-        Establish a persistent connection via websockets to a websocket provider using
-        a ``PersistentConnectionProvider`` instance.
-        """
-        return _PersistentConnectionWeb3(
-            provider,
-            middlewares,
-            modules,
-            external_modules,
-            ens,
-        )
-
-
-class _PersistentConnectionWeb3(AsyncWeb3):
-    provider: PersistentConnectionProvider
-
-    # w3 = AsyncWeb3.persistent_websocket(provider)
-    # await w3.provider.connect()
-    def __init__(
-        self,
-        provider: PersistentConnectionProvider = None,
-        middlewares: 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:
-        if not isinstance(provider, PersistentConnectionProvider):
-            raise Web3ValidationError(
-                "Provider must inherit from PersistentConnectionProvider class."
-            )
-        AsyncWeb3.__init__(self, provider, middlewares, modules, external_modules, ens)
-        self.ws = WebsocketConnection(self)
+    # -- persistent connection methods -- #
 
-    # w3 = await AsyncWeb3.persistent_websocket(provider)
-    def __await__(
-        self,
-    ) -> Generator[Any, None, Self]:
+    @property
+    @persistent_connection_provider_method()
+    def socket(self) -> PersistentConnection:
+        return PersistentConnection(self)
+
+    # w3 = await AsyncWeb3(PersistentConnectionProvider(...))
+    @persistent_connection_provider_method(
+        "Provider must inherit from ``PersistentConnectionProvider`` class "
+        "when instantiating via ``await``."
+    )
+    def __await__(self) -> Generator[Any, None, Self]:
         async def __async_init__() -> Self:
-            if self.provider._ws is None:
-                await self.provider.connect()
-
+            await self.provider.connect()
             return self
 
         return __async_init__().__await__()
 
-    # async with w3.persistent_websocket(provider) as w3
+    # async with AsyncWeb3(PersistentConnectionProvider(...)) as w3:
+    @persistent_connection_provider_method(
+        message="Provider must inherit from ``PersistentConnectionProvider`` class "
+        "when instantiating via ``async with``."
+    )
     async def __aenter__(self) -> Self:
         await self.provider.connect()
         return self
 
+    @persistent_connection_provider_method()
     async def __aexit__(
         self,
         exc_type: Type[BaseException],
@@ -571,11 +518,17 @@ class _PersistentConnectionWeb3(AsyncWeb3):
     ) -> None:
         await self.provider.disconnect()
 
-    # async for w3 in w3.persistent_websocket(provider)
+    # async for w3 in AsyncWeb3(PersistentConnectionProvider(...)):
+    @persistent_connection_provider_method(
+        message="Provider must inherit from ``PersistentConnectionProvider`` class "
+        "when instantiating via ``async for``."
+    )
     async def __aiter__(self) -> AsyncIterator[Self]:
         provider = self.provider
         while True:
             await provider.connect()
             yield self
-            provider.logger.error("Connection interrupted, attempting to reconnect...")
+            cast("PersistentConnectionProvider", provider).logger.error(
+                "Connection interrupted, attempting to reconnect..."
+            )
             await provider.disconnect()