@agentlayer.tech/wallet 0.1.28 → 0.1.32

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/transaction_policy.py

@@ -406,230 +406,6 @@ def verify_provider_swap_simulation_result(
     }
 
 
-def verify_provider_houdini_transaction(
-    message: Any,
-    *,
-    wallet_address: str,
-    deposit_address: str,
-    amount_raw: int,
-    is_native_input: bool,
-    token_mint: str | None = None,
-    loaded_addresses: list[str] | None = None,
-) -> dict[str, Any]:
-    binding = _assert_basic_wallet_binding(
-        message,
-        wallet_address=wallet_address,
-        loaded_addresses=loaded_addresses,
-    )
-    keys = binding["account_keys"]
-    program_ids = _program_ids(message, loaded_addresses)
-    unknown_program_ids = _assert_program_allowlist(
-        program_ids,
-        allowed_programs=CORE_PROGRAM_IDS,
-        label="Houdini private swap funding",
-        reject_unknown=False,
-    )
-
-    matched_native_lamports = 0
-    matched_token_amount = 0
-    parsed_transfers: list[dict[str, Any]] = []
-
-    for instruction in _compiled_instructions(message):
-        instruction_accounts = _instruction_account_keys(
-            message,
-            instruction,
-            loaded_addresses=loaded_addresses,
-        )
-        data = _instruction_data_bytes(instruction)
-        program_id_index = int(getattr(instruction, "program_id_index", -1))
-        if program_id_index < 0 or program_id_index >= len(keys):
-            raise WalletBackendError("Provider transaction contains an invalid program id index.")
-        program_id = _account_keys(message, loaded_addresses)[program_id_index]
-
-        if (
-            is_native_input
-            and program_id == SYSTEM_PROGRAM_ID
-            and len(data) >= 12
-            and len(instruction_accounts) >= 2
-        ):
-            instruction_type = struct.unpack_from("<I", data, 0)[0]
-            if instruction_type == 2:
-                lamports = struct.unpack_from("<Q", data, 4)[0]
-                recipient = instruction_accounts[1]
-                parsed_transfers.append(
-                    {
-                        "program_id": program_id,
-                        "recipient": recipient,
-                        "amount_raw": str(lamports),
-                        "kind": "system-transfer",
-                    }
-                )
-                if recipient == deposit_address:
-                    matched_native_lamports += lamports
-            continue
-
-        if program_id not in {TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID} or len(instruction_accounts) < 2:
-            continue
-
-        if not data:
-            continue
-        instruction_tag = data[0]
-        if instruction_tag == 3 and len(data) >= 9 and len(instruction_accounts) >= 2:
-            token_amount = struct.unpack_from("<Q", data, 1)[0]
-            recipient = instruction_accounts[1]
-            parsed_transfers.append(
-                {
-                    "program_id": program_id,
-                    "recipient": recipient,
-                    "amount_raw": str(token_amount),
-                    "kind": "spl-transfer",
-                    "mint": None,
-                }
-            )
-            if not is_native_input and recipient == deposit_address:
-                matched_token_amount += token_amount
-            continue
-
-        if instruction_tag == 12 and len(data) >= 10 and len(instruction_accounts) >= 3:
-            token_amount = struct.unpack_from("<Q", data, 1)[0]
-            mint = instruction_accounts[1]
-            recipient = instruction_accounts[2]
-            parsed_transfers.append(
-                {
-                    "program_id": program_id,
-                    "recipient": recipient,
-                    "amount_raw": str(token_amount),
-                    "kind": "spl-transfer-checked",
-                    "mint": mint,
-                }
-            )
-            if (
-                not is_native_input
-                and recipient == deposit_address
-                and (token_mint is None or mint == token_mint)
-            ):
-                matched_token_amount += token_amount
-
-    if is_native_input:
-        if matched_native_lamports != amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction does not transfer the approved native SOL amount to the expected deposit address."
-            )
-    else:
-        if matched_token_amount != amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction does not transfer the approved SPL token amount to the expected deposit address."
-            )
-
-    return {
-        "wallet_address": wallet_address,
-        "fee_payer": binding["fee_payer"],
-        "required_signer_keys": binding["required_signer_keys"],
-        "required_signature_count": binding["required_signature_count"],
-        "wallet_signer_index": binding["wallet_signer_index"],
-        "sponsored_fee_payer": binding["sponsored_fee_payer"],
-        "program_ids": program_ids,
-        "unknown_program_ids": unknown_program_ids,
-        "non_core_program_ids": [pid for pid in program_ids if pid not in CORE_PROGRAM_IDS],
-        "account_key_count": len(keys),
-        "instruction_count": len(_compiled_instructions(message)),
-        "deposit_address": deposit_address,
-        "amount_raw": str(amount_raw),
-        "is_native_input": is_native_input,
-        "token_mint": token_mint,
-        "parsed_transfers": parsed_transfers,
-        "verified": True,
-    }
-
-
-def verify_provider_houdini_simulation_result(
-    simulation_value: dict[str, Any],
-    *,
-    wallet_address: str,
-    wallet_account_index: int | None,
-    is_native_input: bool,
-    token_mint: str | None,
-    amount_raw: int,
-    native_sol_extra_spend_allowance_lamports: int = (
-        DEFAULT_NATIVE_SOL_EXTRA_SPEND_ALLOWANCE_LAMPORTS
-    ),
-) -> dict[str, Any]:
-    if not isinstance(simulation_value, dict):
-        raise WalletBackendError(
-            "Houdini funding transaction simulation returned an unexpected payload.",
-            code="transaction_simulation_invalid",
-        )
-
-    if simulation_value.get("err") is not None:
-        raise WalletBackendError(
-            "Houdini funding transaction simulation failed.",
-            code="transaction_simulation_failed",
-            details={"simulation": simulation_value},
-        )
-
-    token_deltas = _wallet_token_deltas_by_mint(
-        simulation_value,
-        wallet_address=wallet_address,
-    )
-    native_delta = _native_lamport_delta(
-        simulation_value,
-        wallet_account_index=wallet_account_index,
-    )
-    warnings: list[str] = []
-    enforced_checks: list[str] = ["simulation_err_is_none"]
-
-    if is_native_input:
-        if native_delta is None:
-            warnings.append("native_input_delta_unavailable")
-        else:
-            max_spend = max(amount_raw, 0) + max(native_sol_extra_spend_allowance_lamports, 0)
-            if -native_delta > max_spend:
-                raise WalletBackendError(
-                    "Houdini funding transaction simulation spends more native SOL than approved.",
-                    code="houdini_simulation_overspend",
-                    details={
-                        "approved_input_amount_raw": str(amount_raw),
-                        "native_delta_lamports": str(native_delta),
-                        "allowed_extra_lamports": str(
-                            native_sol_extra_spend_allowance_lamports
-                        ),
-                    },
-                )
-            enforced_checks.append("native_input_spend_within_approved_amount")
-    else:
-        if not token_mint:
-            raise WalletBackendError("token_mint is required for SPL Houdini simulation checks.")
-        input_delta = token_deltas.get(token_mint)
-        if input_delta is None:
-            warnings.append("token_input_delta_unavailable")
-        elif -input_delta > amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction simulation spends more SPL token than approved.",
-                code="houdini_simulation_overspend",
-                details={
-                    "token_mint": token_mint,
-                    "approved_input_amount_raw": str(amount_raw),
-                    "input_delta_raw": str(input_delta),
-                },
-            )
-        else:
-            enforced_checks.append("token_input_spend_within_approved_amount")
-
-    return {
-        "verified": True,
-        "simulation_err": None,
-        "wallet_address": wallet_address,
-        "wallet_account_index": wallet_account_index,
-        "token_mint": token_mint,
-        "amount_raw": str(amount_raw),
-        "is_native_input": is_native_input,
-        "token_deltas": {mint: str(delta) for mint, delta in sorted(token_deltas.items())},
-        "native_delta_lamports": str(native_delta) if native_delta is not None else None,
-        "enforced_checks": enforced_checks,
-        "warnings": warnings,
-    }
-
-
 def verify_provider_bags_transaction(
     message: Any,
     *,
@@ -673,44 +449,6 @@ def verify_provider_bags_transaction(
     }
 
 
-def verify_provider_lend_transaction(
-    message: Any,
-    *,
-    wallet_address: str,
-    asset_mint: str,
-    action: str,
-) -> dict[str, Any]:
-    binding = _assert_basic_wallet_binding(message, wallet_address=wallet_address)
-    keys = binding["account_keys"]
-    if asset_mint not in keys:
-        raise WalletBackendError(
-            f"{action} transaction does not reference the expected asset mint."
-        )
-    program_ids = _program_ids(message)
-    unknown_program_ids = _assert_program_allowlist(
-        program_ids,
-        allowed_programs=CORE_PROGRAM_IDS,
-        label=action,
-        reject_unknown=False,
-    )
-    return {
-        "wallet_address": wallet_address,
-        "fee_payer": binding["fee_payer"],
-        "required_signer_keys": binding["required_signer_keys"],
-        "required_signature_count": binding["required_signature_count"],
-        "wallet_signer_index": binding["wallet_signer_index"],
-        "sponsored_fee_payer": binding["sponsored_fee_payer"],
-        "program_ids": program_ids,
-        "unknown_program_ids": unknown_program_ids,
-        "non_core_program_ids": [pid for pid in program_ids if pid not in CORE_PROGRAM_IDS],
-        "account_key_count": len(keys),
-        "instruction_count": len(_compiled_instructions(message)),
-        "asset_mint": asset_mint,
-        "action": action,
-        "verified": True,
-    }
-
-
 def verify_provider_kamino_lend_transaction(
     message: Any,
     *,

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

@@ -328,46 +328,6 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Solana-origin LI.FI swap previews.")
 
-    async def preview_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swap previews.")
-
-    async def execute_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-        approved_preview: dict[str, Any] | None = None,
-        existing_order: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swaps.")
-
-    async def get_solana_private_swap_status(
-        self,
-        *,
-        multi_id: str | None = None,
-        houdini_id: str | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swap status lookup.")
-
-    async def continue_solana_private_swap(
-        self,
-        *,
-        approved_preview: dict[str, Any],
-        existing_order: dict[str, Any],
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support continuing Solana private swaps.")
-
     async def execute_solana_lifi_cross_chain_swap(
         self,
         *,
@@ -410,22 +370,6 @@ class AgentWalletBackend(ABC):
     async def get_jupiter_staked_jup(self, address: str | None = None) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Jupiter staked JUP lookup.")
 
-    async def get_jupiter_earn_tokens(self) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn token lookup.")
-
-    async def get_jupiter_earn_positions(
-        self,
-        users: list[str] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn positions.")
-
-    async def get_jupiter_earn_earnings(
-        self,
-        user: str | None = None,
-        positions: list[str] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn earnings.")
-
     async def get_flash_trade_markets(
         self,
         pool_name: str | None = None,
@@ -520,6 +464,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,
@@ -636,50 +583,6 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repays.")
 
-    async def preview_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposit previews.")
-
-    async def prepare_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposit preparation.")
-
-    async def execute_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposits.")
-
-    async def preview_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn withdraw previews.")
-
-    async def prepare_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(
-            f"{self.name} does not support Jupiter Earn withdraw preparation."
-        )
-
-    async def execute_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn withdrawals.")
-
     async def preview_close_empty_token_accounts(
         self,
         limit: int = 8,
@@ -994,9 +897,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,
         )