@agentlayer.tech/wallet 0.1.28 → 0.1.32

package/agent-wallet/agent_wallet/config.py

@@ -49,18 +49,11 @@ class Settings(BaseSettings):
     jupiter_ultra_api_base_url: str = "https://lite-api.jup.ag/ultra/v1"
     jupiter_price_api_base_url: str = "https://lite-api.jup.ag/price/v3"
     jupiter_portfolio_api_base_url: str = "https://api.jup.ag/portfolio/v1"
-    jupiter_lend_api_base_url: str = "https://api.jup.ag/lend/v1"
     jupiter_api_key: str = ""
     lifi_api_base_url: str = "https://li.quest/v1"
     lifi_api_key: str = ""
     lifi_integrator: str = "openclaw"
     lifi_default_deny_bridges: str = "mayan"
-    houdini_api_base_url: str = "https://api-partner.houdiniswap.com/v2"
-    houdini_api_key: str = ""
-    houdini_api_secret: str = ""
-    houdini_user_ip: str = ""
-    houdini_user_agent: str = "AgentLayer/0.1.12"
-    houdini_user_timezone: str = "UTC"
     flash_api_base_url: str = ""
     flash_sdk_bridge_command: str = ""
     flash_sdk_bridge_mode: str = "mock"
@@ -82,6 +75,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 +195,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 +217,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 +236,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 +253,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 +269,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 +287,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 +305,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 +362,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"}
@@ -380,6 +450,17 @@ def resolve_evm_wallet_password() -> str:
     )
 
 
+def resolve_btc_wallet_password() -> str:
+    """Resolve the local BTC vault password from env or the sealed secret store."""
+    direct = os.getenv("WDK_BTC_WALLET_PASSWORD", "").strip()
+    if direct:
+        return direct
+    return _resolve_sealed_secret(
+        "wdk_btc_wallet_password",
+        "btc_wallet_password",
+    )
+
+
 def use_encrypted_user_wallets() -> bool:
     """Per-user wallet files are always encrypted in the hardened runtime."""
     return True

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))
 
@@ -541,6 +529,7 @@ def create_user_evm_wallet(
             "walletId": created["walletId"],
             "accountIndex": effective_account_index,
             "network": effective_network,
+            "password": password,
         },
     )
     binding = {
@@ -593,6 +582,7 @@ def import_user_evm_wallet(
             "walletId": created["walletId"],
             "accountIndex": effective_account_index,
             "network": effective_network,
+            "password": password,
         },
     )
     binding = {