@agentlayer.tech/wallet 0.1.44 → 0.1.47

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

@@ -117,6 +117,7 @@ async def fetch_quote(
     restrict_intermediate_tokens: bool = True,
     only_direct_routes: bool = False,
     swap_mode: str = "ExactIn",
+    exclude_dexes: list[str] | None = None,
 ) -> dict[str, Any]:
     """Fetch a Jupiter quote for an exact-in swap.
 
@@ -133,6 +134,7 @@ async def fetch_quote(
             restrict_intermediate_tokens=restrict_intermediate_tokens,
             only_direct_routes=only_direct_routes,
             swap_mode=swap_mode,
+            exclude_dexes=exclude_dexes,
         )
     except ProviderError as exc:
         error_msg = str(exc).lower()
@@ -168,6 +170,7 @@ async def _fetch_quote_direct(
     restrict_intermediate_tokens: bool = True,
     only_direct_routes: bool = False,
     swap_mode: str = "ExactIn",
+    exclude_dexes: list[str] | None = None,
 ) -> dict[str, Any]:
     """Fetch a Jupiter quote directly from Jupiter API."""
     client = get_client()
@@ -180,6 +183,8 @@ async def _fetch_quote_direct(
         "restrictIntermediateTokens": str(restrict_intermediate_tokens).lower(),
         "onlyDirectRoutes": str(only_direct_routes).lower(),
     }
+    if exclude_dexes:
+        params["excludeDexes"] = ",".join(str(d).strip() for d in exclude_dexes if str(d).strip())
     response = await client.get(
         f"{settings.jupiter_api_base_url.rstrip('/')}/quote",
         params=params,

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

@@ -18,6 +18,12 @@ LONG_RUNNING_POST_PATHS = {
     "/v1/evm/aave/withdraw/send",
     "/v1/evm/aave/borrow/send",
     "/v1/evm/aave/repay/send",
+    "/v1/evm/morpho/vault/supply/send",
+    "/v1/evm/morpho/vault/withdraw/send",
+    "/v1/evm/morpho/market/supply_collateral/send",
+    "/v1/evm/morpho/market/borrow/send",
+    "/v1/evm/morpho/market/repay/send",
+    "/v1/evm/morpho/market/withdraw_collateral/send",
     "/v1/evm/lido/stake_eth_for_wsteth/send",
     "/v1/evm/lido/wrap_steth/send",
     "/v1/evm/lido/unwrap_wsteth/send",

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

@@ -120,6 +120,35 @@ class AgentWalletBackend(ABC):
     async def get_evm_lido_withdrawal_requests(self) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support EVM Lido withdrawal lookup.")
 
+    async def get_evm_morpho_vaults(
+        self,
+        *,
+        vault_address: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault lookup.")
+
+    async def get_evm_morpho_markets(
+        self,
+        *,
+        market_id: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        search: str | None = None,
+        collateral_asset_address: str | None = None,
+        loan_asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market lookup.")
+
+    async def get_evm_morpho_positions(self) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho positions lookup.")
+
     async def preview_evm_aave_operation(
         self,
         *,
@@ -175,6 +204,56 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support EVM Lido withdrawals.")
 
+    async def preview_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault previews.")
+
+    async def send_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault operations.")
+
+    async def preview_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market previews.")
+
+    async def send_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market operations.")
+
     async def preview_evm_swap(
         self,
         *,

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

@@ -4704,6 +4704,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         amount_ui: float,
         slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
         exclude_routers: list[str] | None = None,
+        exclude_dexes: list[str] | None = None,
     ) -> dict[str, Any]:
         if self.network != "mainnet":
             raise WalletBackendError("Provider-routed swaps are only enabled for Solana mainnet.")
@@ -4749,6 +4750,7 @@ class SolanaWalletBackend(AgentWalletBackend):
                     output_mint=output_mint,
                     amount_raw=raw_amount,
                     slippage_bps=slippage_bps,
+                    exclude_dexes=exclude_dexes,
                 )
                 quote_source = "jupiter-metis"
 
@@ -5006,17 +5008,27 @@ class SolanaWalletBackend(AgentWalletBackend):
 
         attempts: list[dict[str, Any]] = []
         last_error: str | None = None
+        _simulation_failed = False
         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
+                # On retries after a simulation failure, exclude DEXes known to fail
+                # simulation for Token-2022 tokens with extensions such as
+                # scaledUiAmountConfig, pausableConfig, or permanentDelegate
+                # (e.g. Backpack xStock tokens). GoonFi V2 is the primary offender;
+                # ZeroFi handles these tokens correctly.
+                exclude_dexes: list[str] | None = None
+                if _simulation_failed and attempt_index > 0:
+                    exclude_dexes = ["GoonFi V2"]
                 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,
+                    exclude_dexes=exclude_dexes,
                 )
                 estimated_output_raw = int(preview.get("estimated_output_amount_raw") or 0)
                 if (
@@ -5073,6 +5085,8 @@ class SolanaWalletBackend(AgentWalletBackend):
                 return result
             except (WalletBackendError, ProviderError) as exc:
                 last_error = str(exc)
+                if "simulation failed" in str(exc).lower():
+                    _simulation_failed = True
                 attempts.append(
                     {
                         "attempt": attempt_index + 1,

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

@@ -119,6 +119,22 @@ def _normalize_lido_withdrawal_operation(value: str) -> str:
     return operation
 
 
+def _normalize_morpho_vault_operation(value: str) -> str:
+    operation = str(value or "").strip().lower()
+    if operation not in {"supply", "withdraw"}:
+        raise WalletBackendError("Morpho vault operation must be one of: supply, withdraw.")
+    return operation
+
+
+def _normalize_morpho_market_operation(value: str) -> str:
+    operation = str(value or "").strip().lower()
+    if operation not in {"supply_collateral", "borrow", "repay", "withdraw_collateral"}:
+        raise WalletBackendError(
+            "Morpho market operation must be one of: supply_collateral, borrow, repay, withdraw_collateral."
+        )
+    return operation
+
+
 def _normalize_aave_payload(
     *,
     chain: str,
@@ -296,6 +312,88 @@ def _normalize_lido_withdrawal_payload(
     }
 
 
+def _normalize_morpho_payload(
+    *,
+    chain: str,
+    network: str,
+    wallet_id: str,
+    address: str,
+    operation: str,
+    token_address: str,
+    amount_raw: str | None,
+    native_amount_raw: str | None,
+    data: dict[str, Any],
+    sign_only: bool,
+) -> dict[str, Any]:
+    result = dict(data.get("result") or {})
+    request = dict(data.get("operationRequest") or {})
+    requirements = dict(data.get("requirements") or {})
+    resolved_amount = (
+        str(request.get("amount"))
+        if request.get("amount") is not None
+        else (str(amount_raw) if amount_raw is not None else None)
+    )
+    resolved_native_amount = (
+        str(request.get("nativeAmount"))
+        if request.get("nativeAmount") is not None
+        else (str(native_amount_raw) if native_amount_raw is not None else None)
+    )
+    target = dict(data.get("target") or {})
+    surface = str(data.get("surface") or target.get("type") or "").strip().lower() or None
+    asset_type = "evm-morpho-vault" if surface == "vault" else "evm-morpho-market"
+    return {
+        "chain": chain,
+        "network": network,
+        "asset_type": asset_type,
+        "asset": "ERC20",
+        "wallet": wallet_id,
+        "from_address": str(data.get("address") or address),
+        "protocol": str(data.get("protocol") or "morpho"),
+        "surface": surface,
+        "operation": str(data.get("operation") or operation),
+        "target": target,
+        "token_address": str(request.get("token") or token_address),
+        "amount_raw": resolved_amount,
+        "native_amount_raw": resolved_native_amount,
+        "amount_ui": str(data.get("amountFormatted")) if data.get("amountFormatted") is not None else None,
+        "native_amount_ui": (
+            str(data.get("nativeAmountFormatted"))
+            if data.get("nativeAmountFormatted") is not None
+            else None
+        ),
+        "estimated_fee_wei": str(data.get("estimatedFeeWei")) if data.get("estimatedFeeWei") is not None else None,
+        "estimated_operation_fee_wei": (
+            str(data.get("estimatedOperationFeeWei"))
+            if data.get("estimatedOperationFeeWei") is not None
+            else None
+        ),
+        "estimated_requirements_fee_wei": (
+            str(data.get("estimatedRequirementsFeeWei"))
+            if data.get("estimatedRequirementsFeeWei") is not None
+            else None
+        ),
+        "fee_estimate_available": bool(data.get("feeEstimateAvailable", True)),
+        "fee_estimate_error": data.get("feeEstimateError"),
+        "execution_supported": bool(data.get("executionSupported", True)) and not sign_only,
+        "quote_fingerprint": str(data.get("quoteFingerprint") or "").strip() or None,
+        "requirements": {
+            "required": bool(requirements.get("required")),
+            "requirement_count": int(requirements.get("requirementCount") or 0),
+            "approval_required": bool(requirements.get("approvalRequired")),
+            "authorization_required": bool(requirements.get("authorizationRequired")),
+            "sequence": list(requirements.get("sequence") or []),
+        },
+        "token_metadata": _normalize_token_metadata(
+            data.get("tokenMetadata"),
+            str(request.get("token") or token_address),
+        ),
+        "hash": result.get("hash"),
+        "result": result,
+        "chain_id": int(data.get("chainId") or 0),
+        "source": "wdk-evm-wallet",
+    }
+
+
 def _normalize_lifi_cross_chain_payload(
     *,
     chain: str,
@@ -921,6 +1019,122 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "source": "wdk-evm-wallet",
         }
 
+    async def get_evm_morpho_vaults(
+        self,
+        *,
+        vault_address: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "network": self.network,
+            "listedOnly": bool(listed_only),
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if limit is not None:
+            payload["limit"] = int(limit)
+        if isinstance(asset_address, str) and asset_address.strip():
+            payload["assetAddress"] = asset_address.strip()
+        if isinstance(order_by, str) and order_by.strip():
+            payload["orderBy"] = order_by.strip()
+        if isinstance(order_direction, str) and order_direction.strip():
+            payload["orderDirection"] = order_direction.strip()
+        data = await self.client.post("/v1/evm/morpho/vaults/get", payload)
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "listed_only": bool(data.get("listedOnly", listed_only)),
+            "requested_limit": int(data.get("requestedLimit") or 0),
+            "order_by": data.get("orderBy"),
+            "order_direction": data.get("orderDirection"),
+            "asset_address_filter": data.get("assetAddressFilter"),
+            "found": bool(data.get("found")) if "found" in data else None,
+            "vault_count": int(data.get("vaultCount") or 0),
+            "vault": dict(data.get("vault") or {}) if isinstance(data.get("vault"), dict) else None,
+            "vaults": list(data.get("vaults") or []),
+            "source": "wdk-evm-wallet",
+        }
+
+    async def get_evm_morpho_markets(
+        self,
+        *,
+        market_id: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        search: str | None = None,
+        collateral_asset_address: str | None = None,
+        loan_asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "network": self.network,
+            "listedOnly": bool(listed_only),
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if limit is not None:
+            payload["limit"] = int(limit)
+        if isinstance(search, str) and search.strip():
+            payload["search"] = search.strip()
+        if isinstance(collateral_asset_address, str) and collateral_asset_address.strip():
+            payload["collateralAssetAddress"] = collateral_asset_address.strip()
+        if isinstance(loan_asset_address, str) and loan_asset_address.strip():
+            payload["loanAssetAddress"] = loan_asset_address.strip()
+        if isinstance(order_by, str) and order_by.strip():
+            payload["orderBy"] = order_by.strip()
+        if isinstance(order_direction, str) and order_direction.strip():
+            payload["orderDirection"] = order_direction.strip()
+        data = await self.client.post("/v1/evm/morpho/markets/get", payload)
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "listed_only": bool(data.get("listedOnly", listed_only)),
+            "requested_limit": int(data.get("requestedLimit") or 0),
+            "order_by": data.get("orderBy"),
+            "order_direction": data.get("orderDirection"),
+            "search": data.get("search"),
+            "collateral_asset_filter": data.get("collateralAssetFilter"),
+            "loan_asset_filter": data.get("loanAssetFilter"),
+            "found": bool(data.get("found")) if "found" in data else None,
+            "market_count": int(data.get("marketCount") or 0),
+            "market": dict(data.get("market") or {}) if isinstance(data.get("market"), dict) else None,
+            "markets": list(data.get("markets") or []),
+            "source": "wdk-evm-wallet",
+        }
+
+    async def get_evm_morpho_positions(self) -> dict[str, Any]:
+        resolved_address = await self.get_address()
+        data = await self.client.post(
+            "/v1/evm/morpho/positions/get",
+            {
+                "walletId": self.wallet_id,
+                "address": resolved_address,
+                "accountIndex": self.account_index,
+                "network": self.network,
+            },
+        )
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "address": str(data.get("address") or resolved_address or ""),
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "market_position_count": int(data.get("marketPositionCount") or 0),
+            "vault_position_count": int(data.get("vaultPositionCount") or 0),
+            "market_positions": list(data.get("marketPositions") or []),
+            "vault_positions": list(data.get("vaultPositions") or []),
+            "source": "wdk-evm-wallet",
+        }
+
     async def preview_evm_aave_operation(
         self,
         *,
@@ -1140,6 +1354,196 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "confirmed": False,
         }
 
+    async def preview_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        normalized_operation = _normalize_morpho_vault_operation(operation)
+        resolved_address = await self.get_address()
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "address": resolved_address,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if isinstance(vault_preset, str) and vault_preset.strip():
+            payload["vaultPreset"] = vault_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        data = await self.client.post(
+            f"/v1/evm/morpho/vault/{normalized_operation}/quote",
+            payload,
+        )
+        return _normalize_morpho_payload(
+            chain=self.chain,
+            network=self.network,
+            wallet_id=self.wallet_id,
+            address=resolved_address,
+            operation=normalized_operation,
+            token_address=token_address,
+            amount_raw=amount_raw,
+            native_amount_raw=native_amount_raw,
+            data=data,
+            sign_only=self.sign_only,
+        )
+
+    async def send_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        if self.sign_only:
+            raise WalletBackendError("wdk_evm_local is configured as sign_only.")
+        normalized_operation = _normalize_morpho_vault_operation(operation)
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if isinstance(vault_preset, str) and vault_preset.strip():
+            payload["vaultPreset"] = vault_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        if isinstance(expected_quote_fingerprint, str) and expected_quote_fingerprint.strip():
+            payload["expectedQuoteFingerprint"] = expected_quote_fingerprint.strip()
+        data = await self.client.post(
+            f"/v1/evm/morpho/vault/{normalized_operation}/send",
+            payload,
+        )
+        return {
+            **_normalize_morpho_payload(
+                chain=self.chain,
+                network=self.network,
+                wallet_id=self.wallet_id,
+                address=await self.get_address(),
+                operation=normalized_operation,
+                token_address=token_address,
+                amount_raw=amount_raw,
+                native_amount_raw=native_amount_raw,
+                data=data,
+                sign_only=self.sign_only,
+            ),
+            "broadcasted": True,
+            "confirmed": False,
+        }
+
+    async def preview_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        normalized_operation = _normalize_morpho_market_operation(operation)
+        resolved_address = await self.get_address()
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "address": resolved_address,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if isinstance(market_preset, str) and market_preset.strip():
+            payload["marketPreset"] = market_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        data = await self.client.post(
+            f"/v1/evm/morpho/market/{normalized_operation}/quote",
+            payload,
+        )
+        return _normalize_morpho_payload(
+            chain=self.chain,
+            network=self.network,
+            wallet_id=self.wallet_id,
+            address=resolved_address,
+            operation=normalized_operation,
+            token_address=token_address,
+            amount_raw=amount_raw,
+            native_amount_raw=native_amount_raw,
+            data=data,
+            sign_only=self.sign_only,
+        )
+
+    async def send_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        if self.sign_only:
+            raise WalletBackendError("wdk_evm_local is configured as sign_only.")
+        normalized_operation = _normalize_morpho_market_operation(operation)
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if isinstance(market_preset, str) and market_preset.strip():
+            payload["marketPreset"] = market_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        if isinstance(expected_quote_fingerprint, str) and expected_quote_fingerprint.strip():
+            payload["expectedQuoteFingerprint"] = expected_quote_fingerprint.strip()
+        data = await self.client.post(
+            f"/v1/evm/morpho/market/{normalized_operation}/send",
+            payload,
+        )
+        return {
+            **_normalize_morpho_payload(
+                chain=self.chain,
+                network=self.network,
+                wallet_id=self.wallet_id,
+                address=await self.get_address(),
+                operation=normalized_operation,
+                token_address=token_address,
+                amount_raw=amount_raw,
+                native_amount_raw=native_amount_raw,
+                data=data,
+                sign_only=self.sign_only,
+            ),
+            "broadcasted": True,
+            "confirmed": False,
+        }
+
     async def get_evm_swap_quote(
         self,
         *,

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.44",
+  "version": "0.1.47",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

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