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

web3/middleware/formatting.py

@@ -3,6 +3,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Literal,
     Optional,
     Union,
     cast,
@@ -14,6 +15,9 @@ from eth_utils.toolz import (
     merge,
 )
 
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -21,7 +25,6 @@ from web3.types import (
     EthSubscriptionParams,
     Formatters,
     FormattersDict,
-    Literal,
     RPCEndpoint,
     RPCResponse,
 )
@@ -118,7 +121,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
         if (
             sync_formatters_builder is None and async_formatters_builder is not None
         ) or (sync_formatters_builder is not None and async_formatters_builder is None):
-            raise ValueError(
+            raise Web3ValueError(
                 "Must specify both sync_formatters_builder and async_formatters_builder"
             )
 
@@ -128,7 +131,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
                 or result_formatters is not None
                 or error_formatters is not None
             ):
-                raise ValueError(
+                raise Web3ValueError(
                     "Cannot specify formatters_builder and formatters at the same time"
                 )
 

web3/middleware/names.py

@@ -31,6 +31,9 @@ from .._utils.abi import (
 from .._utils.formatters import (
     recursive_map,
 )
+from ..exceptions import (
+    Web3TypeError,
+)
 from .base import (
     Web3Middleware,
 )
@@ -92,7 +95,7 @@ async def async_apply_ens_to_address_conversion(
         return (formatted_params_dict, *params[1:])
 
     else:
-        raise TypeError(
+        raise Web3TypeError(
             f"ABI definitions must be a list or dictionary, "
             f"got {abi_types_for_method!r}"
         )

web3/middleware/signing.py

@@ -55,6 +55,9 @@ from web3._utils.transactions import (
     fill_nonce,
     fill_transaction_defaults,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -108,7 +111,7 @@ def gen_normalized_accounts(
 
 @singledispatch
 def to_account(val: Any) -> LocalAccount:
-    raise TypeError(
+    raise Web3TypeError(
         "key must be one of the types: "
         "eth_keys.datatype.PrivateKey, eth_account.signers.local.LocalAccount, "
         "or raw private key as a hex string or byte string. "
@@ -132,7 +135,8 @@ to_account.register(bytes, private_key_to_account)
 
 
 def format_transaction(transaction: TxParams) -> TxParams:
-    """Format transaction so that it can be used correctly in the signing middleware.
+    """
+    Format transaction so that it can be used correctly in the signing middleware.
 
     Converts bytes to hex strings and other types that can be passed to
     the underlying layers. Also has the effect of normalizing 'from' for

web3/middleware/stalecheck.py

@@ -16,6 +16,7 @@ from toolz import (
 
 from web3.exceptions import (
     StaleBlockchain,
+    Web3ValueError,
 )
 from web3.middleware.base import (
     Web3Middleware,
@@ -54,7 +55,7 @@ class StalecheckMiddlewareBuilder(Web3MiddlewareBuilder):
         skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
     ) -> Web3Middleware:
         if allowable_delay <= 0:
-            raise ValueError(
+            raise Web3ValueError(
                 "You must set a positive allowable_delay in seconds for this middleware"
             )
         middleware = StalecheckMiddlewareBuilder(w3)

web3/providers/eth_tester/defaults.py

@@ -218,7 +218,7 @@ def _generate_random_private_key() -> HexStr:
     WARNING: This is not a secure way to generate private keys and should only
     be used for testing purposes.
     """
-    return encode_hex(bytes(bytearray((random.randint(0, 255) for _ in range(32)))))
+    return encode_hex(bytes(bytearray(random.randint(0, 255) for _ in range(32))))
 
 
 @without_params

web3/providers/eth_tester/main.py

@@ -4,6 +4,7 @@ from typing import (
     Callable,
     Coroutine,
     Dict,
+    Literal,
     Optional,
     Union,
 )
@@ -18,9 +19,6 @@ from eth_utils import (
     is_bytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3.providers import (
     BaseProvider,
 )
@@ -33,6 +31,9 @@ from web3.types import (
     RPCResponse,
 )
 
+from ...exceptions import (
+    Web3TypeError,
+)
 from ...middleware import (
     async_combine_middleware,
     combine_middleware,
@@ -133,7 +134,7 @@ class EthereumTesterProvider(BaseProvider):
         elif isinstance(ethereum_tester, BaseChainBackend):
             self.ethereum_tester = EthereumTester(ethereum_tester)
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 "Expected ethereum_tester to be of type `eth_tester.EthereumTester` or "
                 "a subclass of `eth_tester.backends.base.BaseChainBackend`, "
                 f"instead received {type(ethereum_tester)}. "

web3/providers/eth_tester/middleware.py

@@ -72,7 +72,9 @@ is_not_named_block = complement(is_named_block)
 # --- Request Mapping --- #
 
 TRANSACTION_REQUEST_KEY_MAPPING = {
+    "blobVersionedHashes": "blob_versioned_hashes",
     "gasPrice": "gas_price",
+    "maxFeePerBlobGas": "max_fee_per_blob_gas",
     "maxFeePerGas": "max_fee_per_gas",
     "maxPriorityFeePerGas": "max_priority_fee_per_gas",
     "accessList": "access_list",
@@ -90,7 +92,7 @@ TRANSACTION_REQUEST_FORMATTERS = {
     "maxFeePerGas": to_integer_if_hex,
     "maxPriorityFeePerGas": to_integer_if_hex,
     "accessList": apply_list_to_array_formatter(
-        (apply_key_map({"storageKeys": "storage_keys"}))
+        apply_key_map({"storageKeys": "storage_keys"})
     ),
 }
 transaction_request_formatter = apply_formatters_to_dict(TRANSACTION_REQUEST_FORMATTERS)
@@ -123,10 +125,12 @@ filter_request_transformer = compose(
 
 TRANSACTION_RESULT_KEY_MAPPING = {
     "access_list": "accessList",
+    "blob_versioned_hashes": "blobVersionedHashes",
     "block_hash": "blockHash",
     "block_number": "blockNumber",
     "chain_id": "chainId",
     "gas_price": "gasPrice",
+    "max_fee_per_blob_gas": "maxFeePerBlobGas",
     "max_fee_per_gas": "maxFeePerGas",
     "max_priority_fee_per_gas": "maxPriorityFeePerGas",
     "transaction_hash": "transactionHash",
@@ -164,6 +168,8 @@ RECEIPT_RESULT_KEY_MAPPING = {
     "effective_gas_price": "effectiveGasPrice",
     "transaction_hash": "transactionHash",
     "transaction_index": "transactionIndex",
+    "blob_gas_used": "blobGasUsed",
+    "blob_gas_price": "blobGasPrice",
 }
 receipt_result_remapper = apply_key_map(RECEIPT_RESULT_KEY_MAPPING)
 
@@ -186,6 +192,9 @@ BLOCK_RESULT_KEY_MAPPING = {
     # JSON-RPC spec still says miner
     "coinbase": "miner",
     "withdrawals_root": "withdrawalsRoot",
+    "parent_beacon_block_root": "parentBeaconBlockRoot",
+    "blob_gas_used": "blobGasUsed",
+    "excess_blob_gas": "excessBlobGas",
 }
 block_result_remapper = apply_key_map(BLOCK_RESULT_KEY_MAPPING)
 

web3/providers/ipc.py

@@ -26,6 +26,10 @@ from web3.types import (
     RPCResponse,
 )
 
+from ..exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from .base import (
     JSONBaseProvider,
 )
@@ -96,7 +100,7 @@ def get_default_ipc_path() -> str:
         return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
@@ -117,7 +121,7 @@ def get_dev_ipc_path() -> str:
         return r"\\.\pipe\geth.ipc"
 
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Unsupported platform '{sys.platform}'. Only darwin/linux/win32/"
             "freebsd are supported.  You must specify the ipc_path"
         )
@@ -139,7 +143,7 @@ class IPCProvider(JSONBaseProvider):
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
             self.ipc_path = str(Path(ipc_path).expanduser().resolve())
         else:
-            raise TypeError("ipc_path must be of type string or pathlib.Path")
+            raise Web3TypeError("ipc_path must be of type string or pathlib.Path")
 
         self.timeout = timeout
         self._lock = threading.Lock()

web3/providers/persistent/async_ipc.py

@@ -33,6 +33,7 @@ from ..._utils.caching import (
 )
 from ...exceptions import (
     ProviderConnectionError,
+    Web3TypeError,
 )
 from ..ipc import (
     get_default_ipc_path,
@@ -71,7 +72,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
             self.ipc_path = str(Path(ipc_path).expanduser().resolve())
         else:
-            raise TypeError("ipc_path must be of type string or pathlib.Path")
+            raise Web3TypeError("ipc_path must be of type string or pathlib.Path")
 
         self._max_connection_retries = max_connection_retries
         super().__init__(**kwargs)
@@ -91,7 +92,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             current_request_id = json.loads(request_data)["id"]
             await self._get_response_for_request_id(current_request_id, timeout=2)
             return True
-        except (OSError, BrokenPipeError, ProviderConnectionError) as e:
+        except (OSError, ProviderConnectionError) as e:
             if show_traceback:
                 raise ProviderConnectionError(
                     f"Problem connecting to provider with error: {type(e)}: {e}"
@@ -114,11 +115,11 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             except OSError as e:
                 if _connection_attempts == self._max_connection_retries:
                     raise ProviderConnectionError(
-                        f"Could not connect to endpoint: {self.endpoint_uri}. "
+                        f"Could not connect to: {self.ipc_path}. "
                         f"Retries exceeded max of {self._max_connection_retries}."
                     ) from e
                 self.logger.info(
-                    f"Could not connect to endpoint: {self.endpoint_uri}. Retrying in "
+                    f"Could not connect to: {self.ipc_path}. Retrying in "
                     f"{round(_backoff_time, 1)} seconds.",
                     exc_info=True,
                 )
@@ -130,9 +131,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             self._writer.close()
             await self._writer.wait_closed()
             self._writer = None
-            self.logger.debug(
-                f'Successfully disconnected from endpoint: "{self.endpoint_uri}'
-            )
+            self.logger.debug(f'Successfully disconnected from : "{self.ipc_path}')
 
         try:
             self._message_listener_task.cancel()

web3/providers/persistent/persistent.py

@@ -30,7 +30,6 @@ DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 30.0
 class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     logger = logging.getLogger("web3.providers.PersistentConnectionProvider")
     has_persistent_connection = True
-    endpoint_uri: Optional[str] = None
 
     _request_processor: RequestProcessor
     _message_listener_task: Optional["asyncio.Task[None]"] = None
@@ -50,6 +49,17 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         self.request_timeout = request_timeout
         self.silence_listener_task_exceptions = silence_listener_task_exceptions
 
+    def get_endpoint_uri_or_ipc_path(self) -> str:
+        if hasattr(self, "endpoint_uri"):
+            return str(self.endpoint_uri)
+        elif hasattr(self, "ipc_path"):
+            return str(self.ipc_path)
+        else:
+            raise AttributeError(
+                "`PersistentConnectionProvider` must have either `endpoint_uri` or "
+                "`ipc_path` attribute."
+            )
+
     async def connect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 
@@ -78,7 +88,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

@@ -15,6 +15,9 @@ from web3._utils.caching import (
     RequestInformation,
     generate_cache_key,
 )
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -136,9 +139,9 @@ class RequestProcessor:
     ) -> RequestInformation:
         if "method" in response and response["method"] == "eth_subscription":
             if "params" not in response:
-                raise ValueError("Subscription response must have params field")
+                raise Web3ValueError("Subscription response must have params field")
             if "subscription" not in response["params"]:
-                raise ValueError(
+                raise Web3ValueError(
                     "Subscription response params must have subscription field"
                 )
 
@@ -235,19 +238,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(
@@ -268,7 +269,7 @@ class RequestProcessor:
             )
         else:
             if not cache_key:
-                raise ValueError(
+                raise Web3ValueError(
                     "Must provide cache key when popping a non-subscription response."
                 )
 
@@ -285,10 +286,7 @@ class RequestProcessor:
     # request processor class methods
 
     def clear_caches(self) -> None:
-        """
-        Clear the request processor caches.
-        """
-
+        """Clear the request processor caches."""
         self._request_information_cache.clear()
         self._request_response_cache.clear()
         self._subscription_response_queue = asyncio.Queue(

web3/providers/persistent/websocket.py

@@ -71,9 +71,9 @@ class WebSocketProvider(PersistentConnectionProvider):
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
-        self.endpoint_uri = URI(endpoint_uri)
-        if self.endpoint_uri is None:
-            self.endpoint_uri = get_default_endpoint()
+        self.endpoint_uri = (
+            URI(endpoint_uri) if endpoint_uri is not None else get_default_endpoint()
+        )
 
         if not any(
             self.endpoint_uri.startswith(prefix)

web3/providers/rpc/async_rpc.py

@@ -20,6 +20,10 @@ from eth_utils import (
     to_dict,
 )
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
@@ -54,9 +58,9 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
-        exception_retry_configuration: Optional[
-            ExceptionRetryConfiguration
-        ] = ExceptionRetryConfiguration(errors=(ClientError, TimeoutError)),
+        exception_retry_configuration: Union[
+            ExceptionRetryConfiguration, Empty
+        ] = empty,
     ) -> None:
         if endpoint_uri is None:
             self.endpoint_uri = get_default_http_endpoint()
@@ -64,7 +68,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
         super().__init__()
 
@@ -74,12 +78,25 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
 
+    @property
+    def exception_retry_configuration(self) -> ExceptionRetryConfiguration:
+        if isinstance(self._exception_retry_configuration, Empty):
+            self._exception_retry_configuration = ExceptionRetryConfiguration(
+                errors=(ClientError, TimeoutError)
+            )
+        return self._exception_retry_configuration
+
+    @exception_retry_configuration.setter
+    def exception_retry_configuration(
+        self, value: Union[ExceptionRetryConfiguration, Empty]
+    ) -> None:
+        self._exception_retry_configuration = value
+
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
 
     def get_request_headers(self) -> Dict[str, str]:
         return {

web3/providers/rpc/rpc.py

@@ -18,6 +18,10 @@ from eth_utils import (
 )
 import requests
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
@@ -51,26 +55,16 @@ if TYPE_CHECKING:
 class HTTPProvider(JSONBaseProvider):
     logger = logging.getLogger("web3.providers.HTTPProvider")
     endpoint_uri = None
-
-    _request_args = None
     _request_kwargs = None
 
-    exception_retry_configuration: Optional[ExceptionRetryConfiguration] = None
-
     def __init__(
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         session: Optional[Any] = None,
-        exception_retry_configuration: Optional[ExceptionRetryConfiguration] = (
-            ExceptionRetryConfiguration(
-                errors=(
-                    ConnectionError,
-                    requests.HTTPError,
-                    requests.Timeout,
-                )
-            )
-        ),
+        exception_retry_configuration: Union[
+            ExceptionRetryConfiguration, Empty
+        ] = empty,
     ) -> None:
         if endpoint_uri is None:
             self.endpoint_uri = get_default_http_endpoint()
@@ -78,7 +72,7 @@ class HTTPProvider(JSONBaseProvider):
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
         if session:
             cache_and_return_session(self.endpoint_uri, session)
@@ -88,12 +82,29 @@ class HTTPProvider(JSONBaseProvider):
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
 
+    @property
+    def exception_retry_configuration(self) -> ExceptionRetryConfiguration:
+        if isinstance(self._exception_retry_configuration, Empty):
+            self._exception_retry_configuration = ExceptionRetryConfiguration(
+                errors=(
+                    ConnectionError,
+                    requests.HTTPError,
+                    requests.Timeout,
+                )
+            )
+        return self._exception_retry_configuration
+
+    @exception_retry_configuration.setter
+    def exception_retry_configuration(
+        self, value: Union[ExceptionRetryConfiguration, Empty]
+    ) -> None:
+        self._exception_retry_configuration = value
+
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
 
     def get_request_headers(self) -> Dict[str, str]:
         return {

web3/testing.py

@@ -12,21 +12,21 @@ from web3.module import (
 
 class Testing(Module):
     def timeTravel(self, timestamp: int) -> None:
-        return self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
+        self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
 
     def mine(self, num_blocks: int = 1) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
+        self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
 
     def snapshot(self) -> int:
         self.last_snapshot_idx = self.w3.manager.request_blocking(RPC.evm_snapshot, [])
         return self.last_snapshot_idx
 
     def reset(self) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_reset, [])
+        self.w3.manager.request_blocking(RPC.evm_reset, [])
 
     def revert(self, snapshot_idx: Optional[int] = None) -> None:
         if snapshot_idx is None:
             revert_target = self.last_snapshot_idx
         else:
             revert_target = snapshot_idx
-        return self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])
+        self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])