@agentlayer.tech/wallet 0.1.28 → 0.1.30

package/agent-wallet/agent_wallet/config.py

@@ -82,6 +82,79 @@ class Settings(BaseSettings):
 settings = Settings()
 
 
+def normalize_solana_network(network: str | None) -> str:
+    """Canonicalize supported Solana network names and reject test clusters."""
+    normalized = str(network or "").strip().lower() or "mainnet"
+    aliases = {
+        "mainnet-beta": "mainnet",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"devnet", "testnet"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "Solana devnet/testnet are no longer supported by agent-wallet. "
+            "Use mainnet or remove the Solana network override."
+        )
+    if normalized != "mainnet":
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported Solana network: {normalized}. Only mainnet is supported."
+        )
+    return "mainnet"
+
+
+def normalize_evm_network(network: str | None) -> str:
+    """Canonicalize supported EVM network names and reject testnets."""
+    normalized = str(network or "").strip().lower() or "ethereum"
+    aliases = {
+        "mainnet": "ethereum",
+        "eth": "ethereum",
+        "eth-mainnet": "ethereum",
+        "base-mainnet": "base",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"sepolia", "base-sepolia", "base_sepolia"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "EVM testnets are no longer supported by agent-wallet. Use ethereum or base."
+        )
+    if normalized not in {"ethereum", "base"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported EVM network: {normalized}. Use ethereum or base."
+        )
+    return normalized
+
+
+def normalize_btc_network(network: str | None) -> str:
+    """Canonicalize supported BTC network names and reject non-mainnet chains."""
+    normalized = str(network or "").strip().lower() or "bitcoin"
+    aliases = {
+        "mainnet": "bitcoin",
+        "btc": "bitcoin",
+        "bitcoin-mainnet": "bitcoin",
+        "bitcoin_mainnet": "bitcoin",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"testnet", "regtest"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "Bitcoin testnet/regtest are no longer supported by agent-wallet. Use bitcoin."
+        )
+    if normalized != "bitcoin":
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported Bitcoin network: {normalized}. Only bitcoin is supported."
+        )
+    return "bitcoin"
+
+
 def _normalize_provider_mode(value: str | None) -> str:
     mode = (value or "").strip().lower()
     if not mode:
@@ -129,20 +202,20 @@ def resolve_openclaw_home() -> Path:
 
 def default_solana_wallet_path(network: str) -> Path:
     """Return the default keypair path for a Solana wallet."""
-    return resolve_openclaw_home() / "wallets" / f"solana-{network}-agent.json"
+    normalized_network = normalize_solana_network(network)
+    return resolve_openclaw_home() / "wallets" / f"solana-{normalized_network}-agent.json"
 
 
 def resolve_solana_rpc_url(network: str, configured: str) -> str:
     """Resolve the effective Solana RPC URL from network + optional override."""
+    normalized_network = normalize_solana_network(network)
     if configured.strip():
         return configured.strip()
 
     mapping = {
         "mainnet": "https://api.mainnet-beta.solana.com",
-        "devnet": "https://api.devnet.solana.com",
-        "testnet": "https://api.testnet.solana.com",
     }
-    return mapping.get(network.strip().lower(), mapping["mainnet"])
+    return mapping.get(normalized_network, mapping["mainnet"])
 
 
 def resolve_solana_rpc_urls(
@@ -151,17 +224,18 @@ def resolve_solana_rpc_urls(
     configured_list: str = "",
 ) -> list[str]:
     """Resolve the ordered list of Solana RPC URLs to try."""
+    normalized_network = normalize_solana_network(network)
     candidates: list[str] = []
     for raw in (configured_list or "").split(","):
         value = raw.strip()
         if value and value not in candidates:
             candidates.append(value)
 
-    primary = resolve_solana_rpc_url(network, configured)
+    primary = resolve_solana_rpc_url(normalized_network, configured)
     if primary and primary not in candidates:
         candidates.insert(0, primary)
 
-    official = resolve_solana_rpc_url(network, "")
+    official = resolve_solana_rpc_url(normalized_network, "")
     if official and official not in candidates:
         candidates.append(official)
 
@@ -169,7 +243,8 @@ def resolve_solana_rpc_urls(
 
 
 def _build_provider_gateway_rpc_url(base_url: str, provider: str, network: str) -> str:
-    return f"gateway::{provider}::{network.strip().lower()}::{base_url.rstrip('/')}/v1/rpc"
+    normalized_network = normalize_solana_network(network)
+    return f"gateway::{provider}::{normalized_network}::{base_url.rstrip('/')}/v1/rpc"
 
 
 def resolve_runtime_solana_rpc_config(
@@ -185,6 +260,7 @@ def resolve_runtime_solana_rpc_config(
     3. shared proxy gateway
     4. public official fallback
     """
+    normalized_network = normalize_solana_network(network)
     mode = _normalize_provider_mode(
         os.getenv("SOLANA_RPC_PROVIDER_MODE", settings.solana_rpc_provider_mode)
     )
@@ -200,10 +276,10 @@ def resolve_runtime_solana_rpc_config(
             "mode": "user_direct",
             "provider": "custom",
             "transport": "direct",
-            "rpc_urls": resolve_solana_rpc_urls(network, env_primary, env_list),
+            "rpc_urls": resolve_solana_rpc_urls(normalized_network, env_primary, env_list),
         }
     if env_list:
-        official = resolve_solana_rpc_url(network, "")
+        official = resolve_solana_rpc_url(normalized_network, "")
         candidates = [item.strip() for item in env_list.split(",") if item.strip()]
         if official and official not in candidates:
             candidates.append(official)
@@ -218,16 +294,15 @@ def resolve_runtime_solana_rpc_config(
     if alchemy_key:
         alchemy_base_by_network = {
             "mainnet": "https://solana-mainnet.g.alchemy.com/v2",
-            "devnet": "https://solana-devnet.g.alchemy.com/v2",
         }
-        alchemy_base = alchemy_base_by_network.get(network.strip().lower())
+        alchemy_base = alchemy_base_by_network.get(normalized_network)
         if alchemy_base:
             return {
                 "mode": "user_direct",
                 "provider": "alchemy",
                 "transport": "direct",
                 "rpc_urls": resolve_solana_rpc_urls(
-                    network,
+                    normalized_network,
                     f"{alchemy_base}/{alchemy_key}",
                     "",
                 ),
@@ -237,35 +312,40 @@ def resolve_runtime_solana_rpc_config(
     if helius_key:
         helius_base_by_network = {
             "mainnet": "https://mainnet.helius-rpc.com/",
-            "devnet": "https://devnet.helius-rpc.com/",
         }
-        helius_base = helius_base_by_network.get(network.strip().lower())
+        helius_base = helius_base_by_network.get(normalized_network)
         if helius_base:
             return {
                 "mode": "user_direct",
                 "provider": "helius",
                 "transport": "direct",
                 "rpc_urls": resolve_solana_rpc_urls(
-                    network,
+                    normalized_network,
                     f"{helius_base}?api-key={helius_key}",
                     "",
                 ),
             }
 
-    if network.strip().lower() == "mainnet" and (mode == "shared_proxy" or (mode == "auto" and gateway_url)):
+    if normalized_network == "mainnet" and (mode == "shared_proxy" or (mode == "auto" and gateway_url)):
         if gateway_url:
             return {
                 "mode": "shared_proxy",
                 "provider": gateway_provider,
                 "transport": "proxy",
-                "rpc_urls": [_build_provider_gateway_rpc_url(gateway_url, gateway_provider, network)],
+                "rpc_urls": [
+                    _build_provider_gateway_rpc_url(
+                        gateway_url,
+                        gateway_provider,
+                        normalized_network,
+                    )
+                ],
             }
 
     return {
         "mode": "public_fallback",
         "provider": "official",
         "transport": "direct",
-        "rpc_urls": resolve_solana_rpc_urls(network, configured, configured_list),
+        "rpc_urls": resolve_solana_rpc_urls(normalized_network, configured, configured_list),
     }
 
 
@@ -289,10 +369,7 @@ def resolve_runtime_solana_swap_config(network: str) -> dict[str, str]:
     requested = _normalize_swap_provider(
         os.getenv("SOLANA_SWAP_PROVIDER", settings.solana_swap_provider)
     )
-    normalized_network = network.strip().lower()
-
-    if normalized_network != "mainnet":
-        return {"provider": "jupiter", "transport": "direct"}
+    normalize_solana_network(network)
 
     if requested == "jupiter":
         return {"provider": "jupiter", "transport": "direct"}

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -14,6 +14,7 @@ from urllib.parse import urlparse
 from urllib.request import urlopen
 
 from agent_wallet.config import (
+    normalize_evm_network,
     resolve_boot_key,
     resolve_evm_wallet_password,
     resolve_openclaw_home,
@@ -27,18 +28,7 @@ LOCAL_WDK_EVM_HOSTS = {"127.0.0.1", "localhost", "::1"}
 
 
 def _normalize_evm_network(value: str | None) -> str:
-    network = str(value or "").strip().lower()
-    aliases = {
-        "mainnet": "ethereum",
-        "eth": "ethereum",
-        "eth-mainnet": "ethereum",
-        "base-mainnet": "base",
-        "base_sepolia": "base-sepolia",
-    }
-    network = aliases.get(network, network)
-    if network not in {"ethereum", "sepolia", "base", "base-sepolia"}:
-        return "ethereum"
-    return network
+    return normalize_evm_network(value)
 
 
 def _resolve_service_url(service_url: str | None = None) -> str:
@@ -52,8 +42,6 @@ def _paired_network(network: str) -> str | None:
     mapping = {
         "ethereum": "base",
         "base": "ethereum",
-        "sepolia": "base-sepolia",
-        "base-sepolia": "sepolia",
     }
     return mapping.get(_normalize_evm_network(network))
 

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -101,9 +101,10 @@ class OpenClawWalletAdapter:
             "eth": "ethereum",
             "eth-mainnet": "ethereum",
             "base-mainnet": "base",
-            "base_sepolia": "base-sepolia",
         }
         network = aliases.get(network, network)
+        if network in {"sepolia", "base-sepolia", "base_sepolia"}:
+            raise WalletBackendError("EVM testnets are no longer supported. Use ethereum or base.")
         if network not in {"ethereum", "base"}:
             raise WalletBackendError("EVM network must be 'ethereum' or 'base'.")
         return network
@@ -2314,6 +2315,25 @@ class OpenClawWalletAdapter:
                 read_only=True,
                 risk_level="low",
             ),
+            AgentToolSpec(
+                name="get_kamino_open_positions",
+                description=(
+                    "Get all open Kamino lending positions for a Solana wallet on mainnet, "
+                    "aggregated across markets with loan details, reserve APYs, and rewards."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "user": {
+                            "type": "string",
+                            "description": "Optional Solana wallet address override. If omitted, use the configured wallet.",
+                        },
+                    },
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
         ]
 
         if capabilities.can_sign_message:
@@ -3221,30 +3241,6 @@ class OpenClawWalletAdapter:
                 )
             )
 
-            tools.append(
-                AgentToolSpec(
-                    name="request_devnet_airdrop",
-                    description=(
-                        "Request SOL from the Solana faucet on devnet or testnet. "
-                        "Only available outside mainnet."
-                    ),
-                    input_schema={
-                        "type": "object",
-                        "properties": {
-                            "amount": {
-                                "type": "number",
-                                "description": "Amount of SOL to request from faucet.",
-                            }
-                        },
-                        "required": ["amount"],
-                        "additionalProperties": False,
-                    },
-                    read_only=False,
-                    requires_explicit_user_intent=True,
-                    risk_level="low",
-                )
-            )
-
         tools.extend(self._x402_tool_specs())
         return [tool for tool in tools if tool.name not in TEMPORARILY_DISABLED_TOOLS]
 
@@ -4637,6 +4633,13 @@ class OpenClawWalletAdapter:
                 data = await self.backend.get_kamino_lend_user_rewards(user=user)
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
+            if tool_name == "get_kamino_open_positions":
+                user = args.get("user")
+                if user is not None and not isinstance(user, str):
+                    raise WalletBackendError("user must be a string when provided.")
+                data = await self.backend.get_kamino_open_positions(user=user)
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
             if tool_name == "sign_wallet_message":
                 user_confirmed = args.get("user_confirmed")
                 if user_confirmed is not True:
@@ -5199,13 +5202,6 @@ class OpenClawWalletAdapter:
                     ),
                 )
 
-            if tool_name == "request_devnet_airdrop":
-                amount = args.get("amount")
-                if not isinstance(amount, (int, float)) or amount <= 0:
-                    raise WalletBackendError("amount must be a positive number.")
-                result = await self.backend.request_testnet_airdrop(float(amount))
-                return AgentToolResult(tool=tool_name, ok=True, data=result)
-
             if tool_name == "transfer_spl_token":
                 recipient = args.get("recipient")
                 mint = args.get("mint")

package/agent-wallet/agent_wallet/openclaw_runtime.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from agent_wallet.approval import issue_approval_token
 from agent_wallet.btc_user_wallets import get_user_btc_wallet_binding
-from agent_wallet.config import settings
+from agent_wallet.config import normalize_btc_network, normalize_evm_network, settings
 from agent_wallet.evm_user_wallets import ensure_user_evm_wallet_ready
 from agent_wallet.models import OpenClawWalletSessionMetadata
 from agent_wallet.openclaw_adapter import OpenClawWalletAdapter
@@ -105,8 +105,7 @@ def onboard_openclaw_user_wallet(
             if wdk_btc_account_index is None
             else int(wdk_btc_account_index)
         )
-        requested_network = (network or settings.solana_network).strip().lower() or "bitcoin"
-        effective_network = "bitcoin" if requested_network == "mainnet" else requested_network
+        effective_network = normalize_btc_network(network or settings.solana_network)
         binding: dict[str, Any] | None = None
         wallet_id = str(wdk_btc_wallet_id or settings.wdk_btc_wallet_id).strip()
         if not service_url:
@@ -164,15 +163,7 @@ def onboard_openclaw_user_wallet(
             if wdk_evm_account_index is None
             else int(wdk_evm_account_index)
         )
-        requested_network = (network or settings.solana_network).strip().lower() or "ethereum"
-        aliases = {
-            "mainnet": "ethereum",
-            "eth": "ethereum",
-            "eth-mainnet": "ethereum",
-            "base-mainnet": "base",
-            "base_sepolia": "base-sepolia",
-        }
-        effective_network = aliases.get(requested_network, requested_network)
+        effective_network = normalize_evm_network(network or settings.solana_network)
         wallet_id = str(wdk_evm_wallet_id or settings.wdk_evm_wallet_id).strip()
         if not service_url:
             raise WalletBackendError("wdk_evm_service_url is required for backend=wdk_evm_local.")

package/agent-wallet/agent_wallet/providers/kamino.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from agent_wallet.config import settings
+from agent_wallet.config import normalize_solana_network, settings
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
@@ -42,9 +42,7 @@ def _normalized_tx_response(data: Any, *, provider_name: str) -> dict[str, Any]:
 
 
 def _env_name(network: str) -> str:
-    normalized = str(network).strip().lower()
-    if normalized == "devnet":
-        return "devnet"
+    normalize_solana_network(network)
     return "mainnet-beta"
 
 
@@ -125,6 +123,25 @@ async def fetch_lend_user_rewards(*, user: str) -> dict[str, Any]:
     return data
 
 
+async def fetch_lend_loan_info(
+    *,
+    obligation: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch a detailed Kamino loan report for one obligation."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/klend/loans/{obligation}",
+        params={"env": _env_name(network)},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected loan info response from Kamino.")
+    return data
+
+
 async def build_lend_deposit_transaction(
     *,
     wallet: str,

package/agent-wallet/agent_wallet/providers/solana_rpc.py

@@ -42,11 +42,6 @@ def _parse_gateway_url(rpc_url: str) -> tuple[str, str, str]:
 
 def _fallback_for_rpc_url(rpc_url: str) -> str:
     """Choose a cluster-appropriate official fallback URL."""
-    lowered = rpc_url.lower()
-    if "devnet" in lowered:
-        return "https://api.devnet.solana.com"
-    if "testnet" in lowered:
-        return "https://api.testnet.solana.com"
     return SOLANA_RPC_FALLBACK
 
 
@@ -415,24 +410,6 @@ async def simulate_transaction(
     }
 
 
-async def request_airdrop(
-    address: str,
-    lamports: int,
-    rpc_url: str,
-    commitment: str = "confirmed",
-) -> dict[str, Any]:
-    """Request a devnet or testnet SOL airdrop."""
-    data = await rpc_call(
-        "requestAirdrop",
-        [address, lamports, {"commitment": commitment}],
-        rpc_url=rpc_url,
-    )
-    return {
-        "signature": data.get("result"),
-        "source": "solana-rpc",
-    }
-
-
 async def get_signature_status(
     signature: str,
     rpc_url: str,

package/agent-wallet/agent_wallet/providers/x402.py

@@ -9,7 +9,7 @@ import logging
 from typing import Any
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from agent_wallet.config import resolve_solana_rpc_url
+from agent_wallet.config import normalize_solana_network, resolve_solana_rpc_url
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 from agent_wallet.wallet_layer.base import AgentWalletBackend
@@ -19,13 +19,10 @@ AGENTIC_MARKET_API_BASE_URL = "https://api.agentic.market/v1"
 X402_EXECUTE_TIMEOUT_SECONDS = 45.0
 SOLANA_CAIP_BY_NETWORK = {
     "mainnet": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-    "devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
 }
 EVM_CAIP_BY_NETWORK = {
     "ethereum": "eip155:1",
     "base": "eip155:8453",
-    "sepolia": "eip155:11155111",
-    "base-sepolia": "eip155:84532",
 }
 _USDC_IDENTIFIERS = {
     "usdc",
@@ -63,7 +60,7 @@ def _backend_solana_sdk_rpc_url(backend: AgentWalletBackend) -> str | None:
     if primary.startswith(("http://", "https://")):
         return primary
     network = _backend_network(backend)
-    fallback = resolve_solana_rpc_url(network or "mainnet", "")
+    fallback = resolve_solana_rpc_url(normalize_solana_network(network or "mainnet"), "")
     return _trim(fallback) or None
 
 
@@ -361,7 +358,7 @@ def _wallet_caip_networks(backend: AgentWalletBackend) -> list[str]:
 def _solana_exact_execution_supported(backend: AgentWalletBackend) -> bool:
     return (
         _backend_chain(backend) == "solana"
-        and _backend_network(backend) in {"mainnet", "devnet"}
+        and _backend_network(backend) == "mainnet"
         and getattr(backend, "signer", None) is not None
     )
 
@@ -369,7 +366,7 @@ def _solana_exact_execution_supported(backend: AgentWalletBackend) -> bool:
 def _evm_exact_execution_supported(backend: AgentWalletBackend) -> bool:
     return (
         _backend_chain(backend) == "evm"
-        and _backend_network(backend) in {"base", "base-sepolia"}
+        and _backend_network(backend) == "base"
         and callable(getattr(backend, "sign_x402_evm_exact_typed_data", None))
     )
 
@@ -388,9 +385,7 @@ def _wallet_x402_support_summary(backend: AgentWalletBackend) -> dict[str, Any]:
     supported_networks = _wallet_caip_networks(backend)
     planned_execution_networks = {
         "eip155:8453",
-        "eip155:84532",
         "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-        "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
     }
     execution_modes: list[str] = []
     if _solana_exact_execution_supported(backend):

package/agent-wallet/agent_wallet/user_wallets.py

@@ -14,6 +14,7 @@ from agent_wallet.bootstrap import (
 )
 from agent_wallet.config import (
     allow_plaintext_user_wallet_migration,
+    normalize_solana_network,
     resolve_openclaw_home,
     resolve_runtime_solana_rpc_config,
     resolve_runtime_solana_swap_config,
@@ -46,13 +47,13 @@ def normalize_user_id(user_id: str) -> str:
 
 def resolve_user_wallet_path(user_id: str, network: str | None = None) -> Path:
     """Resolve the wallet file path for a given OpenClaw user."""
-    effective_network = (network or settings.solana_network).strip().lower() or "mainnet"
+    effective_network = normalize_solana_network(network or settings.solana_network)
     user_dir = resolve_openclaw_home() / "users" / normalize_user_id(user_id) / "wallets"
     return user_dir / f"solana-{effective_network}-agent.json"
 
 
 def _user_wallet_metadata(user_id: str, address: str, network: str | None = None) -> dict[str, str]:
-    effective_network = (network or settings.solana_network).strip().lower() or "mainnet"
+    effective_network = normalize_solana_network(network or settings.solana_network)
     return {
         "address": address,
         "user_id": user_id,
@@ -61,7 +62,7 @@ def _user_wallet_metadata(user_id: str, address: str, network: str | None = None
 
 
 def _resolve_effective_network(network: str | None = None) -> str:
-    return (network or settings.solana_network).strip().lower() or "mainnet"
+    return normalize_solana_network(network or settings.solana_network)
 
 
 def _resolve_user_wallet_master_key(

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -520,6 +520,9 @@ class AgentWalletBackend(ABC):
     async def get_kamino_lend_user_rewards(self, user: str | None = None) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino rewards lookup.")
 
+    async def get_kamino_open_positions(self, user: str | None = None) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino open position lookup.")
+
     async def preview_kamino_lend_deposit(
         self,
         market: str,
@@ -994,9 +997,6 @@ class AgentWalletBackend(ABC):
             ),
         )
 
-    async def request_testnet_airdrop(self, amount_native: float) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support testnet airdrops.")
-
     async def preview_native_stake(
         self,
         vote_account: str,

package/agent-wallet/agent_wallet/wallet_layer/factory.py

@@ -7,6 +7,8 @@ from pathlib import Path
 from agent_wallet.bootstrap import ensure_solana_wallet_ready, ensure_wallet_pin
 from agent_wallet.encrypted_storage import load_wallet_secret_material
 from agent_wallet.config import (
+    normalize_btc_network,
+    normalize_solana_network,
     resolve_runtime_solana_rpc_config,
     resolve_runtime_solana_swap_config,
     resolve_solana_private_key,
@@ -44,6 +46,7 @@ def create_wallet_backend() -> AgentWalletBackend | None:
         return None
 
     if backend in {"solana", "solana_local", "solana-local"}:
+        solana_network = normalize_solana_network(settings.solana_network)
         secret_material = _load_keypair_material()
         signer = (
             SolanaLocalKeypairSigner.from_secret_material(secret_material)
@@ -55,19 +58,19 @@ def create_wallet_backend() -> AgentWalletBackend | None:
             ensure_wallet_pin(
                 Path(keypair_path).expanduser(),
                 address=signer.address,
-                network=settings.solana_network,
+                network=solana_network,
             )
         configured_address = settings.solana_agent_public_key.strip() or None
         rpc_config = resolve_runtime_solana_rpc_config(
-            settings.solana_network,
+            solana_network,
             settings.solana_rpc_url,
             settings.solana_rpc_urls,
         )
-        swap_config = resolve_runtime_solana_swap_config(settings.solana_network)
+        swap_config = resolve_runtime_solana_swap_config(solana_network)
         return SolanaWalletBackend(
             rpc_url=rpc_config["rpc_urls"],
             commitment=settings.solana_commitment,
-            network=settings.solana_network,
+            network=solana_network,
             signer=signer,
             address=configured_address,
             sign_only=settings.agent_wallet_sign_only,
@@ -82,7 +85,7 @@ def create_wallet_backend() -> AgentWalletBackend | None:
         return WdkBtcLocalWalletBackend(
             service_url=settings.wdk_btc_service_url,
             wallet_id=settings.wdk_btc_wallet_id,
-            network=settings.solana_network,
+            network=normalize_btc_network(settings.solana_network),
             account_index=settings.wdk_btc_account_index,
             sign_only=settings.agent_wallet_sign_only,
         )