@agentlayer.tech/wallet 0.1.43 → 0.1.47

package/agent-wallet/agent_wallet/openclaw_cli.py

@@ -11,6 +11,12 @@ from typing import Any
 
 from agent_wallet.wallet_layer.base import WalletBackendError
 
+try:  # telemetry is optional and must never break the CLI
+    from agent_wallet.telemetry import record as _telemetry_record
+except Exception:  # pragma: no cover - defensive
+    def _telemetry_record(*_args: Any, **_kwargs: Any) -> None:
+        return None
+
 
 def _parse_bool(value: Any) -> str:
     if value is None:
@@ -610,6 +616,15 @@ def main() -> int:
                 )
             )
     except Exception as exc:
+        # Anonymous adoption telemetry for tool invocations only (never for
+        # onboard/wallet-create/unlock/import — those touch secrets). Records
+        # just the tool name + backend family + failure flag; never raises.
+        if getattr(args, "command", "") == "invoke":
+            _telemetry_record(
+                getattr(args, "tool", ""),
+                backend=str(locals().get("config", {}).get("backend", "") or ""),
+                ok=False,
+            )
         error_payload: dict[str, Any] = {"ok": False, "error": str(exc)}
         if isinstance(exc, WalletBackendError):
             if exc.code:
@@ -619,6 +634,13 @@ def main() -> int:
         print(json.dumps(error_payload), file=sys.stderr)
         return 1
 
+    if getattr(args, "command", "") == "invoke":
+        _telemetry_record(
+            getattr(args, "tool", ""),
+            backend=str(config.get("backend", "") or ""),
+            ok=True,
+        )
+
     print(json.dumps(payload))
     return 0
 

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

@@ -0,0 +1,306 @@
+"""Anonymous, privacy-first adoption telemetry for the AgentLayer wallet.
+
+Why this exists: we want to know how many people use the wallet and through which
+host (Claude Code / Codex / Hermes / OpenClaw) — nothing more. It deliberately
+records NO PII: no wallet addresses, balances, amounts, tx hashes, tool
+arguments, or secrets. Only a random local install id, the host name, the
+invoked tool's registered name, the backend family, the plugin version, and a
+success flag.
+
+Design for a short-lived CLI subprocess:
+  - `record()` appends one JSON line to a local spool file. This is instant and
+    durable: a single small append is atomic on POSIX, and the event survives
+    even if this process exits before any network call completes.
+  - A throttled, best-effort flush claims the spool (atomic rename), POSTs each
+    event to the provider-gateway, and re-spools anything that failed. Because
+    durability lives in the spool, a killed flush never loses data — the next
+    invocation (or a longer-lived process) ships it.
+
+Everything here swallows its own errors. Telemetry must never slow down or break
+a wallet operation. Users opt out with AGENT_WALLET_NO_TELEMETRY=1.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+import uuid
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .config import DEFAULT_PROVIDER_GATEWAY_URL, resolve_openclaw_home
+
+ALLOWED_HOSTS = {"claude-code", "codex", "hermes", "openclaw"}
+
+SPOOL_NAME = "telemetry_spool.jsonl"
+ID_NAME = "telemetry_id"
+LAST_FLUSH_NAME = "telemetry_last_flush"
+
+# Keep the spool bounded if the gateway is unreachable for a long time.
+MAX_SPOOL_LINES = 500
+# Don't attempt a network flush more than this often (seconds), unless the spool
+# has grown past the soft cap below.
+FLUSH_THROTTLE_SECONDS = 20
+FLUSH_FORCE_LINES = 50
+# Tight network bounds: telemetry never blocks meaningfully.
+HTTP_TIMEOUT_SECONDS = 1.5
+MAX_EVENTS_PER_FLUSH = 100
+
+
+def _enabled() -> bool:
+    raw = os.getenv("AGENT_WALLET_NO_TELEMETRY", "").strip().lower()
+    return raw not in ("1", "true", "yes", "on")
+
+
+def _home() -> Path:
+    return resolve_openclaw_home()
+
+
+def _gateway_url() -> str:
+    url = os.getenv("PROVIDER_GATEWAY_URL", "").strip() or DEFAULT_PROVIDER_GATEWAY_URL
+    return url.rstrip("/")
+
+
+def _host() -> str:
+    host = os.getenv("AGENT_WALLET_HOST", "").strip().lower()
+    return host if host in ALLOWED_HOSTS else "unknown"
+
+
+def _install_id() -> str:
+    """Stable, random, non-identifying id for this install. Created once."""
+    path = _home() / ID_NAME
+    try:
+        existing = path.read_text(encoding="utf-8").strip()
+        if existing:
+            return existing
+    except OSError:
+        pass
+    new_id = uuid.uuid4().hex
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(new_id, encoding="utf-8")
+    except OSError:
+        pass
+    return new_id
+
+
+def record(
+    tool: str,
+    *,
+    backend: str = "",
+    ok: bool = True,
+    event: str = "tool_invoke",
+) -> None:
+    """Append an anonymous event to the spool and best-effort flush. Never raises."""
+    try:
+        if not _enabled():
+            return
+        payload = {
+            "event": event,
+            "install_id": _install_id(),
+            "host": _host(),
+            "tool": tool or "",
+            "backend": backend or "",
+            "plugin_version": __version__,
+            "ok": bool(ok),
+            "ts": int(time.time()),
+        }
+        _append_spool(payload)
+        _maybe_spawn_flush()
+    except Exception:
+        # Telemetry is never allowed to affect the wallet call.
+        pass
+
+
+# --- spool I/O --------------------------------------------------------------
+
+
+def _spool_path() -> Path:
+    return _home() / SPOOL_NAME
+
+
+def _append_spool(payload: dict[str, Any]) -> None:
+    path = _spool_path()
+    line = json.dumps(payload, separators=(",", ":")) + "\n"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # A single write of a short line is atomic across processes on POSIX.
+    with open(path, "a", encoding="utf-8") as fh:
+        fh.write(line)
+
+
+def _spool_line_count() -> int:
+    try:
+        with open(_spool_path(), "r", encoding="utf-8") as fh:
+            return sum(1 for _ in fh)
+    except OSError:
+        return 0
+
+
+def _should_flush_now() -> bool:
+    count = _spool_line_count()
+    if count == 0:
+        return False
+    if count >= FLUSH_FORCE_LINES:
+        return True
+    last_path = _home() / LAST_FLUSH_NAME
+    try:
+        last = float(last_path.read_text(encoding="utf-8").strip() or "0")
+    except (OSError, ValueError):
+        last = 0.0
+    return (time.time() - last) >= FLUSH_THROTTLE_SECONDS
+
+
+def _mark_flush_attempt() -> None:
+    try:
+        (_home() / LAST_FLUSH_NAME).write_text(str(time.time()), encoding="utf-8")
+    except OSError:
+        pass
+
+
+def _maybe_spawn_flush() -> None:
+    """Trigger a flush in a DETACHED subprocess that outlives this process.
+
+    A per-tool CLI invocation exits microseconds after recording, so a thread
+    would be killed mid-flush. A detached child (its own session, no wait) runs
+    the network call on its own time and re-spools failures reliably. Throttling
+    keeps this to roughly one spawn per FLUSH_THROTTLE_SECONDS, so most calls
+    just append to the spool and return.
+    """
+    if not _should_flush_now():
+        return
+    _mark_flush_attempt()
+    try:
+        subprocess.Popen(
+            [sys.executable, "-m", "agent_wallet.telemetry", "--flush"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,  # detach so parent exit doesn't kill it
+        )
+    except Exception:
+        pass
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True  # exists but owned by another user
+    except OSError:
+        return True
+    return True
+
+
+def _claim_suffix_pid(path: Path) -> int | None:
+    # ...telemetry_spool.jsonl.flushing.<pid>
+    try:
+        return int(path.name.rsplit(".flushing.", 1)[1])
+    except (IndexError, ValueError):
+        return None
+
+
+def _flush() -> None:
+    """Claim the spool atomically, adopt dead-PID orphans, POST, re-spool failures."""
+    spool = _spool_path()
+    home = _home()
+    claim = spool.with_suffix(spool.suffix + f".flushing.{os.getpid()}")
+
+    claims: list[Path] = []
+    try:
+        os.rename(spool, claim)  # atomic; only one process wins the live spool
+        claims.append(claim)
+    except OSError:
+        pass  # nothing to flush, or another process claimed it
+
+    # Recover orphans left by a flush that died mid-run (crash/exit after the
+    # rename but before re-spooling). Only adopt claims whose PID is gone so we
+    # never steal a batch a live sibling is still working.
+    try:
+        for orphan in home.glob(SPOOL_NAME + ".flushing.*"):
+            if orphan == claim:
+                continue
+            pid = _claim_suffix_pid(orphan)
+            if pid is None or not _pid_alive(pid):
+                claims.append(orphan)
+    except OSError:
+        pass
+
+    if not claims:
+        return
+
+    lines: list[str] = []
+    for c in claims:
+        try:
+            lines.extend(c.read_text(encoding="utf-8").splitlines())
+        except OSError:
+            pass
+
+    # Bound a long backlog (gateway down for a while): keep the most recent.
+    if len(lines) > MAX_SPOOL_LINES:
+        lines = lines[-MAX_SPOOL_LINES:]
+
+    url = _gateway_url() + "/v1/telemetry"
+    failed: list[str] = []
+    sent = 0
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        if sent >= MAX_EVENTS_PER_FLUSH:
+            failed.append(line)  # defer the rest to the next flush
+            continue
+        if _post(url, line):
+            sent += 1
+        else:
+            failed.append(line)
+
+    # Re-spool failures BEFORE removing claims: favors at-least-once delivery
+    # (a crash here re-sends, never drops). Successes are gone from the claims.
+    if failed:
+        try:
+            with open(spool, "a", encoding="utf-8") as fh:
+                fh.write("\n".join(failed) + "\n")
+        except OSError:
+            pass
+
+    for c in claims:
+        try:
+            c.unlink()
+        except OSError:
+            pass
+
+
+def _post(url: str, body: str) -> bool:
+    try:
+        req = urllib.request.Request(
+            url,
+            data=body.encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
+            return 200 <= resp.status < 300
+    except Exception:
+        return False
+
+
+def _flush_main() -> int:
+    """Entry point for the detached flush subprocess (`-m agent_wallet.telemetry --flush`)."""
+    try:
+        _flush()
+    except Exception:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    if "--flush" in sys.argv[1:]:
+        raise SystemExit(_flush_main())
+    raise SystemExit(0)

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,