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

web3/_utils/rpc_abi.py

@@ -52,7 +52,6 @@ class RPC:
     eth_call = RPCEndpoint("eth_call")
     eth_createAccessList = RPCEndpoint("eth_createAccessList")
     eth_chainId = RPCEndpoint("eth_chainId")
-    eth_coinbase = RPCEndpoint("eth_coinbase")
     eth_estimateGas = RPCEndpoint("eth_estimateGas")
     eth_feeHistory = RPCEndpoint("eth_feeHistory")
     eth_maxPriorityFeePerGas = RPCEndpoint("eth_maxPriorityFeePerGas")
@@ -94,8 +93,6 @@ class RPC:
     eth_getUncleCountByBlockHash = RPCEndpoint("eth_getUncleCountByBlockHash")
     eth_getUncleCountByBlockNumber = RPCEndpoint("eth_getUncleCountByBlockNumber")
     eth_getWork = RPCEndpoint("eth_getWork")
-    eth_hashrate = RPCEndpoint("eth_hashrate")
-    eth_mining = RPCEndpoint("eth_mining")
     eth_newBlockFilter = RPCEndpoint("eth_newBlockFilter")
     eth_newFilter = RPCEndpoint("eth_newFilter")
     eth_newPendingTransactionFilter = RPCEndpoint("eth_newPendingTransactionFilter")

web3/beacon/__init__.py

@@ -1,2 +1,7 @@
 from .async_beacon import AsyncBeacon
 from .beacon import Beacon
+
+__all__ = [
+    "AsyncBeacon",
+    "Beacon",
+]

web3/beacon/async_beacon.py

@@ -8,9 +8,8 @@ from eth_typing import (
     HexStr,
 )
 
-from web3._utils.request import (
-    async_get_response_from_get_request,
-    async_json_make_get_request,
+from web3._utils.http_session_manager import (
+    HTTPSessionManager,
 )
 from web3.beacon.api_endpoints import (
     GET_ATTESTATIONS,
@@ -63,10 +62,13 @@ class AsyncBeacon:
     ) -> None:
         self.base_url = base_url
         self.request_timeout = request_timeout
+        self._request_session_manager = HTTPSessionManager()
 
     async def _async_make_get_request(self, endpoint_uri: str) -> Dict[str, Any]:
         uri = URI(self.base_url + endpoint_uri)
-        return await async_json_make_get_request(uri, timeout=self.request_timeout)
+        return await self._request_session_manager.async_json_make_get_request(
+            uri, timeout=self.request_timeout
+        )
 
     # [ BEACON endpoints ]
 
@@ -208,7 +210,9 @@ class AsyncBeacon:
 
     async def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
-        response = await async_get_response_from_get_request(url)
+        response = (
+            await self._request_session_manager.async_get_response_from_get_request(url)
+        )
         return response.status
 
     async def get_version(self) -> Dict[str, Any]:

web3/beacon/beacon.py

@@ -8,9 +8,8 @@ from eth_typing import (
     HexStr,
 )
 
-from web3._utils.request import (
-    get_response_from_get_request,
-    json_make_get_request,
+from web3._utils.http_session_manager import (
+    HTTPSessionManager,
 )
 from web3.beacon.api_endpoints import (
     GET_ATTESTATIONS,
@@ -61,10 +60,13 @@ class Beacon:
     ) -> None:
         self.base_url = base_url
         self.request_timeout = request_timeout
+        self._request_session_manager = HTTPSessionManager()
 
     def _make_get_request(self, endpoint_url: str) -> Dict[str, Any]:
         uri = URI(self.base_url + endpoint_url)
-        return json_make_get_request(uri, timeout=self.request_timeout)
+        return self._request_session_manager.json_make_get_request(
+            uri, timeout=self.request_timeout
+        )
 
     # [ BEACON endpoints ]
 
@@ -196,7 +198,7 @@ class Beacon:
 
     def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
-        response = get_response_from_get_request(url)
+        response = self._request_session_manager.get_response_from_get_request(url)
         return response.status_code
 
     def get_version(self) -> Dict[str, Any]:

web3/contract/__init__.py

@@ -7,3 +7,10 @@ from web3.contract.contract import (
     ContractCaller,
     ContractConstructor,
 )
+
+__all__ = [
+    "AsyncContract",
+    "AsyncContractCaller",
+    "Contract",
+    "ContractConstructor",
+]

web3/contract/base_contract.py

@@ -16,6 +16,9 @@ from typing import (
 )
 import warnings
 
+from eth_abi.exceptions import (
+    InsufficientDataBytes,
+)
 from eth_typing import (
     Address,
     ChecksumAddress,
@@ -174,7 +177,13 @@ class BaseContractEvent:
         for log in txn_receipt["logs"]:
             try:
                 rich_log = get_event_data(self.w3.codec, self.abi, log)
-            except (MismatchedABI, LogTopicError, InvalidEventABI, TypeError) as e:
+            except (
+                MismatchedABI,
+                LogTopicError,
+                InvalidEventABI,
+                TypeError,
+                InsufficientDataBytes,
+            ) as e:
                 if errors == DISCARD:
                     continue
                 elif errors == IGNORE:

web3/eth/__init__.py

@@ -8,3 +8,10 @@ from .eth import (
     Contract,
     Eth,
 )
+
+__all__ = [
+    "AsyncEth",
+    "BaseEth",
+    "Contract",
+    "Eth",
+]

web3/eth/async_eth.py

@@ -127,17 +127,6 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], Awaitable[int]]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    async def hashrate(self) -> int:
-        return await self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], Awaitable[BlockNumber]]] = Method(
@@ -160,17 +149,6 @@ class AsyncEth(BaseEth):
     async def chain_id(self) -> int:
         return await self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], Awaitable[ChecksumAddress]]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    async def coinbase(self) -> ChecksumAddress:
-        return await self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Awaitable[Wei]]] = Method(
@@ -206,17 +184,6 @@ class AsyncEth(BaseEth):
             )
             return await async_fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], Awaitable[bool]]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    async def mining(self) -> bool:
-        return await self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Awaitable[Union[SyncStatus, bool]]]] = Method(

web3/eth/eth.py

@@ -119,17 +119,6 @@ class Eth(BaseEth):
     def accounts(self) -> Tuple[ChecksumAddress]:
         return self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], int]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    def hashrate(self) -> int:
-        return self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], BlockNumber]] = Method(
@@ -152,17 +141,6 @@ class Eth(BaseEth):
     def chain_id(self) -> int:
         return self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], ChecksumAddress]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    def coinbase(self) -> ChecksumAddress:
-        return self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Wei]] = Method(
@@ -198,17 +176,6 @@ class Eth(BaseEth):
             )
             return fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], bool]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    def mining(self) -> bool:
-        return self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Union[SyncStatus, bool]]] = Method(
@@ -285,7 +252,8 @@ class Eth(BaseEth):
                 return self._call(transaction, block_identifier, state_override)
             except OffchainLookup as offchain_lookup:
                 durin_calldata = handle_offchain_lookup(
-                    offchain_lookup.payload, transaction
+                    offchain_lookup.payload,
+                    transaction,
                 )
                 transaction["data"] = durin_calldata
 
@@ -660,25 +628,6 @@ class Eth(BaseEth):
         mungers=[default_root_munger],
     )
 
-    # eth_submitHashrate
-
-    submit_hashrate: Method[Callable[[int, _Hash32], bool]] = Method(
-        RPC.eth_submitHashrate,
-        mungers=[default_root_munger],
-    )
-
-    # eth_getWork, eth_submitWork
-
-    get_work: Method[Callable[[], List[HexBytes]]] = Method(
-        RPC.eth_getWork,
-        is_property=True,
-    )
-
-    submit_work: Method[Callable[[int, _Hash32, _Hash32], bool]] = Method(
-        RPC.eth_submitWork,
-        mungers=[default_root_munger],
-    )
-
     @overload
     # type error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
     def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[overload-overlap]  # noqa: E501

web3/exceptions.py

@@ -327,6 +327,12 @@ class TaskNotRunning(Web3Exception):
         super().__init__(message)
 
 
+class PersistentConnectionClosedOK(Web3Exception):
+    """
+    Raised when a persistent connection is closed gracefully by the server.
+    """
+
+
 class Web3RPCError(Web3Exception):
     """
     Raised when a JSON-RPC response contains an error field.

web3/manager.py

@@ -20,9 +20,6 @@ from eth_utils.toolz import (
 from hexbytes import (
     HexBytes,
 )
-from websockets.exceptions import (
-    ConnectionClosedOK,
-)
 
 from web3._utils.batching import (
     RequestBatcher,
@@ -472,22 +469,50 @@ class RequestManager:
 
     # -- persistent connection -- #
 
-    async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def socket_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         request_func = await provider.request_func(
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection: "
+            "Making request to open socket connection and waiting for response: "
             f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
 
+    async def send(self, method: RPCEndpoint, params: Any) -> None:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        # run through the request processors of the middleware
+        for mw_class in self.middleware_onion.as_tuple_of_middleware():
+            mw = mw_class(self.w3)
+            method, params = mw.request_processor(method, params)
+
+        self.logger.debug(
+            "Sending request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
+        )
+        await provider.socket_send(provider.encode_rpc_request(method, params))
+
+    async def recv(self) -> RPCResponse:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        self.logger.debug(
+            "Getting next response from open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}"
+        )
+        # pop from the queue since the listener task is responsible for reading
+        # directly from the socket
+        request_response_cache = self._request_processor._request_response_cache
+        _key, response = await request_response_cache.async_await_and_popitem(
+            last=False,
+            timeout=provider.request_timeout,
+        )
+        return await self._process_response(response)
+
     def _persistent_message_stream(self) -> "_AsyncPersistentMessageStream":
         return _AsyncPersistentMessageStream(self)
 
-    async def _get_next_message(self) -> Any:
+    async def _get_next_message(self) -> RPCResponse:
         return await self._message_stream().__anext__()
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
@@ -515,12 +540,13 @@ class RequestManager:
                     # if response is an active subscription response, process it
                     yield await self._process_response(response)
             except TaskNotRunning:
+                await asyncio.sleep(0)
                 self._provider._handle_listener_task_exceptions()
                 self.logger.error(
                     "Message listener background task has stopped unexpectedly. "
                     "Stopping message stream."
                 )
-                raise StopAsyncIteration
+                return
 
     async def _process_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
@@ -586,7 +612,4 @@ class _AsyncPersistentMessageStream:
         return self
 
     async def __anext__(self) -> RPCResponse:
-        try:
-            return await self.manager._get_next_message()
-        except ConnectionClosedOK:
-            raise StopAsyncIteration
+        return await self.manager._get_next_message()

web3/middleware/__init__.py

@@ -92,3 +92,20 @@ async def async_combine_middleware(
         initialized = mw(async_w3)
         accumulator_fn = await initialized.async_wrap_make_request(accumulator_fn)
     return accumulator_fn
+
+
+__all__ = [
+    "AttributeDictMiddleware",
+    "Middleware",
+    "Web3Middleware",
+    "BufferedGasEstimateMiddleware",
+    "LocalFilterMiddleware",
+    "FormattingMiddlewareBuilder",
+    "GasPriceStrategyMiddleware",
+    "ENSNameToAddressMiddleware",
+    "ExtraDataToPOAMiddleware",
+    "PythonicMiddleware",
+    "SignAndSendRawMiddlewareBuilder",
+    "StalecheckMiddlewareBuilder",
+    "ValidationMiddleware",
+]

web3/module.py

@@ -138,7 +138,7 @@ def retrieve_async_method_call_fn(
 
             try:
                 method_str = cast(RPCEndpoint, method_str)
-                return await async_w3.manager.send(method_str, params)
+                return await async_w3.manager.socket_request(method_str, params)
             except Exception as e:
                 if (
                     cache_key is not None

web3/providers/__init__.py

@@ -8,6 +8,10 @@ from .base import (
     BaseProvider,
     JSONBaseProvider,
 )
+from .eth_tester import (
+    AsyncEthereumTesterProvider,
+    EthereumTesterProvider,
+)
 from .ipc import (
     IPCProvider,
 )
@@ -26,3 +30,20 @@ from .persistent import (
 from .auto import (
     AutoProvider,
 )
+
+__all__ = [
+    "AsyncBaseProvider",
+    "AsyncEthereumTesterProvider",
+    "AsyncHTTPProvider",
+    "AsyncIPCProvider",
+    "AutoProvider",
+    "BaseProvider",
+    "EthereumTesterProvider",
+    "HTTPProvider",
+    "IPCProvider",
+    "JSONBaseProvider",
+    "LegacyWebSocketProvider",
+    "PersistentConnection",
+    "PersistentConnectionProvider",
+    "WebSocketProvider",
+]

web3/providers/eth_tester/__init__.py

@@ -2,3 +2,8 @@ from .main import (
     AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
+
+__all__ = [
+    "AsyncEthereumTesterProvider",
+    "EthereumTesterProvider",
+]

web3/providers/eth_tester/defaults.py

@@ -243,12 +243,6 @@ API_ENDPOINTS = {
     "eth": {
         "protocolVersion": static_return(63),
         "syncing": static_return(False),
-        "coinbase": compose(
-            operator.itemgetter(0),
-            call_eth_tester("get_accounts"),
-        ),
-        "mining": static_return(False),
-        "hashrate": static_return(0),
         "chainId": static_return(131277322940537),  # from fixture generation file
         "feeHistory": call_eth_tester("get_fee_history"),
         "maxPriorityFeePerGas": static_return(10**9),

web3/providers/eth_tester/middleware.py

@@ -59,7 +59,7 @@ if TYPE_CHECKING:
 
 
 def is_named_block(value: Any) -> bool:
-    return value in {"latest", "earliest", "pending", "safe", "finalized"}
+    return value in {"latest", "earliest", "safe", "finalized"}
 
 
 def is_hexstr(value: Any) -> bool:
@@ -334,9 +334,7 @@ result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {
 
 
 def guess_from(w3: "Web3", _: TxParams) -> ChecksumAddress:
-    if w3.eth.coinbase:
-        return w3.eth.coinbase
-    elif w3.eth.accounts and len(w3.eth.accounts) > 0:
+    if w3.eth.accounts and len(w3.eth.accounts) > 0:
         return w3.eth.accounts[0]
 
     return None
@@ -360,11 +358,8 @@ def fill_default(
 async def async_guess_from(
     async_w3: "AsyncWeb3", _: TxParams
 ) -> Optional[ChecksumAddress]:
-    coinbase = await async_w3.eth.coinbase
     accounts = await async_w3.eth.accounts
-    if coinbase is not None:
-        return coinbase
-    elif accounts is not None and len(accounts) > 0:
+    if accounts is not None and len(accounts) > 0:
         return accounts[0]
     return None
 

web3/providers/persistent/__init__.py

@@ -13,3 +13,10 @@ from .async_ipc import (
 from .websocket import (
     WebSocketProvider,
 )
+
+__all__ = [
+    "PersistentConnectionProvider",
+    "PersistentConnection",
+    "AsyncIPCProvider",
+    "WebSocketProvider",
+]