@agentlayer.tech/wallet 0.1.32 → 0.1.34

package/agent-wallet/agent_wallet/update_check.py

@@ -0,0 +1,191 @@
+"""Non-blocking "a newer version is available" check for the agent wallet.
+
+Distribution is the npm package ``@agentlayer.tech/wallet``; a new release is a
+new npm publish. This module compares the installed version against the latest
+version published on the npm registry and decides whether to surface a notice.
+
+Design constraints (must all hold):
+
+* **Never block startup.** The network refresh runs in a daemon thread and only
+  updates a cache file for the *next* start. The synchronous notice decision
+  reads that cache and returns instantly without touching the network.
+* **At most once per usage cycle.** The notice is injected into the MCP server
+  ``instructions`` string, which a client reads exactly once per session.
+* **At most once per day per version across sessions.** A cached
+  ``last_shown_*`` record throttles repeats to :data:`NAG_INTERVAL_SECONDS`.
+* **Fail-open.** Any error (offline, timeout, malformed cache) results in no
+  notice and no exception — the wallet keeps working.
+* **Opt-out.** Set ``AGENT_WALLET_DISABLE_UPDATE_CHECK=1`` to disable entirely.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Callable
+
+from .config import resolve_openclaw_home
+
+PACKAGE_NAME = "@agentlayer.tech/wallet"
+# URL-encoded scoped package name for the npm registry endpoint.
+_REGISTRY_URL = "https://registry.npmjs.org/@agentlayer.tech%2Fwallet/latest"
+
+CACHE_TTL_SECONDS = 24 * 3600
+NAG_INTERVAL_SECONDS = 24 * 3600
+NET_TIMEOUT_SECONDS = 1.5
+
+ENV_DISABLE = "AGENT_WALLET_DISABLE_UPDATE_CHECK"
+
+
+def installed_version() -> str:
+    """Return the installed agent-wallet version."""
+    from . import __version__
+
+    return __version__
+
+
+def is_disabled(env: dict | None = None) -> bool:
+    """Return True when the update check is opted out via environment."""
+    env = os.environ if env is None else env
+    return str(env.get(ENV_DISABLE, "")).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def cache_path() -> Path:
+    """Location of the shared update-check cache file."""
+    return resolve_openclaw_home() / "agent-wallet-runtime" / "update-check.json"
+
+
+def _read_cache() -> dict:
+    try:
+        return json.loads(cache_path().read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _write_cache(data: dict) -> None:
+    try:
+        path = cache_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(data), encoding="utf-8")
+        tmp.replace(path)
+    except Exception:
+        # Cache is best-effort; never let a write failure surface.
+        pass
+
+
+def _parse_semver(value: str) -> tuple[int, ...]:
+    parts: list[int] = []
+    for chunk in str(value).strip().split("."):
+        num = ""
+        for ch in chunk:
+            if ch.isdigit():
+                num += ch
+            else:
+                break
+        parts.append(int(num) if num else 0)
+    return tuple(parts)
+
+
+def _is_newer(latest: str, current: str) -> bool:
+    try:
+        return _parse_semver(latest) > _parse_semver(current)
+    except Exception:
+        return False
+
+
+def pending_notice(
+    *,
+    mark_shown: bool,
+    current: str | None = None,
+    now: float | None = None,
+) -> str | None:
+    """Return a human-readable notice when a newer version should be surfaced.
+
+    Reads only the cache (no network, instant). Returns ``None`` when disabled,
+    when no newer version is known, or when the same version was already shown
+    within :data:`NAG_INTERVAL_SECONDS`. When ``mark_shown`` is True and a notice
+    is returned, the "last shown" record is persisted to throttle later sessions.
+    """
+    if is_disabled():
+        return None
+    current = installed_version() if current is None else current
+    now = time.time() if now is None else now
+
+    cache = _read_cache()
+    latest = cache.get("latest_version")
+    if not latest or not _is_newer(str(latest), current):
+        return None
+
+    if (
+        cache.get("last_shown_version") == latest
+        and isinstance(cache.get("last_shown_at"), (int, float))
+        and now - cache["last_shown_at"] < NAG_INTERVAL_SECONDS
+    ):
+        return None
+
+    if mark_shown:
+        cache["last_shown_version"] = latest
+        cache["last_shown_at"] = now
+        _write_cache(cache)
+
+    return (
+        f"newer agent-wallet version {latest} is available (you have {current}). "
+        f"Update with: npx {PACKAGE_NAME} update --yes"
+    )
+
+
+def _fetch_latest_version() -> str | None:
+    """Fetch the latest published version from the npm registry (blocking)."""
+    import httpx
+
+    resp = httpx.get(_REGISTRY_URL, timeout=NET_TIMEOUT_SECONDS)
+    resp.raise_for_status()
+    version = resp.json().get("version")
+    return str(version) if version else None
+
+
+def _refresh_now(
+    fetcher: Callable[[], str | None] | None = None,
+    now: float | None = None,
+) -> None:
+    """Refresh the cached latest version if stale. Synchronous, fail-open."""
+    if is_disabled():
+        return
+    now = time.time() if now is None else now
+    cache = _read_cache()
+    checked_at = cache.get("checked_at")
+    if isinstance(checked_at, (int, float)) and now - checked_at < CACHE_TTL_SECONDS:
+        return  # cache fresh enough; skip network
+    fetcher = _fetch_latest_version if fetcher is None else fetcher
+    try:
+        latest = fetcher()
+    except Exception:
+        return  # fail-open: leave cache untouched
+    if not latest:
+        return
+    cache["latest_version"] = str(latest)
+    cache["checked_at"] = now
+    _write_cache(cache)
+
+
+def maybe_refresh_in_background(
+    fetcher: Callable[[], str | None] | None = None,
+) -> threading.Thread | None:
+    """Start a daemon thread to refresh the cache without blocking the caller.
+
+    Returns the started thread (for tests) or ``None`` when disabled.
+    """
+    if is_disabled():
+        return None
+    thread = threading.Thread(
+        target=_refresh_now,
+        kwargs={"fetcher": fetcher},
+        name="agent-wallet-update-check",
+        daemon=True,
+    )
+    thread.start()
+    return thread

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

@@ -357,19 +357,6 @@ class AgentWalletBackend(ABC):
     async def get_stake_account(self, stake_account: str) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support stake account lookup.")
 
-    async def get_jupiter_portfolio(
-        self,
-        address: str | None = None,
-        platforms: list[str] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter portfolio lookup.")
-
-    async def get_jupiter_portfolio_platforms(self) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter portfolio platforms.")
-
-    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_flash_trade_markets(
         self,
         pool_name: str | None = None,
@@ -804,37 +791,6 @@ class AgentWalletBackend(ABC):
         }
         return result
 
-    async def get_bags_claimable_positions(
-        self,
-        wallet: str | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Bags claimable positions lookup.")
-
-    async def get_bags_fee_analytics(
-        self,
-        token_mint: str,
-        *,
-        include_claim_events: bool = False,
-        mode: str = "offset",
-        limit: int | None = None,
-        offset: int | None = None,
-        from_ts: int | None = None,
-        to_ts: int | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Bags fee analytics lookup.")
-
-    async def preview_bags_fee_claim(self, token_mint: str) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Bags fee claim previews.")
-
-    async def execute_bags_fee_claim(self, token_mint: str) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Bags fee claims.")
-
-    async def execute_bags_fee_claim_from_preview(
-        self,
-        preview: dict[str, Any],
-    ) -> dict[str, Any]:
-        return await self.execute_bags_fee_claim(str(preview["token_mint"]))
-
     async def preview_bags_token_launch(
         self,
         *,

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

@@ -993,79 +993,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": "lifi",
         }
 
-    async def get_bags_claimable_positions(
-        self,
-        wallet: str | None = None,
-    ) -> dict[str, Any]:
-        self._require_mainnet_bags("Bags fee claims")
-        wallet_address = wallet or self.address
-        if not wallet_address:
-            raise WalletBackendError("A wallet address is required for Bags claimable positions.")
-        wallet_address = validate_solana_address(wallet_address)
-        raw = await bags.fetch_claimable_positions(wallet_address)
-        positions = self._bags_claim_positions_list(raw)
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "wallet": wallet_address,
-            "position_count": len(positions),
-            "positions": positions,
-            "raw": raw,
-            "source": "bags",
-        }
-
-    async def get_bags_fee_analytics(
-        self,
-        token_mint: str,
-        *,
-        include_claim_events: bool = False,
-        mode: str = "offset",
-        limit: int | None = None,
-        offset: int | None = None,
-        from_ts: int | None = None,
-        to_ts: int | None = None,
-    ) -> dict[str, Any]:
-        self._require_mainnet_bags("Bags fee analytics")
-        normalized_mint = validate_solana_mint(token_mint)
-        if mode not in {"offset", "time"}:
-            raise WalletBackendError("mode must be 'offset' or 'time'.")
-        if limit is not None and limit <= 0:
-            raise WalletBackendError("limit must be greater than zero when provided.")
-        if offset is not None and offset < 0:
-            raise WalletBackendError("offset must be greater than or equal to zero when provided.")
-        if from_ts is not None and from_ts < 0:
-            raise WalletBackendError("from_ts must be greater than or equal to zero.")
-        if to_ts is not None and to_ts < 0:
-            raise WalletBackendError("to_ts must be greater than or equal to zero.")
-
-        tasks = [
-            bags.fetch_lifetime_fees(normalized_mint),
-            bags.fetch_claim_stats(normalized_mint),
-        ]
-        if include_claim_events:
-            tasks.append(
-                bags.fetch_claim_events(
-                    token_mint=normalized_mint,
-                    mode=mode,
-                    limit=limit,
-                    offset=offset,
-                    from_ts=from_ts,
-                    to_ts=to_ts,
-                )
-            )
-        results = await asyncio.gather(*tasks)
-        claim_events = results[2] if include_claim_events else None
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "token_mint": normalized_mint,
-            "lifetime_fees": results[0],
-            "claim_stats": results[1],
-            "claim_events": claim_events,
-            "include_claim_events": include_claim_events,
-            "source": "bags",
-        }
-
     async def get_staking_validators(
         self,
         limit: int = 20,
@@ -1262,16 +1189,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             raise WalletBackendError("basis_points must sum to exactly 10000.")
         return normalized
 
-    def _bags_claim_positions_list(self, payload: Any) -> list[dict[str, Any]]:
-        if isinstance(payload, list):
-            return [item for item in payload if isinstance(item, dict)]
-        if isinstance(payload, dict):
-            for key in ("positions", "claimablePositions", "items", "data"):
-                value = payload.get(key)
-                if isinstance(value, list):
-                    return [item for item in value if isinstance(item, dict)]
-        return []
-
     def _bags_decode_serialized_transaction_bytes(self, serialized_transaction: str) -> bytes:
         serialized = str(serialized_transaction).strip()
         if not serialized:
@@ -1533,75 +1450,6 @@ class SolanaWalletBackend(AgentWalletBackend):
         if self.network != "mainnet":
             raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
 
-    async def get_jupiter_portfolio_platforms(self) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter portfolio")
-        data = await jupiter.fetch_portfolio_platforms()
-        platforms = data.get("platforms")
-        if not isinstance(platforms, list):
-            platforms = data.get("data") if isinstance(data.get("data"), list) else []
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "platform_count": len(platforms),
-            "platforms": platforms,
-            "raw": data,
-            "source": "jupiter-portfolio",
-        }
-
-    async def get_jupiter_portfolio(
-        self,
-        address: str | None = None,
-        platforms: list[str] | None = None,
-    ) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter portfolio")
-        wallet_address = address or self.address
-        if not wallet_address:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        wallet_address = validate_solana_address(wallet_address)
-        platform_filter: list[str] | None = None
-        if platforms is not None:
-            platform_filter = []
-            for platform in platforms:
-                if not isinstance(platform, str) or not platform.strip():
-                    raise WalletBackendError("Each platform must be a non-empty string.")
-                platform_filter.append(platform.strip())
-        data = await jupiter.fetch_portfolio_positions(
-            address=wallet_address,
-            platforms=platform_filter,
-        )
-        positions = data.get("positions")
-        if not isinstance(positions, list):
-            positions = data.get("data") if isinstance(data.get("data"), list) else []
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "address": wallet_address,
-            "platforms": platform_filter or [],
-            "position_count": len(positions),
-            "positions": positions,
-            "raw": data,
-            "source": "jupiter-portfolio",
-        }
-
-    async def get_jupiter_staked_jup(self, address: str | None = None) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter staked JUP")
-        wallet_address = address or self.address
-        if not wallet_address:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        wallet_address = validate_solana_address(wallet_address)
-        data = await jupiter.fetch_staked_jup(address=wallet_address)
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "address": wallet_address,
-            "raw": data,
-            "source": "jupiter-portfolio",
-        }
-
     async def get_flash_trade_markets(
         self,
         pool_name: str | None = None,
@@ -4599,90 +4447,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": "solana-rpc",
         }
 
-    async def preview_bags_fee_claim(self, token_mint: str) -> dict[str, Any]:
-        self._require_mainnet_bags("Bags fee claims")
-        owner = await self.get_address()
-        if not owner:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        normalized_mint = validate_solana_mint(token_mint)
-        positions_payload = await self.get_bags_claimable_positions(owner)
-        positions = [
-            item
-            for item in positions_payload["positions"]
-            if str(item.get("tokenMint") or item.get("token_mint") or "").strip() == normalized_mint
-        ]
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "preview",
-            "asset_type": "bags-fee-claim",
-            "owner": owner,
-            "fee_claimer": owner,
-            "token_mint": normalized_mint,
-            "claimable_position_count": len(positions),
-            "claimable_positions": positions,
-            "sign_only": self.sign_only,
-            "can_send": self.get_capabilities().can_send_transaction,
-            "source": "bags",
-        }
-
-    async def execute_bags_fee_claim(
-        self,
-        token_mint: str,
-    ) -> dict[str, Any]:
-        preview = await self.preview_bags_fee_claim(token_mint)
-        return await self.execute_bags_fee_claim_from_preview(preview)
-
-    async def execute_bags_fee_claim_from_preview(
-        self,
-        preview: dict[str, Any],
-    ) -> dict[str, Any]:
-        if not self.signer:
-            raise WalletBackendError("Solana signer is not configured.")
-        owner = await self.get_address()
-        if not owner:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        if str(preview.get("asset_type") or "").strip().lower() != "bags-fee-claim":
-            raise WalletBackendError("preview payload is not a Bags fee claim preview.")
-        if str(preview.get("network") or self.network).strip().lower() != self.network:
-            raise WalletBackendError("preview payload network does not match the wallet backend.")
-        if str(preview.get("owner") or owner) != owner:
-            raise WalletBackendError("preview payload owner does not match the connected wallet.")
-        if int(preview.get("claimable_position_count") or 0) <= 0:
-            raise WalletBackendError("No claimable Bags fee positions were found for this token.")
-
-        token_mint = validate_solana_mint(str(preview.get("token_mint") or ""))
-        claim_payload = await bags.build_claim_transactions(
-            {
-                "feeClaimer": owner,
-                "tokenMint": token_mint,
-            }
-        )
-        transactions = self._bags_extract_transaction_base64s(claim_payload)
-        prepared = await self._prepare_bags_transactions(
-            transaction_base64s=transactions,
-            token_mint=token_mint,
-            action="Bags fee claim",
-            owner=owner,
-            asset_type="bags-fee-claim",
-            extra={
-                "fee_claimer": owner,
-                "claimable_position_count": int(preview.get("claimable_position_count") or 0),
-                "claimable_positions": preview.get("claimable_positions"),
-                "claim_response": claim_payload,
-            },
-        )
-        result = await self._execute_prepared_bags_transactions(prepared)
-        result["fee_claimer"] = owner
-        result["claimable_position_count"] = int(preview.get("claimable_position_count") or 0)
-        result["claimable_positions"] = preview.get("claimable_positions")
-        result["claim_response"] = claim_payload
-        return result
-
     async def preview_bags_token_launch(
         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.0",
+  "version": "0.1.34",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",
@@ -113,10 +113,6 @@
         "type": "string",
         "description": "Optional Jupiter Price API base URL for token price lookup."
       },
-      "jupiterPortfolioBaseUrl": {
-        "type": "string",
-        "description": "Optional Jupiter Portfolio API base URL for Jupiter-specific positions and staking data."
-      },
       "jupiterApiKey": {
         "type": "string",
         "description": "Optional Jupiter API key if your deployment uses a keyed endpoint."

package/agent-wallet/pyproject.toml

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

package/agent-wallet/skills/wallet-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wallet-operator
-description: Use when operating OpenClaw wallet tools: balances, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Kamino lending, Bags claims/launches, and wallet execution safety.
+description: Use when operating OpenClaw wallet tools: balances, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Kamino lending, Bags launches, and wallet execution safety.
 ---
 
 # Wallet Operator
@@ -30,7 +30,7 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 - BTC transfer: `transfer_btc`.
 - Solana staking: `stake_sol_native`, `deactivate_solana_stake`, `withdraw_solana_stake`.
 - Kamino: `kamino_lend_deposit`, `kamino_lend_withdraw`, `kamino_lend_borrow`, `kamino_lend_repay`.
-- Bags: `claim_bags_fees`, `launch_bags_token`.
+- Bags: `launch_bags_token`.
 
 ## Common Token IDs
 
@@ -108,8 +108,6 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 - `withdraw_solana_stake`: `stake_account`, `amount` in SOL, optional `recipient`, `mode`, `purpose`.
 - Before Kamino writes, use `get_kamino_lend_markets`, `get_kamino_lend_market_reserves`, `get_kamino_lend_user_obligations`, and `get_kamino_lend_user_rewards`.
 - Kamino write params: `market`, `reserve`, `amount_ui` decimal string, `mode`, `purpose`.
-- Bags reads: `get_bags_claimable_positions`, `get_bags_fee_analytics`.
-- `claim_bags_fees`: `token_mint`, `mode`, `purpose`.
 - `launch_bags_token`: `name`, `symbol`, `description`, `base_mint`, `claimers`, `basis_points`, `initial_buy_sol`, `mode`, `purpose`; optional socials/image/config type.
 - `close_empty_token_accounts`: `limit`, `mode` (`preview` or `execute`), `purpose`.
 
@@ -123,6 +121,5 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 
 ## Disabled Or Avoided Paths
 
-- Do not call Jupiter Portfolio tools if they are not listed by `get_wallet_capabilities`; they may be temporarily disabled.
 - Do not invent generic calldata, arbitrary contract calls, token approvals, or non-listed bridge providers.
 - If a requested tool is absent from `list_tools` or capabilities, say the wallet runtime does not expose it.