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

web3/_utils/rpc_abi.py

@@ -123,18 +123,6 @@ class RPC:
     net_peerCount = RPCEndpoint("net_peerCount")
     net_version = RPCEndpoint("net_version")
 
-    # personal
-    personal_ecRecover = RPCEndpoint("personal_ecRecover")
-    personal_importRawKey = RPCEndpoint("personal_importRawKey")
-    personal_listAccounts = RPCEndpoint("personal_listAccounts")
-    personal_listWallets = RPCEndpoint("personal_listWallets")
-    personal_lockAccount = RPCEndpoint("personal_lockAccount")
-    personal_newAccount = RPCEndpoint("personal_newAccount")
-    personal_sendTransaction = RPCEndpoint("personal_sendTransaction")
-    personal_sign = RPCEndpoint("personal_sign")
-    personal_signTypedData = RPCEndpoint("personal_signTypedData")
-    personal_unlockAccount = RPCEndpoint("personal_unlockAccount")
-
     # testing
     testing_timeTravel = RPCEndpoint("testing_timeTravel")
 
@@ -211,12 +199,6 @@ RPC_ABIS: Dict[str, Union[Sequence[Any], Dict[str, str]]] = {
     "eth_signTypedData": ["address", None],
     "eth_submitHashrate": ["uint", "bytes32"],
     "eth_submitWork": ["bytes8", "bytes32", "bytes32"],
-    # personal
-    "personal_sendTransaction": TRANSACTION_PARAMS_ABIS,
-    "personal_lockAccount": ["address"],
-    "personal_unlockAccount": ["address", None, None],
-    "personal_sign": [None, "address", None],
-    "personal_signTypedData": [None, "address", None],
     "trace_call": TRANSACTION_PARAMS_ABIS,
     "trace_filter": TRACE_FILTER_PARAM_ABIS,
 }

web3/contract/async_contract.py

@@ -111,8 +111,8 @@ class AsyncContractEvent(BaseContractEvent):
     async def get_logs(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Awaitable[Iterable[EventData]]:
         """
@@ -135,7 +135,7 @@ class AsyncContractEvent(BaseContractEvent):
             from = max(mycontract.web3.eth.block_number - 10, 1)
             to = mycontract.web3.eth.block_number
 
-            events = mycontract.events.Transfer.getLogs(fromBlock=from, toBlock=to)
+            events = mycontract.events.Transfer.getLogs(from_block=from, to_block=to)
 
             for e in events:
                 print(e["args"]["from"],
@@ -165,10 +165,10 @@ class AsyncContractEvent(BaseContractEvent):
 
         :param argument_filters: Filter by argument values. Indexed arguments are
           filtered by the node while non-indexed arguments are filtered by the library.
-        :param fromBlock: block number or "latest", defaults to "latest"
-        :param toBlock: block number or "latest". Defaults to "latest"
+        :param from_block: block number or "latest", defaults to "latest"
+        :param to_block: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. Cannot be set at the
-          same time as fromBlock or toBlock
+          same time as ``from_block`` or ``to_block``
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
@@ -183,7 +183,7 @@ class AsyncContractEvent(BaseContractEvent):
                 )
 
         _filter_params = self._get_event_filter_params(
-            event_abi, argument_filters, fromBlock, toBlock, block_hash
+            event_abi, argument_filters, from_block, to_block, block_hash
         )
         # call JSON-RPC API
         logs = await self.w3.eth.get_logs(_filter_params)
@@ -204,8 +204,8 @@ class AsyncContractEvent(BaseContractEvent):
         self,
         *,  # PEP 3102
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
     ) -> AsyncLogFilter:
@@ -215,8 +215,8 @@ class AsyncContractEvent(BaseContractEvent):
         filter_builder = AsyncEventFilterBuilder(self._get_event_abi(), self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
-            fromBlock,
-            toBlock,
+            from_block,
+            to_block,
             address,
             topics,
             filter_builder,

web3/contract/base_contract.py

@@ -204,9 +204,9 @@ class BaseContractEvent:
         self,
         abi: ABIEvent,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
-        blockHash: Optional[HexBytes] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
+        block_hash: Optional[HexBytes] = None,
     ) -> FilterParams:
         if not self.address:
             raise Web3TypeError(
@@ -219,11 +219,12 @@ class BaseContractEvent:
 
         _filters = dict(**argument_filters)
 
-        blkhash_set = blockHash is not None
-        blknum_set = fromBlock is not None or toBlock is not None
+        blkhash_set = block_hash is not None
+        blknum_set = from_block is not None or to_block is not None
         if blkhash_set and blknum_set:
             raise Web3ValidationError(
-                "blockHash cannot be set at the same time as fromBlock or toBlock"
+                "`block_hash` cannot be set at the same time as "
+                "`from_block` or `to_block`"
             )
 
         # Construct JSON-RPC raw filter presentation based on human readable
@@ -233,13 +234,13 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=self.address,
         )
 
-        if blockHash is not None:
-            event_filter_params["blockHash"] = blockHash
+        if block_hash is not None:
+            event_filter_params["blockHash"] = block_hash
 
         return event_filter_params
 
@@ -319,15 +320,15 @@ class BaseContractEvent:
     def _set_up_filter_builder(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
         filter_builder: Union[EventFilterBuilder, AsyncEventFilterBuilder] = None,
     ) -> None:
-        if fromBlock is None:
+        if from_block is None:
             raise Web3TypeError(
-                "Missing mandatory keyword argument to create_filter: fromBlock"
+                "Missing mandatory keyword argument to create_filter: `from_block`"
             )
 
         if argument_filters is None:
@@ -344,8 +345,8 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=address,
             topics=topics,
         )
@@ -353,8 +354,8 @@ class BaseContractEvent:
         filter_builder.address = cast(
             ChecksumAddress, event_filter_params.get("address")
         )
-        filter_builder.fromBlock = event_filter_params.get("fromBlock")
-        filter_builder.toBlock = event_filter_params.get("toBlock")
+        filter_builder.from_block = event_filter_params.get("fromBlock")
+        filter_builder.to_block = event_filter_params.get("toBlock")
         match_any_vals = {
             arg: value
             for arg, value in _filters.items()

web3/contract/contract.py

@@ -110,8 +110,8 @@ class ContractEvent(BaseContractEvent):
     def get_logs(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Iterable[EventData]:
         """
@@ -131,10 +131,10 @@ class ContractEvent(BaseContractEvent):
 
         .. code-block:: python
 
-            from = max(mycontract.web3.eth.block_number - 10, 1)
-            to = mycontract.web3.eth.block_number
+            from = max(my_contract.web3.eth.block_number - 10, 1)
+            to = my_contract.web3.eth.block_number
 
-            events = mycontract.events.Transfer.get_logs(fromBlock=from, toBlock=to)
+            events = my_contract.events.Transfer.get_logs(from_block=from, to_block=to)
 
             for e in events:
                 print(e["args"]["from"],
@@ -164,10 +164,10 @@ class ContractEvent(BaseContractEvent):
 
         :param argument_filters: Filter by argument values. Indexed arguments are
           filtered by the node while non-indexed arguments are filtered by the library.
-        :param fromBlock: block number or "latest", defaults to "latest"
-        :param toBlock: block number or "latest". Defaults to "latest"
+        :param from_block: block number or "latest", defaults to "latest"
+        :param to_block: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. block_hash cannot be set at the
-          same time as fromBlock or toBlock
+          same time as ``from_block`` or ``to_block``
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
@@ -182,7 +182,7 @@ class ContractEvent(BaseContractEvent):
                 )
 
         _filter_params = self._get_event_filter_params(
-            event_abi, argument_filters, fromBlock, toBlock, block_hash
+            event_abi, argument_filters, from_block, to_block, block_hash
         )
         # call JSON-RPC API
         logs = self.w3.eth.get_logs(_filter_params)
@@ -205,8 +205,8 @@ class ContractEvent(BaseContractEvent):
         self,
         *,  # PEP 3102
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
     ) -> LogFilter:
@@ -216,8 +216,8 @@ class ContractEvent(BaseContractEvent):
         filter_builder = EventFilterBuilder(self._get_event_abi(), self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
-            fromBlock,
-            toBlock,
+            from_block,
+            to_block,
             address,
             topics,
             filter_builder,

web3/eth/async_eth.py

@@ -57,12 +57,13 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
+    MethodNotSupported,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
     Web3ValueError,
 )
 from web3.method import (
@@ -194,7 +195,7 @@ class AsyncEth(BaseEth):
         """
         try:
             return await self._max_priority_fee()
-        except (ValueError, MethodUnavailable):
+        except Web3RPCError:
             warnings.warn(
                 "There was an issue with the method eth_maxPriorityFeePerGas. "
                 "Calculating using eth_feeHistory.",
@@ -736,7 +737,7 @@ class AsyncEth(BaseEth):
         ] = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_subscribe is only supported with providers that support "
                 "persistent connections."
             )
@@ -753,7 +754,7 @@ class AsyncEth(BaseEth):
 
     async def unsubscribe(self, subscription_id: HexStr) -> bool:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_unsubscribe is only supported with providers that support "
                 "persistent connections."
             )

web3/eth/eth.py

@@ -57,12 +57,12 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
     Web3ValueError,
 )
 from web3.method import (
@@ -187,7 +187,7 @@ class Eth(BaseEth):
         """
         try:
             return self._max_priority_fee()
-        except (ValueError, MethodUnavailable):
+        except Web3RPCError:
             warnings.warn(
                 "There was an issue with the method eth_maxPriorityFeePerGas. "
                 "Calculating using eth_feeHistory.",

web3/exceptions.py

@@ -13,6 +13,7 @@ from eth_utils import (
 
 from web3.types import (
     BlockData,
+    RPCResponse,
 )
 
 
@@ -30,6 +31,8 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    user_message: Optional[str] = None
+
     def __init__(
         self,
         *args: Any,
@@ -69,6 +72,12 @@ class Web3TypeError(Web3Exception, TypeError):
     """
 
 
+class MethodNotSupported(Web3Exception):
+    """
+    Raised when a method is not supported by the provider.
+    """
+
+
 class BadFunctionCallOutput(Web3Exception):
     """
     We failed to decode ABI output.
@@ -77,7 +86,7 @@ class BadFunctionCallOutput(Web3Exception):
     """
 
 
-class BlockNumberOutofRange(Web3Exception):
+class BlockNumberOutOfRange(Web3Exception):
     """
     block_identifier passed does not match known block.
     """
@@ -216,25 +225,6 @@ class TimeExhausted(Web3Exception):
     """
 
 
-class TransactionNotFound(Web3Exception):
-    """
-    Raised when a tx hash used to lookup a tx in a jsonrpc call cannot be found.
-    """
-
-
-class TransactionIndexingInProgress(Web3Exception):
-    """
-    Raised when a transaction receipt is not yet available due to transaction indexing
-    still being in progress.
-    """
-
-
-class BlockNotFound(Web3Exception):
-    """
-    Raised when the block id used to lookup a block in a jsonrpc call cannot be found.
-    """
-
-
 class InfuraProjectIdNotFound(Web3Exception):
     """
     Raised when there is no Infura Project Id set.
@@ -317,7 +307,51 @@ class BadResponseFormat(Web3Exception):
     """
 
 
-class MethodUnavailable(Web3Exception):
+class Web3RPCError(Web3Exception):
+    """
+    Raised when a JSON-RPC response contains an error field.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        rpc_response: Optional[RPCResponse] = None,
+        user_message: Optional[str] = None,
+    ) -> None:
+        if user_message is None:
+            user_message = (
+                "An RPC error was returned by the node. Check the message provided in "
+                "the error and any available logs for more information."
+            )
+
+        super().__init__(
+            message,
+            user_message=user_message,
+        )
+        self.message = message
+        self.rpc_response = rpc_response
+
+
+class MethodUnavailable(Web3RPCError):
     """
     Raised when the method is not available on the node
     """
+
+
+class TransactionNotFound(Web3RPCError):
+    """
+    Raised when a tx hash used to look up a tx in a jsonrpc call cannot be found.
+    """
+
+
+class TransactionIndexingInProgress(Web3RPCError):
+    """
+    Raised when a transaction receipt is not yet available due to transaction indexing
+    still being in progress.
+    """
+
+
+class BlockNotFound(Web3RPCError):
+    """
+    Raised when the block id used to look up a block in a jsonrpc call cannot be found.
+    """

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