@agentlayer.tech/wallet 0.1.32 → 0.1.34

package/codex/plugins/agent-wallet/server.py

@@ -906,17 +906,51 @@ async def _handle_wallet_tool(tool_name: str, params: dict[str, Any]) -> dict[st
     return payload.get("data", {})
 
 
+BASE_INSTRUCTIONS = (
+    "Use the local AgentLayer wallet runtime through explicit wallet tools. Keep wallet "
+    "secrets local. Preview writes first when supported, and execute only after explicit "
+    "user confirmation."
+)
+
+
+def _update_notice_instructions(base: str) -> str:
+    """Append a one-time update notice to ``base`` when a newer version exists.
+
+    Fully fail-open: any error (package not importable, malformed cache, etc.)
+    returns ``base`` unchanged so the server always starts. The network refresh
+    runs in a background daemon thread and only affects the *next* start; the
+    notice itself is decided synchronously from the cache.
+    """
+    try:
+        package_root_text = str(_resolve_package_root())
+        inserted = package_root_text not in sys.path
+        if inserted:
+            sys.path.insert(0, package_root_text)
+        try:
+            from agent_wallet import update_check
+
+            update_check.maybe_refresh_in_background()
+            notice = update_check.pending_notice(mark_shown=True)
+        finally:
+            if inserted:
+                try:
+                    sys.path.remove(package_root_text)
+                except ValueError:
+                    pass
+        if notice:
+            return f"{base}\n\n⚠️ UPDATE AVAILABLE: {notice}"
+    except Exception:
+        pass
+    return base
+
+
 def build_server():
     from fastmcp import FastMCP
     from fastmcp.tools import FunctionTool
 
     mcp = FastMCP(
         "Agent Wallet",
-        instructions=(
-            "Use the local AgentLayer wallet runtime through explicit wallet tools. Keep wallet "
-            "secrets local. Preview writes first when supported, and execute only after explicit "
-            "user confirmation."
-        ),
+        instructions=_update_notice_instructions(BASE_INSTRUCTIONS),
     )
 
     async def _dispatch(tool_name: str, params: dict[str, Any] | None = None) -> dict[str, Any]:

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.0
+version: 0.1.34
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {
@@ -19,12 +19,16 @@
     "build:openclaw-plugins": "node scripts/manage_openclaw_plugin_packages.mjs build",
     "check:openclaw-plugins": "node scripts/manage_openclaw_plugin_packages.mjs check",
     "check:release-version": "node scripts/check_release_version.mjs",
+    "version:sync": "node scripts/sync_version.mjs",
+    "release:local": "node scripts/release_local.mjs",
     "test:npm-installer": "python3 agent-wallet/tests/smoke_npm_installer.py",
     "pack:dry-run": "npm pack --dry-run"
   },
   "files": [
     "bin/",
+    "VERSION",
     "scripts/check_release_version.mjs",
+    "scripts/version_targets.mjs",
     "setup.sh",
     "install-from-github.sh",
     "README.md",

package/scripts/check_release_version.mjs

@@ -1,26 +1,59 @@
 #!/usr/bin/env node
+// Verify the project version is consistent across every framework manifest and,
+// when run on a release tag, that the tag matches the canonical VERSION.
+//
+// Canonical source: the root VERSION file. All derived manifests (see
+// scripts/version_targets.mjs) must equal it — stamp them with
+// scripts/sync_version.mjs if this fails. Emits the resolved version and npm
+// dist-tag for the publish workflow.
 
 import fs from "node:fs";
 
-const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
-const pyproject = fs.readFileSync("agent-wallet/pyproject.toml", "utf8");
-const pyVersion = pyproject.match(/^version\s*=\s*"([^"]+)"/m)?.[1] || "";
-const packageVersion = packageJson.version;
-const refName = process.env.GITHUB_REF_NAME || process.argv[2] || "";
-const expectedFromTag = refName.startsWith("v") ? refName.slice(1) : "";
+import {
+  TARGETS,
+  VERSION_FILE,
+  npmTagFor,
+  readCanonicalVersion,
+  readTargetVersion,
+} from "./version_targets.mjs";
+
+const root = process.cwd();
 const errors = [];
 
-if (!packageVersion) {
-  errors.push("package.json version is missing");
+let canonical = "";
+try {
+  canonical = readCanonicalVersion(root);
+} catch {
+  errors.push(`${VERSION_FILE} is missing`);
 }
-if (!pyVersion) {
-  errors.push("agent-wallet/pyproject.toml version is missing");
+if (canonical === "") {
+  errors.push(`${VERSION_FILE} is empty`);
 }
-if (packageVersion && pyVersion && packageVersion !== pyVersion) {
-  errors.push(`version mismatch: package.json=${packageVersion}, pyproject=${pyVersion}`);
+
+if (canonical) {
+  for (const target of TARGETS) {
+    let actual = null;
+    try {
+      actual = readTargetVersion(root, target);
+    } catch {
+      errors.push(`${target.file} is missing`);
+      continue;
+    }
+    if (!actual) {
+      errors.push(`${target.file}: version field not found`);
+    } else if (actual !== canonical) {
+      errors.push(
+        `version mismatch: ${target.file}=${actual}, ${VERSION_FILE}=${canonical} ` +
+          `(run: npm run version:sync)`,
+      );
+    }
+  }
 }
-if (expectedFromTag && packageVersion !== expectedFromTag) {
-  errors.push(`tag/version mismatch: tag=${refName}, package.json=${packageVersion}`);
+
+const refName = process.env.GITHUB_REF_NAME || process.argv[2] || "";
+const expectedFromTag = refName.startsWith("v") ? refName.slice(1) : "";
+if (expectedFromTag && canonical && canonical !== expectedFromTag) {
+  errors.push(`tag/version mismatch: tag=${refName}, ${VERSION_FILE}=${canonical}`);
 }
 
 if (errors.length > 0) {
@@ -30,13 +63,10 @@ if (errors.length > 0) {
   process.exit(1);
 }
 
-const npmTag = packageVersion.includes("-") ? "beta" : "latest";
-console.log(`release_version=${packageVersion}`);
+const npmTag = npmTagFor(canonical);
+console.log(`release_version=${canonical}`);
 console.log(`npm_tag=${npmTag}`);
 
 if (process.env.GITHUB_OUTPUT) {
-  fs.appendFileSync(
-    process.env.GITHUB_OUTPUT,
-    `release_version=${packageVersion}\nnpm_tag=${npmTag}\n`,
-  );
+  fs.appendFileSync(process.env.GITHUB_OUTPUT, `release_version=${canonical}\nnpm_tag=${npmTag}\n`);
 }

package/scripts/version_targets.mjs

@@ -0,0 +1,60 @@
+// Single source of truth for the project version.
+//
+// The root VERSION file is canonical. Every other manifest below is a *derived*
+// target that must carry the exact same version. These targets are stamped by
+// scripts/sync_version.mjs and verified by scripts/check_release_version.mjs, so
+// they should never be edited by hand.
+
+import fs from "node:fs";
+import path from "node:path";
+
+export const VERSION_FILE = "VERSION";
+
+// kind -> regex capturing (prefix)(version)(suffix). Non-global on purpose: we
+// only ever replace the first (top-level) occurrence in each file.
+const PATTERNS = {
+  json: /("version"\s*:\s*")([^"]*)(")/,
+  toml: /^(version\s*=\s*")([^"]*)(")/m,
+  pyinit: /^(__version__\s*=\s*")([^"]*)(")/m,
+  yaml: /^(version:\s*)(\S+)(.*)$/m,
+};
+
+// Every place the version lives, across all agent frameworks and packages.
+export const TARGETS = [
+  { file: "package.json", kind: "json" },
+  { file: "agent-wallet/pyproject.toml", kind: "toml" },
+  { file: "agent-wallet/agent_wallet/__init__.py", kind: "pyinit" },
+  { file: ".openclaw/extensions/agent-wallet/package.json", kind: "json" },
+  { file: "agent-wallet/openclaw.plugin.json", kind: "json" },
+  { file: ".openclaw/extensions/agent-wallet/openclaw.plugin.json", kind: "json" },
+  { file: "codex/plugins/agent-wallet/.codex-plugin/plugin.json", kind: "json" },
+  { file: "claude-code/plugins/agent-wallet/.claude-plugin/plugin.json", kind: "json" },
+  { file: "hermes/plugins/agent_wallet/plugin.yaml", kind: "yaml" },
+  { file: "wdk-btc-wallet/package.json", kind: "json" },
+  { file: "wdk-evm-wallet/package.json", kind: "json" },
+];
+
+export function readCanonicalVersion(root) {
+  return fs.readFileSync(path.join(root, VERSION_FILE), "utf8").trim();
+}
+
+export function readTargetVersion(root, target) {
+  const content = fs.readFileSync(path.join(root, target.file), "utf8");
+  const match = content.match(PATTERNS[target.kind]);
+  return match ? match[2] : null;
+}
+
+export function stampTarget(root, target, version) {
+  const filePath = path.join(root, target.file);
+  const content = fs.readFileSync(filePath, "utf8");
+  const pattern = PATTERNS[target.kind];
+  if (!pattern.test(content)) {
+    throw new Error(`No version field found in ${target.file}`);
+  }
+  const updated = content.replace(pattern, (_m, prefix, _old, suffix) => `${prefix}${version}${suffix}`);
+  fs.writeFileSync(filePath, updated);
+}
+
+export function npmTagFor(version) {
+  return version.includes("-") ? "beta" : "latest";
+}

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.0",
+  "version": "0.1.34",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/README.md

@@ -18,8 +18,8 @@ Current scope:
 - fetch ERC-20 balances
 - fetch ERC-20 token metadata (`name`, `symbol`, `decimals`)
 - fetch fee-rate suggestions
-- fetch read-only Velora swap quotes for supported mainnet ERC-20 pairs
-- execute Velora ERC-20 swaps on supported mainnet networks through the local wallet account
+- fetch read-only Velora swap quotes for supported mainnet ERC-20 and native ETH pairs
+- execute Velora ERC-20 and native ETH swaps on supported mainnet networks through the local wallet account
 - fetch Aave V3 account data on supported mainnet networks
 - fetch Aave V3 reserve catalog on supported mainnet networks
 - fetch Aave V3 per-reserve user positions on supported mainnet networks
@@ -177,7 +177,7 @@ Local security note:
 - unlocked seed phrases live only in memory
 - explicit `lock` or process restart clears the in-memory unlocked state
 - seed reveal is password-gated and separate from normal agent operations
-- Velora swap support is currently limited to `ethereum` and `base` ERC-20 pairs
+- Velora swap support is currently limited to `ethereum` and `base` ERC-20 and native ETH pairs
 - the underlying WDK Velora package is still beta; test swap execution carefully before relying on it
 - Aave V3 support is currently limited to `ethereum` and `base`
 - Aave `supply` and `repay` may perform pool-scoped ERC-20 approvals; if a send fails after approval, the service attempts to restore the original allowance

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.0",
+  "version": "0.1.34",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",

package/wdk-evm-wallet/src/wdk_evm_wallet.js

@@ -246,6 +246,21 @@ function normalizeEvmTokenAddressAllowingNative(value, fieldName) {
   return normalizeAddress(address, fieldName).toLowerCase();
 }
 
+function normalizeVeloraTokenAddress(value, fieldName) {
+  const raw = assertNonEmptyString(value, fieldName);
+  const alias = raw.toLowerCase();
+  if (
+    alias === "native" ||
+    alias === "eth" ||
+    alias === "ethereum" ||
+    isZeroAddress(raw) ||
+    isVeloraNativeTokenAddress(raw)
+  ) {
+    return VELORA_NATIVE_TOKEN_ADDRESS;
+  }
+  return normalizeAddress(raw, fieldName);
+}
+
 function normalizeLifiOutputTokenAddress(value, destinationChainId, fieldName) {
   const raw = assertNonEmptyString(value, fieldName);
   const alias = raw.toLowerCase();
@@ -380,8 +395,8 @@ function normalizeX402ExactTypedData({ domain, types, primaryType, message }, ru
 
 function buildSwapRequest({ tokenIn, tokenOut, tokenInAmount }) {
   const swapRequest = {
-    tokenIn: normalizeAddress(tokenIn, "tokenIn"),
-    tokenOut: normalizeAddress(tokenOut, "tokenOut"),
+    tokenIn: normalizeVeloraTokenAddress(tokenIn, "tokenIn"),
+    tokenOut: normalizeVeloraTokenAddress(tokenOut, "tokenOut"),
     tokenInAmount: assertPositiveBigIntString(tokenInAmount, "tokenInAmount"),
   };
   assertDistinctAddresses(swapRequest.tokenIn, "tokenIn", swapRequest.tokenOut, "tokenOut");