@agentlayer.tech/wallet 0.1.14 → 0.1.16

package/.openclaw/extensions/agent-wallet/index.ts

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 
@@ -13,7 +14,12 @@ let selectedEvmNetwork = null;
 let selectedBtcNetwork = null;
 const PREVIEW_CACHE_TTL_MS = 15 * 60 * 1000;
 const PRIVATE_SWAP_CACHE_TTL_MS = 35 * 60 * 1000;
-const PREVIEW_BOUND_SWAP_TOOLS = new Set(["swap_solana_tokens", "swap_solana_privately"]);
+const PREVIEW_BOUND_SWAP_TOOLS = new Set([
+  "swap_solana_tokens",
+  "swap_solana_privately",
+  "flash_trade_open_position",
+  "flash_trade_close_position",
+]);
 const PRIVATE_SWAP_APPROVAL_TOOL_NAME = "swap_solana_privately";
 const approvalPreviewCache = new Map();
 const privateSwapOrderCache = new Map();
@@ -390,10 +396,16 @@ function resolvePythonBin(config) {
   return config.pythonBin || process.env.OPENCLAW_AGENT_WALLET_PYTHON || "python3";
 }
 
+function resolveOpenclawHome(config) {
+  return path.resolve(config.openclawHome || process.env.OPENCLAW_HOME || path.join(os.homedir(), ".openclaw"));
+}
+
 function resolvePackageRoot(config) {
+  const openclawHome = resolveOpenclawHome(config);
   const candidates = [
     config.packageRoot,
     process.env.OPENCLAW_AGENT_WALLET_PACKAGE_ROOT,
+    path.join(openclawHome, "agent-wallet-runtime/current/agent-wallet"),
     path.resolve(PLUGIN_ROOT, "../../../agent-wallet"),
     path.resolve(process.cwd(), "agent-wallet"),
   ].filter(Boolean);
@@ -405,7 +417,7 @@ function resolvePackageRoot(config) {
     }
   }
   throw new Error(
-    "Could not resolve agent-wallet package root. Set plugins.entries.agent-wallet.config.packageRoot."
+    `Could not resolve agent-wallet package root. Checked ${path.join(openclawHome, "agent-wallet-runtime/current/agent-wallet")} and local workspace fallbacks. Set plugins.entries.agent-wallet.config.packageRoot if your runtime lives elsewhere.`
   );
 }
 
@@ -1019,6 +1031,38 @@ const solanaToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "get_flash_trade_markets",
+    description: "List Flash Trade perpetual markets currently available on Solana mainnet.",
+    parameters: {
+      type: "object",
+      properties: {
+        pool_name: {
+          type: "string",
+          description: "Optional Flash pool identifier such as Crypto.1.",
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "get_flash_trade_positions",
+    description: "Get Flash Trade perpetual positions for a Solana wallet on mainnet.",
+    parameters: {
+      type: "object",
+      properties: {
+        owner: {
+          type: "string",
+          description: "Optional Solana wallet address override. If omitted, use the configured wallet.",
+        },
+        pool_name: {
+          type: "string",
+          description: "Optional Flash pool identifier such as Crypto.1.",
+        },
+      },
+      additionalProperties: false,
+    },
+  },
   {
     name: "get_kamino_lend_markets",
     description: "List Kamino lending markets currently available on Solana mainnet.",
@@ -1402,6 +1446,85 @@ const solanaToolDefinitions = [
       additionalProperties: false,
     },
   },
+  {
+    name: "flash_trade_open_position",
+    description: "Preview, prepare, or execute a Flash Trade same-collateral perpetual open on Solana mainnet.",
+    optional: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pool_name: {
+          type: "string",
+          description: "Flash pool identifier such as Crypto.1.",
+        },
+        market_symbol: {
+          type: "string",
+          description: "Flash market symbol such as SOL or BTC.",
+        },
+        collateral_symbol: {
+          type: "string",
+          description: "Collateral symbol. Current integration requires the same symbol as market_symbol.",
+        },
+        collateral_amount_raw: {
+          type: "string",
+          description: "Collateral amount in raw token units.",
+        },
+        leverage: {
+          type: "string",
+          description: "Requested leverage as a decimal string such as 5 or 7.5.",
+        },
+        side: {
+          type: "string",
+          enum: ["long", "short"],
+          description: "Position direction.",
+        },
+        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        purpose: { type: "string" },
+        user_intent: { type: "boolean" },
+        approval_token: { type: "string" },
+      },
+      required: [
+        "pool_name",
+        "market_symbol",
+        "collateral_symbol",
+        "collateral_amount_raw",
+        "leverage",
+        "side",
+        "mode",
+        "purpose",
+      ],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "flash_trade_close_position",
+    description: "Preview, prepare, or execute a Flash Trade same-collateral perpetual close on Solana mainnet.",
+    optional: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pool_name: {
+          type: "string",
+          description: "Flash pool identifier such as Crypto.1.",
+        },
+        market_symbol: {
+          type: "string",
+          description: "Flash market symbol such as SOL or BTC.",
+        },
+        side: {
+          type: "string",
+          enum: ["long", "short"],
+          description: "Position direction to close.",
+        },
+        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        purpose: { type: "string" },
+        user_intent: { type: "boolean" },
+        approval_token: { type: "string" },
+      },
+      required: ["pool_name", "market_symbol", "side", "mode", "purpose"],
+      additionalProperties: false,
+    },
+  },
   {
     name: "close_empty_token_accounts",
     description: "Preview or execute closing zero-balance token accounts. Execute requires a host-issued approval token bound to the previewed operation.",

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -8,6 +8,8 @@
       "claim_bags_fees",
       "close_empty_token_accounts",
       "continue_solana_private_swap",
+      "flash_trade_close_position",
+      "flash_trade_open_position",
       "get_active_wallet_backend",
       "get_bags_claimable_positions",
       "get_bags_fee_analytics",
@@ -26,6 +28,8 @@
       "get_evm_token_balance",
       "get_evm_token_metadata",
       "get_evm_transaction_receipt",
+      "get_flash_trade_markets",
+      "get_flash_trade_positions",
       "get_jupiter_earn_earnings",
       "get_jupiter_earn_positions",
       "get_jupiter_earn_tokens",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,11 +1,50 @@
 {
-  "name": "agent-wallet",
-  "version": "0.1.0",
-  "private": true,
+  "name": "@agentlayertech/agent-wallet-plugin",
+  "version": "0.1.16",
+  "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
+  "license": "SEE LICENSE IN ../../../LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lopushok9/Agent-Layer.git",
+    "directory": ".openclaw/extensions/agent-wallet"
+  },
+  "bugs": {
+    "url": "https://github.com/lopushok9/Agent-Layer/issues"
+  },
+  "homepage": "https://github.com/lopushok9/Agent-Layer/tree/main/.openclaw/extensions/agent-wallet#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.ts",
+    "dist/",
+    "openclaw.plugin.json",
+    "README.md",
+    "skills/"
+  ],
   "openclaw": {
     "extensions": [
       "./index.ts"
-    ]
-  }
+    ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24-beta.2",
+      "minGatewayVersion": "2026.3.24-beta.2"
+    },
+    "build": {
+      "openclawVersion": "2026.3.24-beta.2",
+      "pluginSdkVersion": "2026.3.24-beta.2"
+    }
+  },
+  "keywords": [
+    "openclaw",
+    "plugin",
+    "wallet",
+    "solana",
+    "bitcoin",
+    "evm"
+  ]
 }

package/.openclaw/extensions/pay-bridge/README.md

@@ -2,6 +2,12 @@
 
 Thin OpenClaw bridge to the locally installed `pay` CLI.
 
+External install path:
+
+```bash
+openclaw plugins install clawhub:@agentlayertech/pay-bridge-plugin
+```
+
 This plugin is intentionally separate from `agent-wallet`:
 
 - `agent-wallet` remains the execution wallet stack for Solana/EVM/BTC

package/.openclaw/extensions/pay-bridge/dist/core.mjs

@@ -0,0 +1,287 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+
+function stripAnsi(text) {
+  return String(text || "").replace(ANSI_RE, "");
+}
+
+function nonEmptyLines(text) {
+  return stripAnsi(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function extractLastJsonValue(text) {
+  const lines = nonEmptyLines(text);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const candidate = lines[i];
+    if (!candidate.startsWith("{") && !candidate.startsWith("[")) continue;
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function collectStringLeaves(value, acc = new Set()) {
+  if (typeof value === "string") {
+    acc.add(value);
+    return acc;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectStringLeaves(item, acc);
+    return acc;
+  }
+  if (value && typeof value === "object") {
+    for (const item of Object.values(value)) collectStringLeaves(item, acc);
+  }
+  return acc;
+}
+
+function withAccountArgs(args, account) {
+  if (!account) return args;
+  return [...args, "--account", account];
+}
+
+export function resolvePayBinary(config = {}) {
+  return (
+    config.payBinary ||
+    process.env.OPENCLAW_PAY_BINARY ||
+    "pay"
+  );
+}
+
+export async function runPayCommand(payBinary, args, options = {}) {
+  const { cwd, input = null } = options;
+  let stdout = "";
+  let stderr = "";
+  try {
+    const result = await execFileAsync(payBinary, args, {
+      cwd,
+      env: { ...process.env },
+      input,
+      maxBuffer: 1024 * 1024 * 8,
+    });
+    stdout = result.stdout ?? "";
+    stderr = result.stderr ?? "";
+  } catch (error) {
+    stdout = typeof error?.stdout === "string" ? error.stdout : "";
+    stderr = typeof error?.stderr === "string" ? error.stderr : "";
+    const payload = extractLastJsonValue(stdout) || extractLastJsonValue(stderr);
+    const message =
+      payload?.error?.message ||
+      payload?.message ||
+      stripAnsi(stderr || stdout || error?.message || "pay command failed").trim() ||
+      "pay command failed";
+    const wrapped = new Error(message);
+    wrapped.stdout = stdout;
+    wrapped.stderr = stderr;
+    wrapped.details = payload && typeof payload === "object" ? payload : null;
+    throw wrapped;
+  }
+  return { stdout, stderr };
+}
+
+export function parseWhoamiOutput(stdout) {
+  const lines = nonEmptyLines(stdout);
+  const systemUser = lines[0] || null;
+  const noAccount = lines.some((line) => /no mainnet account/i.test(line));
+  return {
+    system_user: systemUser,
+    has_mainnet_account: !noAccount,
+    raw_lines: lines,
+  };
+}
+
+export function parseAccountListOutput(stdout) {
+  const lines = nonEmptyLines(stdout);
+  const noAccounts = lines.some((line) => /no accounts found/i.test(line));
+  return {
+    has_accounts: !noAccounts,
+    raw_lines: lines,
+  };
+}
+
+export async function getPayStatus(config = {}, options = {}) {
+  const payBinary = resolvePayBinary(config);
+  const versionResult = await runPayCommand(payBinary, ["--version"], options);
+  const whoamiResult = await runPayCommand(
+    payBinary,
+    withAccountArgs(["whoami"], config.defaultAccount),
+    options
+  );
+  const accountListResult = await runPayCommand(payBinary, ["account", "list"], options);
+  return {
+    installed: true,
+    pay_binary: payBinary,
+    version: stripAnsi(versionResult.stdout).trim() || null,
+    account_configured: parseWhoamiOutput(whoamiResult.stdout).has_mainnet_account,
+    has_any_accounts: parseAccountListOutput(accountListResult.stdout).has_accounts,
+    whoami: parseWhoamiOutput(whoamiResult.stdout),
+    accounts: parseAccountListOutput(accountListResult.stdout),
+  };
+}
+
+export async function getPayWalletInfo(config = {}, options = {}) {
+  const payBinary = resolvePayBinary(config);
+  const whoamiResult = await runPayCommand(
+    payBinary,
+    withAccountArgs(["whoami"], config.defaultAccount),
+    options
+  );
+  const accountListResult = await runPayCommand(payBinary, ["account", "list"], options);
+  return {
+    pay_binary: payBinary,
+    default_account: config.defaultAccount || null,
+    whoami: parseWhoamiOutput(whoamiResult.stdout),
+    accounts: parseAccountListOutput(accountListResult.stdout),
+    notes: [
+      "This wallet is managed by pay.sh and is separate from the AgentLayer execution wallet.",
+    ],
+  };
+}
+
+export async function searchPayServices(config = {}, params = {}, options = {}) {
+  const payBinary = resolvePayBinary(config);
+  const args = ["skills", "search"];
+  if (params.query) args.push(String(params.query));
+  if (params.category) args.push("--category", String(params.category));
+  args.push("--json");
+  const { stdout, stderr } = await runPayCommand(
+    payBinary,
+    withAccountArgs(args, params.account || config.defaultAccount),
+    options
+  );
+  const parsed = JSON.parse(stdout.trim() || "{}");
+  return {
+    query: params.query || "",
+    category: params.category || null,
+    results: parsed,
+    warnings: nonEmptyLines(stderr),
+  };
+}
+
+export async function getPayServiceEndpoints(config = {}, params = {}, options = {}) {
+  const payBinary = resolvePayBinary(config);
+  const args = [
+    "skills",
+    "endpoints",
+    String(params.service_fqn),
+    String(params.resource),
+    "--json",
+  ];
+  const { stdout, stderr } = await runPayCommand(
+    payBinary,
+    withAccountArgs(args, params.account || config.defaultAccount),
+    options
+  );
+  const parsed = JSON.parse(stdout.trim() || "{}");
+  return {
+    service_fqn: String(params.service_fqn),
+    resource: String(params.resource),
+    endpoints: parsed,
+    warnings: nonEmptyLines(stderr),
+  };
+}
+
+function ensureHttps(url, requireHttps = true) {
+  if (!requireHttps) return;
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error("pay_api_request only allows https URLs.");
+  }
+}
+
+function appendQuery(url, query) {
+  const parsed = new URL(url);
+  if (query && typeof query === "object") {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null) continue;
+      parsed.searchParams.set(key, String(value));
+    }
+  }
+  return parsed.toString();
+}
+
+export function endpointPayloadContainsUrl(endpointPayload, url) {
+  const strings = collectStringLeaves(endpointPayload);
+  return strings.has(url);
+}
+
+export async function executePayApiRequest(config = {}, params = {}, options = {}) {
+  if (params.user_confirmed !== true) {
+    throw new Error("pay_api_request requires user_confirmed=true.");
+  }
+  if (!params.purpose || !String(params.purpose).trim()) {
+    throw new Error("pay_api_request requires a non-empty purpose.");
+  }
+  if (!params.service_fqn || !params.resource || !params.url) {
+    throw new Error("pay_api_request requires service_fqn, resource, and url.");
+  }
+  if (params.json_body !== undefined && params.text_body !== undefined) {
+    throw new Error("Provide either json_body or text_body, not both.");
+  }
+
+  const endpointData = await getPayServiceEndpoints(config, {
+    account: params.account,
+    resource: params.resource,
+    service_fqn: params.service_fqn,
+  }, options);
+
+  const finalUrl = appendQuery(String(params.url), params.query);
+  ensureHttps(finalUrl, config.requireHttps !== false);
+  if (!endpointPayloadContainsUrl(endpointData.endpoints, String(params.url))) {
+    throw new Error("The requested URL is not present in pay_get_service_endpoints for this service/resource.");
+  }
+
+  const payBinary = resolvePayBinary(config);
+  const method = String(params.method || "GET").toUpperCase();
+  const args = ["curl"];
+  if (params.account || config.defaultAccount) {
+    args.push("--account", String(params.account || config.defaultAccount));
+  }
+  args.push("--request", method);
+
+  const headers = params.headers && typeof params.headers === "object" ? params.headers : {};
+  for (const [key, value] of Object.entries(headers)) {
+    args.push("--header", `${key}: ${String(value)}`);
+  }
+
+  if (params.json_body !== undefined) {
+    const hasContentType = Object.keys(headers).some((key) => key.toLowerCase() === "content-type");
+    if (!hasContentType) {
+      args.push("--header", "content-type: application/json");
+    }
+    args.push("--data", JSON.stringify(params.json_body));
+  } else if (params.text_body !== undefined) {
+    args.push("--data", String(params.text_body));
+  }
+
+  args.push(finalUrl);
+  const { stdout, stderr } = await runPayCommand(payBinary, args, options);
+  const trimmed = stdout.trim();
+  let responseBody = trimmed;
+  if (params.parse_json_response !== false) {
+    try {
+      responseBody = JSON.parse(trimmed);
+    } catch {
+      responseBody = trimmed;
+    }
+  }
+  return {
+    method,
+    purpose: String(params.purpose),
+    request_url: finalUrl,
+    service_fqn: String(params.service_fqn),
+    resource: String(params.resource),
+    response: responseBody,
+    raw_response_text: trimmed,
+    warnings: nonEmptyLines(stderr),
+  };
+}