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

web3/geth.py

@@ -5,6 +5,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Protocol,
     Tuple,
 )
 
@@ -18,9 +19,6 @@ from hexbytes.main import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Protocol,
-)
 from web3._utils.rpc_abi import (
     RPC,
 )

web3/main.py

@@ -84,6 +84,10 @@ from web3.eth import (
     AsyncEth,
     Eth,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
@@ -283,7 +287,7 @@ class BaseWeb3:
             input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
             return eth_utils_keccak(input_bytes)
 
-        raise TypeError(
+        raise Web3TypeError(
             f"You called keccak with first arg {primitive!r} and keywords "
             f"{{'text': {text!r}, 'hexstr': {hexstr!r}}}. You must call it with "
             "one of these approaches: keccak(text='txt'), keccak(hexstr='0x747874'), "
@@ -304,7 +308,7 @@ class BaseWeb3:
         and list of corresponding values  -- `[20, [-1, 5, 0], True]`
         """
         if len(abi_types) != len(values):
-            raise ValueError(
+            raise Web3ValueError(
                 "Length mismatch between provided abi types and values.  Got "
                 f"{len(abi_types)} types and {len(values)} values."
             )

web3/manager.py

@@ -35,6 +35,8 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.middleware import (
     AttributeDictMiddleware,
@@ -238,7 +240,7 @@ class RequestManager:
             error = response.get("error")
             # Raise the error when the value is a string
             if error is None or isinstance(error, str):
-                raise ValueError(error)
+                raise Web3ValueError(error)
 
             # Errors must include an integer code
             code = error.get("code")
@@ -259,7 +261,7 @@ class RequestManager:
 
             apply_error_formatters(error_formatters, response)
 
-            raise ValueError(error)
+            raise Web3ValueError(error)
 
         # Format and validate results
         elif "result" in response:
@@ -323,8 +325,8 @@ class RequestManager:
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection - "
-            f"uri: {provider.endpoint_uri}, method: {method}"
+            "Making request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
@@ -337,7 +339,7 @@ class RequestManager:
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
         if not isinstance(self._provider, PersistentConnectionProvider):
-            raise TypeError(
+            raise Web3TypeError(
                 "Only providers that maintain an open, persistent connection "
                 "can listen to streams."
             )

web3/method.py

@@ -32,7 +32,9 @@ from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCEndpoint,
@@ -66,7 +68,9 @@ def _set_mungers(
     return (
         mungers
         if mungers
-        else [default_munger] if is_property else [default_root_munger]
+        else [default_munger]
+        if is_property
+        else [default_root_munger]
     )
 
 
@@ -84,7 +88,8 @@ TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
 class Method(Generic[TFunc]):
-    """Method object for web3 module methods
+    """
+    Method object for web3 module methods
 
     Calls to the Method go through these steps:
 
@@ -147,7 +152,7 @@ class Method(Generic[TFunc]):
         self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
     ) -> TFunc:
         if obj is None:
-            raise TypeError(
+            raise Web3TypeError(
                 "Direct calls to methods are not supported. "
                 "Methods must be called from an module instance, "
                 "usually attached to a web3 instance."
@@ -163,7 +168,7 @@ class Method(Generic[TFunc]):
             return self.json_rpc_method
         elif isinstance(self.json_rpc_method, (str,)):
             return lambda *_: self.json_rpc_method
-        raise ValueError(
+        raise Web3ValueError(
             "``json_rpc_method`` config invalid.  May be a string or function"
         )
 
@@ -175,7 +180,9 @@ class Method(Generic[TFunc]):
             lambda args, munger: munger(module, *args, **kwargs), self.mungers, args
         )
 
-    def process_params(self, module: "Module", *args: Any, **kwargs: Any) -> Tuple[
+    def process_params(
+        self, module: "Module", *args: Any, **kwargs: Any
+    ) -> Tuple[
         Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[Any, ...]],
         Tuple[
             Union[TReturn, Dict[str, Callable[..., Any]]],
@@ -226,5 +233,6 @@ class DeprecatedMethod:
         warnings.warn(
             f"{self.old_name} is deprecated in favor of {self.new_name}",
             category=DeprecationWarning,
+            stacklevel=2,
         )
         return self.method.__get__(obj, obj_type)

web3/middleware/base.py

@@ -48,7 +48,9 @@ class Web3Middleware:
     def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         return method, params
 
-    def response_processor(self, method: "RPCEndpoint", response: "RPCResponse") -> Any:
+    def response_processor(
+        self, method: "RPCEndpoint", response: "RPCResponse"
+    ) -> "RPCResponse":
         return response
 
     # -- async -- #
@@ -76,7 +78,7 @@ class Web3Middleware:
         self,
         method: "RPCEndpoint",
         response: "RPCResponse",
-    ) -> Any:
+    ) -> "RPCResponse":
         return response
 
 

web3/middleware/filter.py

@@ -42,6 +42,9 @@ from web3._utils.formatters import (
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3Middleware,
 )
@@ -71,7 +74,8 @@ else:
 
 
 def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
-    """Creates a segment counting generator
+    """
+    Creates a segment counting generator
 
     The generator returns tuple pairs of integers
     that correspond to segments in the provided range.
@@ -84,6 +88,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
 
 
     Example:
+    -------
 
     >>> segment_counter = segment_count(start=0, stop=10, step=3)
     >>> next(segment_counter)
@@ -94,6 +99,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     (6, 9)
     >>> next(segment_counter) #  Remainder is also returned
     (9, 10)
+
     """
     return gen_bounded_segments(start, stop, step)
 
@@ -104,10 +110,9 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
     if start + step >= stop:
         yield (start, stop)
         return
-    for segment in zip(
+    yield from zip(
         range(start, stop - step + 1, step), range(start + step, stop + 1, step)
-    ):
-        yield segment
+    )
 
     remainder = (stop - start) % step
     #  Handle the remainder
@@ -118,13 +123,14 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 def block_ranges(
     start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
 ) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
-    """Returns 2-tuple ranges describing ranges of block from start_block to last_block
+    """
+    Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
     Ranges do not overlap to facilitate use as ``toBlock``, ``fromBlock``
     json-rpc arguments, which are both inclusive.
     """
     if last_block is not None and start_block > last_block:
-        raise TypeError(
+        raise Web3TypeError(
             "Incompatible start and stop arguments.",
             "Start must be less than or equal to stop.",
         )
@@ -138,7 +144,8 @@ def block_ranges(
 def iter_latest_block(
     w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> Iterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -160,8 +167,7 @@ def iter_latest_block(
 
     while True:
         latest_block = w3.eth.block_number
-        # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:  # type: ignore
+        if is_bounded_range and latest_block > to_block:
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -176,7 +182,8 @@ def iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `fromBlock` to the latest mined block,
     until reaching toBlock. e.g.:
@@ -212,7 +219,8 @@ def get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> Iterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -247,9 +255,8 @@ class RequestLogs:
         if from_block is None or from_block == "latest":
             self._from_block = BlockNumber(w3.eth.block_number + 1)
         elif is_string(from_block) and is_hex(from_block):
-            self._from_block = BlockNumber(hex_to_integer(from_block))  # type: ignore
+            self._from_block = BlockNumber(hex_to_integer(from_block))
         else:
-            # cast b/c LatestBlockParam is handled above
             self._from_block = from_block
         self._to_block = to_block
         self.filter_changes = self._get_filter_changes()
@@ -265,7 +272,7 @@ class RequestLogs:
         elif self._to_block == "latest":
             to_block = self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
-            to_block = BlockNumber(hex_to_integer(self._to_block))  # type: ignore
+            to_block = BlockNumber(hex_to_integer(self._to_block))
         else:
             to_block = self._to_block
 
@@ -352,7 +359,8 @@ def block_hashes_in_range(
 async def async_iter_latest_block(
     w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> AsyncIterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -390,7 +398,8 @@ async def async_iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `from_block` to the latest mined block,
     until reaching to_block. e.g.:
@@ -423,7 +432,8 @@ async def async_get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> AsyncIterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.

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")