web3 7.0.0b4__py3-none-any.whl → 7.0.0b6__py3-none-any.whl

web3/geth.py

@@ -1,23 +1,15 @@
 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.rpc_abi import (
     RPC,
@@ -31,10 +23,8 @@ from web3.module import (
 )
 from web3.types import (
     EnodeURI,
-    GethWallet,
     NodeInfo,
     Peer,
-    TxParams,
     TxPoolContent,
     TxPoolInspect,
     TxPoolStatus,
@@ -51,66 +41,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
@@ -204,7 +134,6 @@ class GethAdmin(Module):
 
 
 class Geth(Module):
-    personal: GethPersonal
     admin: GethAdmin
     txpool: GethTxPool
 
@@ -332,125 +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],
-    )
-
-    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)
-
-
 class AsyncGeth(Module):
     is_async = True
 
-    personal: AsyncGethPersonal
     admin: AsyncGethAdmin
     txpool: AsyncGethTxPool

web3/main.py

@@ -34,6 +34,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterator,
+    Callable,
     Dict,
     Generator,
     List,
@@ -91,17 +92,18 @@ from web3.exceptions import (
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
-    AsyncGethPersonal,
     AsyncGethTxPool,
     Geth,
     GethAdmin,
-    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,
 )
@@ -145,7 +147,9 @@ from web3.types import (
 )
 
 if TYPE_CHECKING:
+    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]]]:
@@ -156,7 +160,6 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
             AsyncGeth,
             {
                 "admin": AsyncGethAdmin,
-                "personal": AsyncGethPersonal,
                 "txpool": AsyncGethTxPool,
             },
         ),
@@ -171,7 +174,6 @@ def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
             Geth,
             {
                 "admin": GethAdmin,
-                "personal": GethPersonal,
                 "txpool": GethTxPool,
             },
         ),
@@ -340,6 +342,13 @@ class BaseWeb3:
     def is_encodable(self, _type: TypeStr, value: Any) -> bool:
         return self.codec.is_encodable(_type, value)
 
+    # -- APIs for high-level requests -- #
+
+    def batch_requests(
+        self,
+    ) -> "RequestBatcher[Method[Callable[..., Any]]]":
+        return self.manager._batch_requests()
+
 
 class Web3(BaseWeb3):
     # mypy types
@@ -472,7 +481,7 @@ class AsyncWeb3(BaseWeb3):
             new_ens.w3 = self  # set self object reference for ``AsyncENS.w3``
         self._ens = new_ens
 
-        # -- persistent connection methods -- #
+    # -- persistent connection methods -- #
 
     @property
     @persistent_connection_provider_method()
@@ -515,12 +524,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()