web3 7.0.0b1__py3-none-any.whl → 7.0.0b3__py3-none-any.whl

web3/eth/async_eth.py

@@ -4,6 +4,7 @@ from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
     List,
     Optional,
     Tuple,
@@ -75,6 +76,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -440,6 +442,20 @@ class AsyncEth(BaseEth):
     ) -> BlockData:
         return await self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[
+        Callable[[BlockIdentifier], Awaitable[BlockReceipts]]
+    ] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    async def get_block_receipts(
+        self, block_identifier: BlockIdentifier
+    ) -> BlockReceipts:
+        return await self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -622,14 +638,16 @@ class AsyncEth(BaseEth):
     # eth_signTypedData
 
     _sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], Awaitable[HexStr]]
+        Callable[
+            [Union[Address, ChecksumAddress, ENS], Dict[str, Any]], Awaitable[HexStr]
+        ]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],
     )
 
     async def sign_typed_data(
-        self, account: Union[Address, ChecksumAddress, ENS], data: str
+        self, account: Union[Address, ChecksumAddress, ENS], data: Dict[str, Any]
     ) -> HexStr:
         return await self._sign_typed_data(account, data)
 

web3/eth/eth.py

@@ -2,6 +2,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Sequence,
@@ -72,6 +73,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -411,6 +413,16 @@ class Eth(BaseEth):
     ) -> BlockData:
         return self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[Callable[[BlockIdentifier], BlockReceipts]] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    def get_block_receipts(self, block_identifier: BlockIdentifier) -> BlockReceipts:
+        return self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -611,7 +623,7 @@ class Eth(BaseEth):
     # eth_signTypedData
 
     sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], HexStr]
+        Callable[[Union[Address, ChecksumAddress, ENS], Dict[str, Any]], HexStr]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],

web3/exceptions.py

@@ -30,6 +30,16 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    def __init__(
+        self,
+        *args: Any,
+        user_message: Optional[str] = None,
+    ):
+        super().__init__(*args)
+
+        # Assign properties of Web3Exception
+        self.user_message = user_message
+
 
 class BadFunctionCallOutput(Web3Exception):
     """
@@ -274,6 +284,7 @@ class ContractLogicError(Web3Exception):
         message: Optional[str] = None,
         data: Optional[Union[str, Dict[str, str]]] = None,
     ):
+        super().__init__(message, data)
         self.message = message
         self.data = data
 

web3/main.py

@@ -1,5 +1,4 @@
 import decimal
-import warnings
 from types import (
     TracebackType,
 )
@@ -142,7 +141,6 @@ from web3.types import (
 )
 
 if TYPE_CHECKING:
-    from web3.pm import PM  # noqa: F401
     from web3._utils.empty import Empty  # noqa: F401
 
 
@@ -338,30 +336,6 @@ 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
-
-            self.attach_modules({"_pm": PM})
-
 
 class Web3(BaseWeb3):
     # mypy types
@@ -378,14 +352,14 @@ 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)
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         if modules is None:
@@ -446,14 +420,14 @@ 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)
+        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

web3/manager.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 from typing import (
     TYPE_CHECKING,
@@ -125,7 +124,7 @@ class RequestManager:
         self,
         w3: Union["AsyncWeb3", "Web3"],
         provider: Optional[Union["BaseProvider", "AsyncBaseProvider"]] = None,
-        middlewares: Optional[Sequence[Tuple[Middleware, str]]] = None,
+        middleware: Optional[Sequence[Tuple[Middleware, str]]] = None,
     ) -> None:
         self.w3 = w3
 
@@ -134,10 +133,10 @@ class RequestManager:
         else:
             self.provider = provider
 
-        if middlewares is None:
-            middlewares = self.get_default_middlewares()
+        if middleware is None:
+            middleware = self.get_default_middleware()
 
-        self.middleware_onion = NamedElementOnion(middlewares)
+        self.middleware_onion = NamedElementOnion(middleware)
 
         if isinstance(provider, PersistentConnectionProvider):
             # set up the request processor to be able to properly process ordered
@@ -157,9 +156,9 @@ class RequestManager:
         self._provider = provider
 
     @staticmethod
-    def get_default_middlewares() -> List[Tuple[Middleware, str]]:
+    def get_default_middleware() -> List[Tuple[Middleware, str]]:
         """
-        List the default middlewares for the request manager.
+        List the default middleware for the request manager.
         Documentation should remain in sync with these defaults.
         """
         return [
@@ -246,7 +245,11 @@ class RequestManager:
             if not isinstance(code, int):
                 _raise_bad_response_format(response, "error['code'] must be an integer")
             elif code == METHOD_NOT_FOUND:
-                raise MethodUnavailable(error)
+                raise MethodUnavailable(
+                    error,
+                    user_message="Check your node provider's API docs to see what "
+                    "methods are supported",
+                )
 
             # Errors must include a message
             if not isinstance(error.get("message"), str):
@@ -345,11 +348,7 @@ class RequestManager:
             )
 
         while True:
-            # sleep(0) here seems to be the most efficient way to yield control
-            # back to the event loop while waiting for the response in the queue.
-            await asyncio.sleep(0)
-
-            response = self._request_processor.pop_raw_response(subscription=True)
+            response = await self._request_processor.pop_raw_response(subscription=True)
             if (
                 response is not None
                 and response.get("params", {}).get("subscription")

web3/middleware/__init__.py

@@ -11,6 +11,7 @@ from .attrdict import (
 )
 from .base import (
     Middleware,
+    Web3Middleware,
 )
 from .buffered_gas_estimate import (
     BufferedGasEstimateMiddleware,
@@ -58,8 +59,8 @@ if TYPE_CHECKING:
     )
 
 
-def combine_middlewares(
-    middlewares: Sequence[Middleware],
+def combine_middleware(
+    middleware: Sequence[Middleware],
     w3: "Web3",
     provider_request_fn: MakeRequestFn,
 ) -> Callable[..., "RPCResponse"]:
@@ -69,14 +70,14 @@ def combine_middlewares(
     the response through the response processors.
     """
     accumulator_fn = provider_request_fn
-    for middleware in reversed(middlewares):
+    for mw in reversed(middleware):
         # initialize the middleware and wrap the accumulator function down the stack
-        accumulator_fn = middleware(w3).wrap_make_request(accumulator_fn)
+        accumulator_fn = mw(w3).wrap_make_request(accumulator_fn)
     return accumulator_fn
 
 
-async def async_combine_middlewares(
-    middlewares: Sequence[Middleware],
+async def async_combine_middleware(
+    middleware: Sequence[Middleware],
     async_w3: "AsyncWeb3",
     provider_request_fn: AsyncMakeRequestFn,
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
@@ -86,8 +87,8 @@ async def async_combine_middlewares(
     the response through the response processors.
     """
     accumulator_fn = provider_request_fn
-    for middleware in reversed(middlewares):
+    for mw in reversed(middleware):
         # initialize the middleware and wrap the accumulator function down the stack
-        initialized = middleware(async_w3)
+        initialized = mw(async_w3)
         accumulator_fn = await initialized.async_wrap_make_request(accumulator_fn)
     return accumulator_fn

web3/module.py

@@ -129,7 +129,7 @@ def retrieve_async_method_call_fn(
 
 #  Module should no longer have access to the full web3 api.
 #  Only the calling functions need access to the request methods.
-#  Any "re-entrant" shenanigans can go in the middlewares, which do
+#  Any "re-entrant" shenanigans can go in the middleware, which do
 #  have web3 access.
 class Module:
     is_async = False

web3/providers/async_base.py

@@ -28,7 +28,7 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    async_combine_middlewares,
+    async_combine_middleware,
 )
 from web3.middleware.base import (
     Middleware,
@@ -95,14 +95,14 @@ class AsyncBaseProvider:
     async def request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        middlewares: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middlewares()
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                await async_combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                await async_combine_middleware(
+                    middleware=middleware,
                     async_w3=async_w3,
                     provider_request_fn=self.make_request,
                 ),

web3/providers/base.py

@@ -25,7 +25,7 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    combine_middlewares,
+    combine_middleware,
 )
 from web3.middleware.base import (
     Middleware,
@@ -61,7 +61,7 @@ CACHEABLE_REQUESTS = cast(
 
 
 class BaseProvider:
-    # a tuple of (middlewares, request_func)
+    # a tuple of (middleware, request_func)
     _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
         None,
         None,
@@ -86,19 +86,19 @@ class BaseProvider:
     ) -> Callable[..., RPCResponse]:
         """
         @param w3 is the web3 instance
-        @param middleware_onion is an iterable of middlewares,
+        @param middleware_onion is an iterable of middleware,
             ordered by first to execute
         @returns a function that calls all the middleware and
             eventually self.make_request()
         """
-        middlewares: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middlewares()
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                combine_middleware(
+                    middleware=middleware,
                     w3=w3,
                     provider_request_fn=self.make_request,
                 ),

web3/providers/eth_tester/main.py

@@ -12,7 +12,7 @@ from eth_abi import (
     abi,
 )
 from eth_abi.exceptions import (
-    InsufficientDataBytes,
+    DecodingError,
 )
 from eth_utils import (
     is_bytes,
@@ -34,8 +34,8 @@ from web3.types import (
 )
 
 from ...middleware import (
-    async_combine_middlewares,
-    combine_middlewares,
+    async_combine_middleware,
+    combine_middleware,
 )
 from .middleware import (
     default_transaction_fields_middleware,
@@ -58,7 +58,7 @@ if TYPE_CHECKING:
 
 
 class AsyncEthereumTesterProvider(AsyncBaseProvider):
-    _middlewares = (
+    _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
     )
@@ -83,16 +83,14 @@ class AsyncEthereumTesterProvider(AsyncBaseProvider):
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
         # override the request_func to add the ethereum_tester_middleware
 
-        middlewares = middleware_onion.as_tuple_of_middlewares() + tuple(
-            self._middlewares
-        )
+        middleware = middleware_onion.as_tuple_of_middleware() + tuple(self._middleware)
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                await async_combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                await async_combine_middleware(
+                    middleware=middleware,
                     async_w3=async_w3,
                     provider_request_fn=self.make_request,
                 ),
@@ -107,7 +105,7 @@ class AsyncEthereumTesterProvider(AsyncBaseProvider):
 
 
 class EthereumTesterProvider(BaseProvider):
-    _middlewares = (
+    _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
     )
@@ -159,16 +157,14 @@ class EthereumTesterProvider(BaseProvider):
     ) -> Callable[..., RPCResponse]:
         # override the request_func to add the ethereum_tester_middleware
 
-        middlewares = middleware_onion.as_tuple_of_middlewares() + tuple(
-            self._middlewares
-        )
+        middleware = middleware_onion.as_tuple_of_middleware() + tuple(self._middleware)
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                combine_middleware(
+                    middleware=middleware,
                     w3=w3,
                     provider_request_fn=self.make_request,
                 ),
@@ -229,7 +225,7 @@ def _make_request(
                 if is_bytes(raw_error_msg)
                 else raw_error_msg
             )
-        except InsufficientDataBytes:
+        except DecodingError:
             reason = first_arg
         raise TransactionFailed(f"execution reverted: {reason}")
     else:

web3/providers/ipc.py

@@ -130,7 +130,7 @@ class IPCProvider(JSONBaseProvider):
     def __init__(
         self,
         ipc_path: Union[str, Path] = None,
-        timeout: int = 10,
+        timeout: int = 30,
         *args: Any,
         **kwargs: Any,
     ) -> None:

web3/providers/legacy_websocket.py

@@ -37,7 +37,7 @@ from web3.types import (
 )
 
 RESTRICTED_WEBSOCKET_KWARGS = {"uri", "loop"}
-DEFAULT_WEBSOCKET_TIMEOUT = 10
+DEFAULT_WEBSOCKET_TIMEOUT = 30
 
 
 def _start_event_loop(loop: asyncio.AbstractEventLoop) -> None:

web3/providers/persistent/persistent.py

@@ -24,7 +24,7 @@ from web3.types import (
     RPCResponse,
 )
 
-DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 50.0
+DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 30.0
 
 
 class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
@@ -78,7 +78,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                     self.logger.debug(
                         f"Popping response for id {request_id} from cache."
                     )
-                    popped_response = self._request_processor.pop_raw_response(
+                    popped_response = await self._request_processor.pop_raw_response(
                         cache_key=request_cache_key,
                     )
                     return popped_response

web3/providers/persistent/request_processor.py

@@ -235,19 +235,17 @@ class RequestProcessor:
             )
             self._request_response_cache.cache(cache_key, raw_response)
 
-    def pop_raw_response(
+    async def pop_raw_response(
         self, cache_key: str = None, subscription: bool = False
     ) -> Any:
         if subscription:
             qsize = self._subscription_response_queue.qsize()
-            if qsize == 0:
-                return None
+            raw_response = await self._subscription_response_queue.get()
 
             if not self._provider._listen_event.is_set():
                 self._provider._listen_event.set()
 
-            raw_response = self._subscription_response_queue.get_nowait()
-            if qsize == 1:
+            if qsize == 0:
                 if not self._subscription_queue_synced_with_ws_stream:
                     self._subscription_queue_synced_with_ws_stream = True
                     self._provider.logger.info(

web3/tools/benchmark/main.py

@@ -59,7 +59,7 @@ def build_web3_http(endpoint_uri: str) -> Web3:
     wait_for_http(endpoint_uri)
     _w3 = Web3(
         HTTPProvider(endpoint_uri),
-        middlewares=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
     )
     return _w3
 
@@ -68,7 +68,7 @@ async def build_async_w3_http(endpoint_uri: str) -> AsyncWeb3:
     await wait_for_aiohttp(endpoint_uri)
     _w3 = AsyncWeb3(
         AsyncHTTPProvider(endpoint_uri),
-        middlewares=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
     )
     return _w3
 

web3/types.py

@@ -135,6 +135,7 @@ TxData = TypedDict(
     "TxData",
     {
         "accessList": AccessList,
+        "blobVersionedHashes": Sequence[HexBytes],
         "blockHash": HexBytes,
         "blockNumber": BlockNumber,
         "chainId": int,
@@ -142,6 +143,7 @@ TxData = TypedDict(
         "from": ChecksumAddress,
         "gas": int,
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Wei,
         "maxFeePerGas": Wei,
         "maxPriorityFeePerGas": Wei,
         "hash": HexBytes,
@@ -381,6 +383,8 @@ TxReceipt = TypedDict(
     },
 )
 
+BlockReceipts = List[TxReceipt]
+
 
 class SignedTx(TypedDict, total=False):
     raw: bytes

web3/utils/caching.py

@@ -16,22 +16,20 @@ class SimpleCache:
         self._data: OrderedDict[str, Any] = OrderedDict()
 
     def cache(self, key: str, value: Any) -> Tuple[Any, Dict[str, Any]]:
-        evicted_items = None
+        evicted_items = {}
         # If the key is already in the OrderedDict just update it
         # and don't evict any values. Ideally, we could still check to see
         # if there are too many items in the OrderedDict but that may rearrange
         # the order it should be unlikely that the size could grow over the limit
         if key not in self._data:
             while len(self._data) >= self._size:
-                if evicted_items is None:
-                    evicted_items = {}
                 k, v = self._data.popitem(last=False)
                 evicted_items[k] = v
         self._data[key] = value
 
         # Return the cached value along with the evicted items at the same time. No
         # need to reach back into the cache to grab the value.
-        return value, evicted_items
+        return value, evicted_items or None
 
     def get_cache_entry(self, key: str) -> Optional[Any]:
         return self._data[key] if key in self._data else None