@agentlayer.tech/wallet 0.1.24 → 0.1.26

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+import time
 from dataclasses import asdict, dataclass, field
 from typing import Any
 
@@ -731,16 +732,74 @@ class AgentWalletBackend(ABC):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swap previews.")
 
+    async def preview_swap_intent(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = 300,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_for_seconds: int = 30,
+        max_attempts: int = 2,
+    ) -> dict[str, Any]:
+        preview = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
+        )
+        fee_summary = preview.get("fee_summary") if isinstance(preview.get("fee_summary"), dict) else {}
+        network_fee_lamports = fee_summary.get("network_fee_lamports")
+        if max_fee_lamports is None and isinstance(network_fee_lamports, int):
+            max_fee_lamports = max(network_fee_lamports * 3, network_fee_lamports + 100_000)
+        resolved_min_raw = minimum_output_amount_raw
+        if resolved_min_raw is None and isinstance(preview.get("minimum_output_amount_raw"), int):
+            resolved_min_raw = int(preview["minimum_output_amount_raw"])
+        output_decimals = preview.get("output_decimals")
+        minimum_output_amount_ui = preview.get("minimum_output_amount_ui")
+        if resolved_min_raw is not None and isinstance(output_decimals, int):
+            minimum_output_amount_ui = int(resolved_min_raw) / (10**output_decimals)
+        return {
+            "chain": preview.get("chain", "solana"),
+            "network": preview.get("network", getattr(self, "network", "unknown")),
+            "mode": "intent_preview",
+            "asset_type": "solana-swap-intent",
+            "owner": preview.get("owner"),
+            "input_mint": preview.get("input_mint", input_mint),
+            "output_mint": preview.get("output_mint", output_mint),
+            "input_amount_ui": preview.get("input_amount_ui", amount_ui),
+            "input_amount_raw": preview.get("input_amount_raw"),
+            "minimum_output_amount_raw": resolved_min_raw,
+            "minimum_output_amount_ui": minimum_output_amount_ui,
+            "indicative_output_amount_ui": preview.get("estimated_output_amount_ui"),
+            "indicative_output_amount_raw": preview.get("estimated_output_amount_raw"),
+            "max_slippage_bps": slippage_bps,
+            "slippage_bps": slippage_bps,
+            "max_fee_lamports": max_fee_lamports,
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "max_attempts": max_attempts,
+            "allowed_providers": ["jupiter-ultra", "jupiter-metis"],
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-input",
+            "indicative_swap_provider": preview.get("swap_provider"),
+            "indicative_fee_summary": fee_summary,
+            "can_send": preview.get("can_send"),
+            "sign_only": preview.get("sign_only"),
+            "source": "swap-intent",
+        }
+
     async def prepare_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swap preparation.")
 
@@ -752,7 +811,7 @@ class AgentWalletBackend(ABC):
             input_mint=str(preview["input_mint"]),
             output_mint=str(preview["output_mint"]),
             amount_ui=float(preview["input_amount_ui"]),
-            slippage_bps=int(preview.get("slippage_bps") or 50),
+            slippage_bps=int(preview.get("slippage_bps") or 300),
         )
 
     async def execute_swap(
@@ -760,7 +819,7 @@ class AgentWalletBackend(ABC):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swaps.")
 
@@ -772,8 +831,55 @@ class AgentWalletBackend(ABC):
             input_mint=str(preview["input_mint"]),
             output_mint=str(preview["output_mint"]),
             amount_ui=float(preview["input_amount_ui"]),
-            slippage_bps=int(preview.get("slippage_bps") or 50),
+            slippage_bps=int(preview.get("slippage_bps") or 300),
+        )
+
+    async def execute_swap_intent(
+        self,
+        *,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = 300,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_until_epoch_seconds: int | None = None,
+        max_attempts: int = 2,
+    ) -> dict[str, Any]:
+        if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+            raise WalletBackendError("Approved swap intent has expired. Create a fresh intent preview.")
+        preview = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
         )
+        output_raw = preview.get("estimated_output_amount_raw")
+        if (
+            minimum_output_amount_raw is not None
+            and isinstance(output_raw, int)
+            and output_raw < int(minimum_output_amount_raw)
+        ):
+            raise WalletBackendError(
+                "Fresh swap quote is below the approved minimum output. Funds were not moved."
+            )
+        fee_summary = preview.get("fee_summary") if isinstance(preview.get("fee_summary"), dict) else {}
+        network_fee_lamports = fee_summary.get("network_fee_lamports")
+        if (
+            max_fee_lamports is not None
+            and isinstance(network_fee_lamports, int)
+            and network_fee_lamports > int(max_fee_lamports)
+        ):
+            raise WalletBackendError("Fresh swap fee exceeds the approved fee limit. Funds were not moved.")
+        result = await self.execute_swap_from_preview(preview)
+        result["intent_execution"] = {
+            "approved_minimum_output_amount_raw": minimum_output_amount_raw,
+            "approved_max_fee_lamports": max_fee_lamports,
+            "fresh_quote_used": True,
+            "attempt_count": 1,
+            "max_attempts": max_attempts,
+        }
+        return result
 
     async def get_bags_claimable_positions(
         self,

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

@@ -7,6 +7,7 @@ import base64
 import binascii
 import hashlib
 import json
+import time
 from decimal import Decimal, InvalidOperation
 from typing import Any
 
@@ -48,6 +49,8 @@ TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
 NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112"
 STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111"
 HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS = 600
+SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS = 300
+SOLANA_SWAP_INTENT_DEFAULT_MAX_FEE_LAMPORTS = 6_000_000
 
 
 def _load_signing_key():
@@ -2062,6 +2065,29 @@ class SolanaWalletBackend(AgentWalletBackend):
             parts.append(f"route fee {route_fee_bps} bps (already reflected in quoted output)")
         return "; ".join(parts)
 
+    def _swap_fee_lamports(self, payload: dict[str, Any]) -> int | None:
+        fee_summary = payload.get("fee_summary")
+        if isinstance(fee_summary, dict):
+            network_fee = _coerce_int(fee_summary.get("network_fee_lamports"))
+            if network_fee is not None:
+                return network_fee
+        return None
+
+    def _default_swap_intent_max_fee_lamports(self, fee_summary: dict[str, Any]) -> int:
+        estimated_fee = _coerce_int(fee_summary.get("network_fee_lamports")) or 0
+        return max(
+            estimated_fee * 3,
+            estimated_fee + 100_000,
+            SOLANA_SWAP_INTENT_DEFAULT_MAX_FEE_LAMPORTS,
+        )
+
+    def _swap_minimum_output_floor(self, *, out_amount_raw: int, slippage_bps: int) -> int:
+        if out_amount_raw <= 0:
+            return 0
+        if slippage_bps <= 0:
+            raise WalletBackendError("slippage_bps must be greater than zero.")
+        return max(1, (out_amount_raw * max(0, 10_000 - slippage_bps)) // 10_000)
+
     def _require_mainnet_bags(self, feature: str) -> None:
         if self.network != "mainnet":
             raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
@@ -5426,7 +5452,8 @@ class SolanaWalletBackend(AgentWalletBackend):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        exclude_routers: list[str] | None = None,
     ) -> dict[str, Any]:
         if self.network != "mainnet":
             raise WalletBackendError("Provider-routed swaps are only enabled for Solana mainnet.")
@@ -5447,29 +5474,38 @@ class SolanaWalletBackend(AgentWalletBackend):
             raise WalletBackendError("amount is too small for the input token decimals.")
 
         sender = await self.get_address()
-        quote_source = "jupiter-ultra"
+        quote_source = "jupiter-v2-order"
         try:
-            quote = await jupiter.fetch_ultra_order(
+            quote = await jupiter.fetch_swap_v2_order(
                 input_mint=input_mint,
                 output_mint=output_mint,
                 amount_raw=raw_amount,
                 taker=sender,
-                slippage_bps=slippage_bps,
+                exclude_routers=exclude_routers,
             )
         except ProviderError:
-            quote = await jupiter.fetch_quote(
-                input_mint=input_mint,
-                output_mint=output_mint,
-                amount_raw=raw_amount,
-                slippage_bps=slippage_bps,
-            )
-            quote_source = "jupiter-metis"
+            quote_source = "jupiter-ultra"
+            try:
+                quote = await jupiter.fetch_ultra_order(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_raw=raw_amount,
+                    taker=sender,
+                    slippage_bps=slippage_bps,
+                )
+            except ProviderError:
+                quote = await jupiter.fetch_quote(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_raw=raw_amount,
+                    slippage_bps=slippage_bps,
+                )
+                quote_source = "jupiter-metis"
 
         out_amount_raw = int(quote.get("outAmount") or 0)
-        other_threshold_raw = int(
-            quote.get("otherAmountThreshold")
-            or quote.get("minOutAmount")
-            or 0
+        other_threshold_raw = self._swap_minimum_output_floor(
+            out_amount_raw=out_amount_raw,
+            slippage_bps=slippage_bps,
         )
         fee_summary = self._build_swap_fee_summary(
             swap_provider=quote_source,
@@ -5505,12 +5541,115 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": quote_source,
         }
 
+    async def preview_swap_intent(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_for_seconds: int = 120,
+        max_attempts: int = 3,
+    ) -> dict[str, Any]:
+        if valid_for_seconds <= 0 or valid_for_seconds > 120:
+            raise WalletBackendError("valid_for_seconds must be between 1 and 120.")
+        if max_attempts <= 0 or max_attempts > 5:
+            raise WalletBackendError("max_attempts must be between 1 and 5.")
+        slippage_bps = max(int(slippage_bps), SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS)
+        max_attempts = max(int(max_attempts), 3)
+
+        indicative = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
+        )
+        indicative_output_raw = int(indicative.get("estimated_output_amount_raw") or 0)
+        slippage_floor_raw = self._swap_minimum_output_floor(
+            out_amount_raw=indicative_output_raw,
+            slippage_bps=slippage_bps,
+        )
+        requested_min_output_raw = (
+            int(minimum_output_amount_raw)
+            if minimum_output_amount_raw is not None
+            else None
+        )
+        if requested_min_output_raw is not None:
+            min_output_raw = min(requested_min_output_raw, slippage_floor_raw)
+            minimum_output_policy = (
+                "explicit_clamped_to_slippage_floor"
+                if requested_min_output_raw > slippage_floor_raw
+                else "explicit"
+            )
+        else:
+            min_output_raw = slippage_floor_raw
+            minimum_output_policy = "slippage_floor"
+        if min_output_raw <= 0:
+            raise WalletBackendError("minimum_output_amount_raw could not be derived from the indicative quote.")
+        output_decimals = int(indicative.get("output_decimals") or 0)
+        min_output_ui = min_output_raw / (10**output_decimals)
+
+        fee_summary = (
+            indicative.get("fee_summary")
+            if isinstance(indicative.get("fee_summary"), dict)
+            else {}
+        )
+        fee_limit = (
+            int(max_fee_lamports)
+            if max_fee_lamports is not None
+            else self._default_swap_intent_max_fee_lamports(fee_summary)
+        )
+        if fee_limit < 0:
+            raise WalletBackendError("max_fee_lamports must be non-negative.")
+
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "mode": "intent_preview",
+            "asset_type": "solana-swap-intent",
+            "owner": indicative.get("owner"),
+            "input_mint": indicative["input_mint"],
+            "output_mint": indicative["output_mint"],
+            "input_amount_ui": indicative["input_amount_ui"],
+            "input_amount_raw": indicative["input_amount_raw"],
+            "input_decimals": indicative.get("input_decimals"),
+            "output_decimals": indicative.get("output_decimals"),
+            "indicative_output_amount_ui": indicative.get("estimated_output_amount_ui"),
+            "indicative_output_amount_raw": indicative.get("estimated_output_amount_raw"),
+            "minimum_output_amount_ui": min_output_ui,
+            "minimum_output_amount_raw": min_output_raw,
+            "requested_minimum_output_amount_raw": requested_min_output_raw,
+            "minimum_output_policy": minimum_output_policy,
+            "max_slippage_bps": slippage_bps,
+            "slippage_bps": slippage_bps,
+            "max_fee_lamports": fee_limit,
+            "max_fee_sol": fee_limit / solana_rpc.LAMPORTS_PER_SOL,
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "max_attempts": max_attempts,
+            "allowed_providers": ["jupiter-v2-order", "jupiter-ultra", "jupiter-metis"],
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-input",
+            "indicative_swap_provider": indicative.get("swap_provider"),
+            "indicative_price_impact_pct": indicative.get("price_impact_pct"),
+            "indicative_route_plan": indicative.get("route_plan", []),
+            "indicative_fee_summary": fee_summary,
+            "intent_note": (
+                "This is an intent approval preview. Execute will fetch a fresh quote and "
+                "only sign/send if it remains inside these approved limits."
+            ),
+            "can_send": self.get_capabilities().can_send_transaction,
+            "sign_only": self.sign_only,
+            "source": "swap-intent",
+        }
+
     async def execute_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
     ) -> dict[str, Any]:
         preview = await self.preview_swap(
             input_mint=input_mint,
@@ -5520,17 +5659,23 @@ class SolanaWalletBackend(AgentWalletBackend):
         )
         return await self.execute_swap_from_preview(preview)
 
-    async def execute_swap_from_preview(
+    async def _submit_prepared_swap(
         self,
-        preview: dict[str, Any],
+        prepared: dict[str, Any],
     ) -> dict[str, Any]:
-        prepared = await self.prepare_swap_from_preview(preview)
         if self.sign_only:
             raise WalletBackendError(
                 "This wallet backend is in sign-only mode. Disable sign_only to broadcast transactions."
             )
 
-        if prepared.get("swap_provider") == "jupiter-ultra":
+        if prepared.get("swap_provider") == "jupiter-v2-order":
+            submitted = await jupiter.execute_swap_v2_order(
+                signed_transaction_base64=str(prepared["transaction_base64"]),
+                request_id=str(prepared["request_id"]),
+                last_valid_block_height=_coerce_int(prepared.get("last_valid_block_height")),
+            )
+            onchain_signature = submitted.get("signature") or submitted.get("txid")
+        elif prepared.get("swap_provider") == "jupiter-ultra":
             submitted = await jupiter.execute_ultra_order(
                 signed_transaction_base64=str(prepared["transaction_base64"]),
                 request_id=str(prepared["request_id"]),
@@ -5583,12 +5728,132 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": prepared.get("swap_provider") or "jupiter-metis",
         }
 
+    async def execute_swap_from_preview(
+        self,
+        preview: dict[str, Any],
+    ) -> dict[str, Any]:
+        prepared = await self.prepare_swap_from_preview(preview)
+        return await self._submit_prepared_swap(prepared)
+
+    async def execute_swap_intent(
+        self,
+        *,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_until_epoch_seconds: int | None = None,
+        max_attempts: int = 3,
+    ) -> dict[str, Any]:
+        if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+            raise WalletBackendError("Approved swap intent has expired. Create a fresh intent preview.")
+        if max_attempts <= 0 or max_attempts > 5:
+            raise WalletBackendError("max_attempts must be between 1 and 5.")
+        slippage_bps = max(int(slippage_bps), SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS)
+        max_attempts = max(int(max_attempts), 3)
+
+        attempts: list[dict[str, Any]] = []
+        last_error: str | None = None
+        for attempt_index in range(max_attempts):
+            if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+                break
+            try:
+                exclude_routers = ["jupiterz"] if attempt_index > 0 else None
+                preview = await self.preview_swap(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_ui=amount_ui,
+                    slippage_bps=slippage_bps,
+                    exclude_routers=exclude_routers,
+                )
+                estimated_output_raw = int(preview.get("estimated_output_amount_raw") or 0)
+                if (
+                    minimum_output_amount_raw is not None
+                    and estimated_output_raw < int(minimum_output_amount_raw)
+                ):
+                    attempts.append(
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": preview.get("swap_provider"),
+                            "rejected": "quote_below_minimum_output",
+                            "estimated_output_amount_raw": estimated_output_raw,
+                            "minimum_output_amount_raw": int(minimum_output_amount_raw),
+                        }
+                    )
+                    last_error = "Fresh swap quote is below the approved minimum output."
+                    continue
+
+                prepared = await self.prepare_swap_from_preview(preview)
+                prepared_fee = self._swap_fee_lamports(prepared)
+                if (
+                    max_fee_lamports is not None
+                    and prepared_fee is not None
+                    and prepared_fee > int(max_fee_lamports)
+                ):
+                    attempts.append(
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": prepared.get("swap_provider"),
+                            "rejected": "fee_above_limit",
+                            "fee_lamports": prepared_fee,
+                            "max_fee_lamports": int(max_fee_lamports),
+                        }
+                    )
+                    last_error = "Fresh swap fee exceeds the approved fee limit."
+                    continue
+
+                result = await self._submit_prepared_swap(prepared)
+                result["intent_execution"] = {
+                    "approved_minimum_output_amount_raw": minimum_output_amount_raw,
+                    "approved_max_fee_lamports": max_fee_lamports,
+                    "fresh_quote_used": True,
+                    "attempt_count": attempt_index + 1,
+                    "max_attempts": max_attempts,
+                    "attempts": attempts
+                    + [
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": prepared.get("swap_provider"),
+                            "status": "submitted",
+                        }
+                    ],
+                }
+                return result
+            except (WalletBackendError, ProviderError) as exc:
+                last_error = str(exc)
+                attempts.append(
+                    {
+                        "attempt": attempt_index + 1,
+                        "rejected": "execution_error",
+                        "error": str(exc),
+                    }
+                )
+                if "sign-only mode" in str(exc).lower():
+                    break
+            if attempt_index + 1 < max_attempts:
+                await asyncio.sleep(min(0.5 * (attempt_index + 1), 1.5))
+
+        reason_suffix = f" Last reason: {last_error}" if last_error else ""
+        raise WalletBackendError(
+            "Solana swap intent execution failed within the approved limits. Funds were not moved."
+            + reason_suffix,
+            details={
+                "reason": last_error,
+                "attempts": attempts,
+                "minimum_output_amount_raw": minimum_output_amount_raw,
+                "max_fee_lamports": max_fee_lamports,
+                "max_attempts": max_attempts,
+            },
+        )
+
     async def prepare_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
     ) -> dict[str, Any]:
         preview = await self.preview_swap(
             input_mint=input_mint,
@@ -5629,13 +5894,23 @@ class SolanaWalletBackend(AgentWalletBackend):
 
         swap_provider = str(preview.get("swap_provider") or "jupiter-metis")
         request_id = None
-        if swap_provider == "jupiter-ultra":
+        if swap_provider in {"jupiter-v2-order", "jupiter-ultra"}:
             swap_build = preview["quote_response"]
             unsigned_transaction = VersionedTransaction.from_bytes(
                 base64.b64decode(str(swap_build["transaction"]))
             )
             request_id = swap_build.get("requestId")
-            last_valid_block_height = swap_build.get("expireAt")
+            blockhash_metadata = swap_build.get("blockhashWithMetadata")
+            last_valid_block_height = (
+                blockhash_metadata.get("lastValidBlockHeight")
+                if isinstance(blockhash_metadata, dict)
+                else None
+            )
+            if last_valid_block_height is None:
+                last_valid_block_height = (
+                    swap_build.get("lastValidBlockHeight")
+                    or swap_build.get("expireAt")
+                )
             prioritization_fee_lamports = swap_build.get("prioritizationFeeLamports")
             compute_unit_limit = swap_build.get("computeUnitLimit")
         else:

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.24"
+version = "0.1.26"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/agent-wallet/scripts/install_openclaw_local_config.py

@@ -16,7 +16,7 @@ from agent_wallet.file_ops import atomic_write_text, chmod_if_exists
 from agent_wallet.sealed_keys import resolve_sealed_keys_path, seal_keys, unseal_keys
 from security_utils import write_redacted_backup
 
-OPTIONAL_TOOLS = [
+LEGACY_ALLOWLIST_TOOLS = [
     "get_wallet_capabilities",
     "get_wallet_address",
     "get_wallet_balance",
@@ -57,6 +57,62 @@ X402_TOOLS = [
 ]
 
 
+def _extract_tool_allowlist_from_manifest(manifest_path: Path) -> list[str]:
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return []
+
+    tools = manifest.get("contracts", {}).get("tools", [])
+    if not isinstance(tools, list):
+        return []
+
+    allowlist: list[str] = []
+    for item in tools:
+        tool_name = str(item).strip()
+        if tool_name and tool_name not in allowlist:
+            allowlist.append(tool_name)
+    return allowlist
+
+
+def _load_extension_tool_allowlist(extension_path: Path) -> list[str]:
+    manifest_candidates = [
+        extension_path / "openclaw.plugin.json",
+        _repo_root() / ".openclaw" / "extensions" / "agent-wallet" / "openclaw.plugin.json",
+    ]
+    for manifest_path in manifest_candidates:
+        allowlist = _extract_tool_allowlist_from_manifest(manifest_path)
+        if allowlist:
+            return allowlist
+    return LEGACY_ALLOWLIST_TOOLS + X402_TOOLS
+
+
+def _is_agent_wallet_extension_path(value: object) -> bool:
+    return "extensions/agent-wallet" in str(value).replace("\\", "/")
+
+
+def _normalize_load_paths(paths: list[object], extension_path_text: str) -> list[str]:
+    normalized: list[str] = []
+    seen: set[str] = set()
+
+    for item in paths:
+        item_text = str(item).strip()
+        if not item_text:
+            continue
+        if "extensions/pay-bridge" in item_text:
+            continue
+        if _is_agent_wallet_extension_path(item_text) and item_text != extension_path_text:
+            continue
+        if item_text in seen:
+            continue
+        normalized.append(item_text)
+        seen.add(item_text)
+
+    if extension_path_text not in seen:
+        normalized.append(extension_path_text)
+    return normalized
+
+
 def _default_config_path() -> Path:
     return Path(os.path.expanduser("~/.openclaw/openclaw.json"))
 
@@ -239,9 +295,7 @@ def main() -> None:
     load = plugins.setdefault("load", {})
     paths = load.setdefault("paths", [])
     extension_path_text = str(Path(args.extension_path).expanduser().resolve())
-    if extension_path_text not in paths:
-        paths.append(extension_path_text)
-    paths[:] = [item for item in paths if "extensions/pay-bridge" not in str(item)]
+    paths[:] = _normalize_load_paths(list(paths), extension_path_text)
 
     entries = plugins.setdefault("entries", {})
     effective_network = _normalize_network(args.backend, args.network)
@@ -306,7 +360,7 @@ def main() -> None:
         "pay_api_request",
     }
     also_allow[:] = [tool_name for tool_name in also_allow if tool_name not in removed_pay_tools]
-    for tool_name in OPTIONAL_TOOLS + X402_TOOLS:
+    for tool_name in _load_extension_tool_allowlist(Path(extension_path_text)):
         if tool_name not in also_allow:
             also_allow.append(tool_name)