intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/skills/xmtp/schema.json

@@ -1,75 +1,73 @@
 {
-    "$schema": "http://json-schema.org/draft-07/schema#",
-    "type": "object",
-    "title": "XMTP",
-    "description": "Use this skill only if you want make an XMTP Agent. XMTP protocol skills for creating blockchain transaction requests that can be sent to users for signing",
-    "x-icon": "https://ai.service.crestal.dev/skills/xmtp/xmtp.png",
-    "x-tags": [
-        "XMTP",
-        "Blockchain",
-        "Transactions",
-        "Web3",
-        "Base"
-    ],
-    "properties": {
-        "enabled": {
-            "type": "boolean",
-            "title": "Enabled",
-            "description": "Whether this skill is enabled",
-            "default": false
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "XMTP",
+  "description": "Use this skill only if you want make an XMTP Agent. XMTP protocol skills for creating blockchain transaction requests that can be sent to users for signing",
+  "x-icon": "https://ai.service.crestal.dev/skills/xmtp/xmtp.png",
+  "x-tags": [
+    "Communication",
+    "Crypto",
+    "DeFi"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "xmtp_transfer": {
+          "type": "string",
+          "title": "XMTP Transfer",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Create XMTP transaction requests for transferring ETH or ERC20 tokens on Base mainnet. Supports both native ETH transfers and ERC20 token transfers. Generates wallet_sendCalls transaction data that users can sign.",
+          "default": "disabled"
         },
-        "states": {
-            "type": "object",
-            "properties": {
-                "xmtp_transfer": {
-                    "type": "string",
-                    "title": "XMTP Transfer",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Create XMTP transaction requests for transferring ETH or ERC20 tokens on Base mainnet. Supports both native ETH transfers and ERC20 token transfers. Generates wallet_sendCalls transaction data that users can sign.",
-                    "default": "disabled"
-                },
-                "xmtp_swap": {
-                    "type": "string",
-                    "title": "XMTP Swap",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Create XMTP transaction requests for swapping tokens on Base using CDP swap quote. Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. Only supports base-mainnet and base-sepolia.",
-                    "default": "disabled"
-                },
-                "xmtp_get_swap_price": {
-                    "type": "string",
-                    "title": "XMTP Get Swap Price",
-                    "enum": [
-                        "disabled",
-                        "public",
-                        "private"
-                    ],
-                    "x-enum-title": [
-                        "Disabled",
-                        "Agent Owner + All Users",
-                        "Agent Owner Only"
-                    ],
-                    "description": "Get an indicative swap price/quote for token pair and amount on Base networks using CDP. Provides estimated output amounts for token swaps without creating transactions.",
-                    "default": "disabled"
-                }
-            }
+        "xmtp_swap": {
+          "type": "string",
+          "title": "XMTP Swap",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Create XMTP transaction requests for swapping tokens on Base using CDP swap quote. Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. Only supports base-mainnet and base-sepolia.",
+          "default": "disabled"
+        },
+        "xmtp_get_swap_price": {
+          "type": "string",
+          "title": "XMTP Get Swap Price",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get an indicative swap price/quote for token pair and amount on Base networks using CDP. Provides estimated output amounts for token swaps without creating transactions.",
+          "default": "disabled"
         }
+      }
     }
-}
+  }
+}

intentkit/skills/xmtp/swap.py

@@ -1,8 +1,6 @@
-from typing import List, Tuple, Type
-
 from pydantic import BaseModel, Field
 
-from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.clients.cdp import get_cdp_client
 from intentkit.models.chat import ChatMessageAttachment, ChatMessageAttachmentType
 from intentkit.skills.xmtp.base import XmtpBaseTool
 
@@ -42,7 +40,7 @@ class XmtpSwap(XmtpBaseTool):
         "Returns a wallet_sendCalls payload that can include an optional approval call and the swap call. "
         "Supports Ethereum, Base, Arbitrum, and Optimism mainnet networks."
     )
-    args_schema: Type[BaseModel] = SwapInput
+    args_schema: type[BaseModel] = SwapInput
 
     async def _arun(
         self,
@@ -51,7 +49,7 @@ class XmtpSwap(XmtpBaseTool):
         to_token: str,
         from_amount: str,
         slippage_bps: int = 100,
-    ) -> Tuple[str, List[ChatMessageAttachment]]:
+    ) -> tuple[str, list[ChatMessageAttachment]]:
         # Input validation
         if (
             not from_address
@@ -107,15 +105,15 @@ class XmtpSwap(XmtpBaseTool):
         # https://github.com/coinbase/cdp-sdk/blob/main/examples/python/evm/swaps/create_swap_quote.py
         network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        # Get CDP client from global origin helper (server-side credentials)
-        cdp_client = get_origin_cdp_client(self.skill_store)
+        # Get CDP client from the global helper (server-side credentials)
+        cdp_client = get_cdp_client()
 
         # Call CDP to create swap quote and extract call datas
         # Be permissive with response shape across SDK versions
         try:
             # Attempt the canonical method per CDP SDK examples
             # create_swap_quote(from_token, to_token, from_amount, network, taker, slippage_bps, signer_address)
-            # Note: Don't use async with context manager as get_origin_cdp_client returns a managed global client
+            # Note: Don't use async with context manager as get_cdp_client returns a managed global client
             quote = await cdp_client.evm.create_swap_quote(
                 from_token=from_token,
                 to_token=to_token,

intentkit/skills/xmtp/transfer.py

@@ -1,5 +1,3 @@
-from typing import List, Optional, Tuple, Type
-
 from pydantic import BaseModel, Field
 from web3.exceptions import ContractLogicError
 
@@ -16,7 +14,7 @@ class TransferInput(BaseModel):
         description="The amount to transfer in human-readable format (e.g., '1.5' for 1.5 ETH, '100' for 100 USDC). Do NOT multiply by token decimals."
     )
     currency: str = Field(description="Currency symbol (e.g., 'ETH', 'USDC', 'NATION')")
-    token_contract_address: Optional[str] = Field(
+    token_contract_address: str | None = Field(
         default=None,
         description="Token contract address for ERC20 transfers. Leave empty for ETH transfers.",
     )
@@ -31,7 +29,7 @@ class XmtpTransfer(XmtpBaseTool):
     that can be sent to users for signing. 
     Supports Ethereum, Polygon, Base, Arbitrum, and Optimism networks (both mainnet and testnet).
     """
-    args_schema: Type[BaseModel] = TransferInput
+    args_schema: type[BaseModel] = TransferInput
 
     async def _arun(
         self,
@@ -39,8 +37,8 @@ class XmtpTransfer(XmtpBaseTool):
         to_address: str,
         amount: str,
         currency: str,
-        token_contract_address: Optional[str],
-    ) -> Tuple[str, List[ChatMessageAttachment]]:
+        token_contract_address: str | None,
+    ) -> tuple[str, list[ChatMessageAttachment]]:
         """Create an XMTP transfer transaction request.
 
         Args:

intentkit/utils/__init__.py

@@ -1 +1,5 @@
+"""Utility exports for IntentKit."""
 
+from intentkit.utils.ens import resolve_ens_to_address
+
+__all__ = ["resolve_ens_to_address"]

intentkit/utils/chain.py

@@ -1,8 +1,11 @@
+import logging
 from abc import ABC, abstractmethod
 from enum import IntEnum, StrEnum
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
 
 class Chain(StrEnum):
     """
@@ -54,7 +57,7 @@ class Chain(StrEnum):
     Frontera = "frontera"
 
 
-class Network(StrEnum):
+class QuickNodeNetwork(StrEnum):
     """
     Enum of well-known blockchain network names, based on QuickNode API.
 
@@ -65,9 +68,9 @@ class Network(StrEnum):
     """
 
     # Ethereum Mainnet and Testnets
-    EthereumMainnet = "ethereum-mainnet"
-    EthereumGoerli = "ethereum-goerli"  # Goerli Testnet (deprecated, Sepolia preferred)
-    EthereumSepolia = "ethereum-sepolia"
+    EthereumMainnet = "mainnet"
+    EthereumGoerli = "goerli"  # Goerli Testnet (deprecated, Sepolia preferred)
+    EthereumSepolia = "sepolia"
 
     # Layer 2s on Ethereum
     ArbitrumMainnet = "arbitrum-mainnet"
@@ -150,51 +153,123 @@ class NetworkId(IntEnum):
     BeraMainnet = 80094
 
 
-# Mapping of Network enum members to their corresponding NetworkId enum members.
+# Mapping of QuickNodeNetwork enum members to their corresponding NetworkId enum members.
 # This dictionary facilitates efficient lookup of network IDs given a network name.
 # Note: SolanaMainnet is intentionally excluded as it does not have a numeric chain ID.
 #       Always refer to the official documentation for the most up-to-date mappings.
-network_to_id: dict[Network, NetworkId] = {
-    Network.ArbitrumMainnet: NetworkId.ArbitrumMainnet,
-    Network.AvalancheMainnet: NetworkId.AvalancheMainnet,
-    Network.BaseMainnet: NetworkId.BaseMainnet,
-    Network.BaseSepolia: NetworkId.BaseSepolia,
-    Network.BeraMainnet: NetworkId.BeraMainnet,
-    Network.BinanceMainnet: NetworkId.BinanceMainnet,
-    Network.EthereumMainnet: NetworkId.EthereumMainnet,
-    Network.EthereumSepolia: NetworkId.EthereumSepolia,
-    Network.GnosisMainnet: NetworkId.GnosisMainnet,
-    Network.LineaMainnet: NetworkId.LineaMainnet,
-    Network.OptimismMainnet: NetworkId.OptimismMainnet,
-    Network.PolygonMainnet: NetworkId.PolygonMainnet,
-    Network.SonicMainnet: NetworkId.SonicMainnet,
-    Network.ZkSyncMainnet: NetworkId.ZkSyncMainnet,
+network_to_id: dict[QuickNodeNetwork, NetworkId] = {
+    QuickNodeNetwork.ArbitrumMainnet: NetworkId.ArbitrumMainnet,
+    QuickNodeNetwork.AvalancheMainnet: NetworkId.AvalancheMainnet,
+    QuickNodeNetwork.BaseMainnet: NetworkId.BaseMainnet,
+    QuickNodeNetwork.BaseSepolia: NetworkId.BaseSepolia,
+    QuickNodeNetwork.BeraMainnet: NetworkId.BeraMainnet,
+    QuickNodeNetwork.BinanceMainnet: NetworkId.BinanceMainnet,
+    QuickNodeNetwork.EthereumMainnet: NetworkId.EthereumMainnet,
+    QuickNodeNetwork.EthereumSepolia: NetworkId.EthereumSepolia,
+    QuickNodeNetwork.GnosisMainnet: NetworkId.GnosisMainnet,
+    QuickNodeNetwork.LineaMainnet: NetworkId.LineaMainnet,
+    QuickNodeNetwork.OptimismMainnet: NetworkId.OptimismMainnet,
+    QuickNodeNetwork.PolygonMainnet: NetworkId.PolygonMainnet,
+    QuickNodeNetwork.SonicMainnet: NetworkId.SonicMainnet,
+    QuickNodeNetwork.ZkSyncMainnet: NetworkId.ZkSyncMainnet,
 }
 
 # Mapping of NetworkId enum members (chain IDs) to their corresponding
-# Network enum members (network names). This dictionary allows for reverse
+# QuickNodeNetwork enum members (network names). This dictionary allows for reverse
 # lookup, enabling retrieval of the network name given a chain ID.
 # Note:  Solana is not included here as it does not use a standard numeric
 #       chain ID.  Always consult official documentation for the most
 #       up-to-date mappings.
-id_to_network: dict[NetworkId, Network] = {
-    NetworkId.ArbitrumMainnet: Network.ArbitrumMainnet,
-    NetworkId.AvalancheMainnet: Network.AvalancheMainnet,
-    NetworkId.BaseMainnet: Network.BaseMainnet,
-    NetworkId.BaseSepolia: Network.BaseSepolia,
-    NetworkId.BeraMainnet: Network.BeraMainnet,
-    NetworkId.BinanceMainnet: Network.BinanceMainnet,
-    NetworkId.EthereumMainnet: Network.EthereumMainnet,
-    NetworkId.EthereumSepolia: Network.EthereumSepolia,
-    NetworkId.GnosisMainnet: Network.GnosisMainnet,
-    NetworkId.LineaMainnet: Network.LineaMainnet,
-    NetworkId.OptimismMainnet: Network.OptimismMainnet,
-    NetworkId.PolygonMainnet: Network.PolygonMainnet,
-    NetworkId.SonicMainnet: Network.SonicMainnet,
-    NetworkId.ZkSyncMainnet: Network.ZkSyncMainnet,
+id_to_network: dict[NetworkId, QuickNodeNetwork] = {
+    NetworkId.ArbitrumMainnet: QuickNodeNetwork.ArbitrumMainnet,
+    NetworkId.AvalancheMainnet: QuickNodeNetwork.AvalancheMainnet,
+    NetworkId.BaseMainnet: QuickNodeNetwork.BaseMainnet,
+    NetworkId.BaseSepolia: QuickNodeNetwork.BaseSepolia,
+    NetworkId.BeraMainnet: QuickNodeNetwork.BeraMainnet,
+    NetworkId.BinanceMainnet: QuickNodeNetwork.BinanceMainnet,
+    NetworkId.EthereumMainnet: QuickNodeNetwork.EthereumMainnet,
+    NetworkId.EthereumSepolia: QuickNodeNetwork.EthereumSepolia,
+    NetworkId.GnosisMainnet: QuickNodeNetwork.GnosisMainnet,
+    NetworkId.LineaMainnet: QuickNodeNetwork.LineaMainnet,
+    NetworkId.OptimismMainnet: QuickNodeNetwork.OptimismMainnet,
+    NetworkId.PolygonMainnet: QuickNodeNetwork.PolygonMainnet,
+    NetworkId.SonicMainnet: QuickNodeNetwork.SonicMainnet,
+    NetworkId.ZkSyncMainnet: QuickNodeNetwork.ZkSyncMainnet,
+}
+
+# Mapping of agent-level network identifiers to QuickNode network names.
+# Agent configuration often uses human-friendly identifiers such as
+# "ethereum-mainnet" or "solana" while QuickNode expects the canonical
+# network strings defined in `QuickNodeNetwork`.  This mapping bridges the two.
+AGENT_NETWORK_TO_QUICKNODE_NETWORK: dict[str, QuickNodeNetwork] = {
+    "arbitrum-mainnet": QuickNodeNetwork.ArbitrumMainnet,
+    "avalanche-mainnet": QuickNodeNetwork.AvalancheMainnet,
+    "aurora-mainnet": QuickNodeNetwork.AuroraMainnet,
+    "axelar-mainnet": QuickNodeNetwork.AxelarMainnet,
+    "base-mainnet": QuickNodeNetwork.BaseMainnet,
+    "base-sepolia": QuickNodeNetwork.BaseSepolia,
+    "bera-mainnet": QuickNodeNetwork.BeraMainnet,
+    "binance-mainnet": QuickNodeNetwork.BinanceMainnet,
+    "bsc-mainnet": QuickNodeNetwork.BinanceMainnet,
+    "celo-mainnet": QuickNodeNetwork.CeloMainnet,
+    "ethereum": QuickNodeNetwork.EthereumMainnet,
+    "ethereum-mainnet": QuickNodeNetwork.EthereumMainnet,
+    "ethereum-sepolia": QuickNodeNetwork.EthereumSepolia,
+    "evmos-mainnet": QuickNodeNetwork.EvmosMainnet,
+    "fantom-mainnet": QuickNodeNetwork.FantomMainnet,
+    "frontera-mainnet": QuickNodeNetwork.FronteraMainnet,
+    "gnosis": QuickNodeNetwork.GnosisMainnet,
+    "gnosis-mainnet": QuickNodeNetwork.GnosisMainnet,
+    "goerli": QuickNodeNetwork.EthereumGoerli,
+    "kava-mainnet": QuickNodeNetwork.KavaMainnet,
+    "linea-mainnet": QuickNodeNetwork.LineaMainnet,
+    "matic": QuickNodeNetwork.PolygonMainnet,
+    "matic-mainnet": QuickNodeNetwork.PolygonMainnet,
+    "moonbeam-mainnet": QuickNodeNetwork.MoonbeamMainnet,
+    "near-mainnet": QuickNodeNetwork.NearMainnet,
+    "optimism-mainnet": QuickNodeNetwork.OptimismMainnet,
+    "persistence-mainnet": QuickNodeNetwork.PersistenceMainnet,
+    "polygon": QuickNodeNetwork.PolygonMainnet,
+    "polygon-mainnet": QuickNodeNetwork.PolygonMainnet,
+    "secret-mainnet": QuickNodeNetwork.SecretMainnet,
+    "sepolia": QuickNodeNetwork.EthereumSepolia,
+    "solana": QuickNodeNetwork.SolanaMainnet,
+    "solana-mainnet": QuickNodeNetwork.SolanaMainnet,
+    "sonic-mainnet": QuickNodeNetwork.SonicMainnet,
+    "stargaze-mainnet": QuickNodeNetwork.StargazeMainnet,
+    "terra-mainnet": QuickNodeNetwork.TerraMainnet,
+    "xdai": QuickNodeNetwork.GnosisMainnet,
+    "zksync-mainnet": QuickNodeNetwork.ZkSyncMainnet,
 }
 
 
+def resolve_quicknode_network(agent_network_id: str) -> QuickNodeNetwork:
+    """Resolve an agent-level network identifier to a QuickNode network.
+
+    Args:
+        agent_network_id: Network identifier stored on the agent model.
+
+    Returns:
+        The corresponding `QuickNodeNetwork` enum value.
+
+    Raises:
+        ValueError: If the agent network identifier is empty or unmapped.
+    """
+
+    normalized = (agent_network_id or "").strip().lower()
+    if not normalized:
+        raise ValueError("agent network_id must be provided")
+
+    mapped_network = AGENT_NETWORK_TO_QUICKNODE_NETWORK.get(normalized)
+    if mapped_network:
+        return mapped_network
+
+    try:
+        return QuickNodeNetwork(normalized)
+    except ValueError as exc:  # pragma: no cover - defensive guard
+        raise ValueError(f"unsupported agent network_id: {agent_network_id}") from exc
+
+
 class ChainConfig:
     """
     Configuration class for a specific blockchain chain.
@@ -206,7 +281,7 @@ class ChainConfig:
     def __init__(
         self,
         chain: Chain,
-        network: Network,
+        network: QuickNodeNetwork,
         rpc_url: str,
         ens_url: str,
         wss_url: str,
@@ -216,7 +291,7 @@ class ChainConfig:
 
         Args:
             chain: The Chain enum member representing the blockchain type (e.g., Ethereum, Solana).
-            network: The Network enum member representing the specific network (e.g., EthereumMainnet).
+            network: The QuickNodeNetwork enum member representing the specific network (e.g., EthereumMainnet).
             rpc_url: The URL for the RPC endpoint of the blockchain.
             ens_url: The URL for the ENS (Ethereum Name Service) endpoint (can be None if not applicable).
             wss_url: The URL for the WebSocket endpoint of the blockchain (can be None if not applicable).
@@ -236,9 +311,9 @@ class ChainConfig:
         return self._chain
 
     @property
-    def network(self) -> Network:
+    def network(self) -> QuickNodeNetwork:
         """
-        Returns the Network enum member.
+        Returns the QuickNodeNetwork enum member.
         """
         return self._network
 
@@ -287,14 +362,14 @@ class ChainProvider(ABC):
 
         Sets up an empty dictionary `chain_configs` to store the configurations.
         """
-        self.chain_configs: dict[Network, ChainConfig] = {}
+        self.chain_configs: dict[QuickNodeNetwork, ChainConfig] = {}
 
-    def get_chain_config(self, network: Network) -> ChainConfig:
+    def get_chain_config(self, network_id: str) -> ChainConfig:
         """
-        Retrieves the chain configuration for a specific network.
+        Retrieves the chain configuration for a specific agent network identifier.
 
         Args:
-            network: The `Network` enum member representing the desired network.
+            network_id: The agent-level network identifier (e.g., "base-mainnet").
 
         Returns:
             The `ChainConfig` object associated with the given network.
@@ -302,17 +377,27 @@ class ChainProvider(ABC):
         Raises:
             Exception: If no chain configuration is found for the specified network.
         """
-        chain_config = self.chain_configs.get(network)
+        try:
+            quicknode_network = resolve_quicknode_network(network_id)
+        except ValueError as exc:
+            raise Exception(f"unsupported network_id: {network_id}") from exc
+
+        return self._get_chain_config_by_quicknode_network(quicknode_network)
+
+    def _get_chain_config_by_quicknode_network(
+        self, quicknode_network: QuickNodeNetwork
+    ) -> ChainConfig:
+        chain_config = self.chain_configs.get(quicknode_network)
         if not chain_config:
-            raise Exception(f"chain config for network {network} not found")
+            raise Exception(f"chain config for network {quicknode_network} not found")
         return chain_config
 
     def get_chain_config_by_id(self, network_id: NetworkId) -> ChainConfig:
         """
         Retrieves the chain configuration by network ID.
 
-        This method first looks up the `Network` enum member associated with the
-        provided `NetworkId` and then uses `get_chain_config` to retrieve the
+        This method first looks up the `QuickNodeNetwork` enum member associated
+        with the provided `NetworkId` and then retrieves the corresponding
         configuration.
 
         Args:
@@ -328,10 +413,10 @@ class ChainProvider(ABC):
         network = id_to_network.get(network_id)
         if not network:
             raise Exception(f"network with id {network_id} not found")
-        return self.get_chain_config(network)
+        return self._get_chain_config_by_quicknode_network(network)
 
     @abstractmethod
-    def init_chain_configs(self, api_key: str) -> dict[Network, ChainConfig]:
+    def init_chain_configs(self, *_, **__) -> None:
         """
         Initializes the chain configurations.
 
@@ -340,11 +425,8 @@ class ChainProvider(ABC):
         `ChainConfig` objects, typically using the provided `api_key` to fetch
         or generate the necessary configuration data.
 
-        Args:
-            api_key: The API key used for initializing chain configurations.
-
-        Returns:
-            A dictionary mapping `Network` enum members to `ChainConfig` objects.
+        The method must mutate `self.chain_configs` in-place and does not need
+        to return anything.
         """
         raise NotImplementedError
 
@@ -367,27 +449,18 @@ class QuicknodeChainProvider(ChainProvider):
         super().__init__()
         self.api_key = api_key
 
-    def init_chain_configs(
-        self, limit: int = 100, offset: int = 0
-    ) -> dict[Network, ChainConfig]:
+    def init_chain_configs(self, limit: int = 100, offset: int = 0) -> None:
         """
         Initializes chain configurations by fetching data from the QuickNode API.
 
         This method retrieves a list of QuickNode endpoints using the provided
         API key and populates the `chain_configs` dictionary with `ChainConfig`
-        objects.
+        objects.  Errors are logged and do not raise exceptions so that any
+        successful configurations remain available.
 
         Args:
             limit: The maximum number of endpoints to retrieve (default: 100).
             offset: The number of endpoints to skip (default: 0).
-
-        Returns:
-            A dictionary mapping `Network` enum members to `ChainConfig` objects.
-
-        Raises:
-            Exception: If an error occurs during the API request or processing
-                       the response.  More specific exception types are used
-                       for HTTP errors and request errors.
         """
         url = "https://api.quicknode.com/v0/endpoints"
         headers = {
@@ -399,38 +472,67 @@ class QuicknodeChainProvider(ChainProvider):
             "offset": offset,
         }
 
-        with httpx.Client(timeout=30) as client:  # Set a timeout for the request
+        with httpx.Client(timeout=30) as client:
             try:
                 response = client.get(url, timeout=30, headers=headers, params=params)
-                response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+                response.raise_for_status()
                 json_dict = response.json()
-
-                for item in json_dict["data"]:
-                    # Assuming 'item' contains 'chain', 'network', 'http_url', 'wss_url'
-                    # and that these values can be used to construct the ChainConfig object
-                    chain = Chain(item["chain"])
-                    network = Network(item["network"])
-
-                    self.chain_configs[item["network"]] = ChainConfig(
-                        chain,
-                        network,
-                        item["http_url"],
-                        item[
-                            "http_url"
-                        ],  # ens_url is the same as http_url in this case.
-                        item["wss_url"],
-                    )
-
             except httpx.HTTPStatusError as http_err:
-                raise Exception(f"Quicknode API HTTP Error: {http_err}")
+                logger.error(
+                    "QuickNode API HTTP error while initializing chain configs: %s",
+                    http_err,
+                )
+                return
             except httpx.RequestError as req_err:
-                raise Exception(f"Quicknode API Request Error: {req_err}")
-            except (
-                KeyError,
-                TypeError,
-            ) as e:  # Handle potential data issues in the API response
-                raise Exception(
-                    f"Error processing QuickNode API response: {e}. Check the API response format."
+                logger.error(
+                    "QuickNode API request error while initializing chain configs: %s",
+                    req_err,
+                )
+                return
+            except Exception as exc:
+                logger.exception(
+                    "Unexpected error while fetching QuickNode chain configs: %s", exc
+                )
+                return
+
+        data = json_dict.get("data", [])
+        if not isinstance(data, list):
+            logger.error(
+                "QuickNode chain configs response 'data' is not a list: %s", data
+            )
+            return
+
+        for item in data:
+            if not isinstance(item, dict):
+                logger.error("Skipping malformed QuickNode chain entry: %s", item)
+                continue
+
+            try:
+                chain_value = item["chain"]
+                network_value = item["network"]
+                rpc_url = item["http_url"]
+                chain = Chain(chain_value)
+                network = QuickNodeNetwork(network_value)
+                ens_url = item.get("ens_url", rpc_url)
+                wss_url = item.get("wss_url")
+            except ValueError as exc:
+                logger.debug("Skipping unsupported QuickNode entry %s: %s", item, exc)
+                continue
+            except KeyError as exc:
+                logger.error(
+                    "Missing field %s in QuickNode chain config item %s", exc, item
+                )
+                continue
+            except Exception as exc:
+                logger.error(
+                    "Failed processing QuickNode chain config item %s: %s", item, exc
                 )
-            except Exception as e:
-                raise Exception(f"Quicknode API An unexpected error occurred: {e}")
+                continue
+
+            self.chain_configs[network] = ChainConfig(
+                chain,
+                network,
+                rpc_url,
+                ens_url,
+                wss_url,
+            )