@vultisig/cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -11,9 +11,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -1101,11 +1108,333 @@ var require_main = __commonJS({
   }
 });
 
+// ../../node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
+var init_u64 = __esm({
+  "../../node_modules/@noble/hashes/esm/_u64.js"() {
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function createXOFer(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+var isLE, swap32IfBE, Hash;
+var init_utils = __esm({
+  "../../node_modules/@noble/hashes/esm/utils.js"() {
+    isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    swap32IfBE = isLE ? (u) => u : byteSwap32;
+    Hash = class {
+    };
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/sha3.js
+var sha3_exports = {};
+__export(sha3_exports, {
+  Keccak: () => Keccak,
+  keccakP: () => keccakP,
+  keccak_224: () => keccak_224,
+  keccak_256: () => keccak_256,
+  keccak_384: () => keccak_384,
+  keccak_512: () => keccak_512,
+  sha3_224: () => sha3_224,
+  sha3_256: () => sha3_256,
+  sha3_384: () => sha3_384,
+  sha3_512: () => sha3_512,
+  shake128: () => shake128,
+  shake256: () => shake256
+});
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
+var init_sha3 = __esm({
+  "../../node_modules/@noble/hashes/esm/sha3.js"() {
+    init_u64();
+    init_utils();
+    _0n = BigInt(0);
+    _1n = BigInt(1);
+    _2n = BigInt(2);
+    _7n = BigInt(7);
+    _256n = BigInt(256);
+    _0x71n = BigInt(113);
+    SHA3_PI = [];
+    SHA3_ROTL = [];
+    _SHA3_IOTA = [];
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    IOTAS = split(_SHA3_IOTA, true);
+    SHA3_IOTA_H = IOTAS[0];
+    SHA3_IOTA_L = IOTAS[1];
+    rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+    rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+    Keccak = class _Keccak extends Hash {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        anumber(outputLen);
+        if (!(0 < blockLen && blockLen < 200))
+          throw new Error("only keccak-f1600 function is supported");
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+      destroy() {
+        this.destroyed = true;
+        clean(this.state);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+    sha3_224 = /* @__PURE__ */ (() => gen(6, 144, 224 / 8))();
+    sha3_256 = /* @__PURE__ */ (() => gen(6, 136, 256 / 8))();
+    sha3_384 = /* @__PURE__ */ (() => gen(6, 104, 384 / 8))();
+    sha3_512 = /* @__PURE__ */ (() => gen(6, 72, 512 / 8))();
+    keccak_224 = /* @__PURE__ */ (() => gen(1, 144, 224 / 8))();
+    keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+    keccak_384 = /* @__PURE__ */ (() => gen(1, 104, 384 / 8))();
+    keccak_512 = /* @__PURE__ */ (() => gen(1, 72, 512 / 8))();
+    genShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+    shake128 = /* @__PURE__ */ (() => genShake(31, 168, 128 / 8))();
+    shake256 = /* @__PURE__ */ (() => genShake(31, 136, 256 / 8))();
+  }
+});
+
 // src/index.ts
 import "dotenv/config";
 import { promises as fs3 } from "node:fs";
-import { parseKeygenQR, Vultisig as Vultisig5 } from "@vultisig/sdk";
-import chalk13 from "chalk";
+import { parseKeygenQR, Vultisig as Vultisig7 } from "@vultisig/sdk";
+import chalk14 from "chalk";
 import { program } from "commander";
 import inquirer8 from "inquirer";
 
@@ -2327,6 +2656,66 @@ async function executeBroadcast(ctx2, params) {
   }
 }
 
+// src/commands/tx-status.ts
+import { Chain as Chain5, Vultisig as Vultisig5 } from "@vultisig/sdk";
+var POLL_INTERVAL_MS = 5e3;
+async function executeTxStatus(ctx2, params) {
+  const vault = await ctx2.ensureActiveVault();
+  if (!Object.values(Chain5).includes(params.chain)) {
+    throw new Error(`Invalid chain: ${params.chain}`);
+  }
+  const spinner = createSpinner("Checking transaction status...");
+  try {
+    let result = await vault.getTxStatus({ chain: params.chain, txHash: params.txHash });
+    if (!params.noWait) {
+      let polls = 1;
+      while (result.status === "pending") {
+        spinner.text = `Transaction pending... (${polls * 5}s)`;
+        await sleep(POLL_INTERVAL_MS);
+        result = await vault.getTxStatus({ chain: params.chain, txHash: params.txHash });
+        polls++;
+      }
+    }
+    spinner.succeed(`Transaction status: ${result.status}`);
+    displayResult(params.chain, params.txHash, result);
+    return result;
+  } catch (error2) {
+    spinner.fail("Failed to check transaction status");
+    throw error2;
+  }
+}
+function displayResult(chain, txHash, result) {
+  if (isJsonOutput()) {
+    outputJson({
+      chain,
+      txHash,
+      status: result.status,
+      receipt: result.receipt ? {
+        feeAmount: result.receipt.feeAmount.toString(),
+        feeDecimals: result.receipt.feeDecimals,
+        feeTicker: result.receipt.feeTicker
+      } : void 0,
+      explorerUrl: Vultisig5.getTxExplorerUrl(chain, txHash)
+    });
+  } else {
+    printResult(`Status: ${result.status}`);
+    if (result.receipt) {
+      const fee = formatFee(result.receipt.feeAmount, result.receipt.feeDecimals);
+      printResult(`Fee: ${fee} ${result.receipt.feeTicker}`);
+    }
+    printResult(`Explorer: ${Vultisig5.getTxExplorerUrl(chain, txHash)}`);
+  }
+}
+function formatFee(amount, decimals) {
+  const str = amount.toString().padStart(decimals + 1, "0");
+  const whole = str.slice(0, -decimals) || "0";
+  const frac = str.slice(-decimals).replace(/0+$/, "");
+  return frac ? `${whole}.${frac}` : whole;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/commands/vault-management.ts
 var import_qrcode_terminal4 = __toESM(require_main(), 1);
 import chalk5 from "chalk";
@@ -2344,13 +2733,14 @@ function withAbortSignal(promise, signal) {
   ]);
 }
 async function executeCreateFast(ctx2, options) {
-  const { name, password, email, signal } = options;
+  const { name, password, email, signal, twoStep } = options;
   const spinner = createSpinner("Creating vault...");
   const vaultId = await withAbortSignal(
     ctx2.sdk.createFastVault({
       name,
       password,
       email,
+      persistPending: twoStep,
       onProgress: (step) => {
         spinner.text = `${step.message} (${step.progress}%)`;
       }
@@ -2358,6 +2748,17 @@ async function executeCreateFast(ctx2, options) {
     signal
   );
   spinner.succeed(`Vault keys generated: ${name}`);
+  if (twoStep) {
+    success("\n+ Vault created and saved to disk (pending verification)");
+    info(`
+Vault ID: ${vaultId}`);
+    info("\nA verification code has been sent to your email.");
+    info("To complete setup, run:");
+    printResult(chalk5.cyan(`  vultisig verify ${vaultId} --code <OTP>`));
+    info("\nOr to resend the verification email:");
+    printResult(chalk5.cyan(`  vultisig verify ${vaultId} --resend --email ${email} --password <password>`));
+    return void 0;
+  }
   warn("\nA verification code has been sent to your email.");
   info("Please check your inbox and enter the code.");
   const MAX_VERIFY_ATTEMPTS = 5;
@@ -3268,7 +3669,7 @@ async function executeSwap(ctx2, options) {
 }
 
 // src/commands/settings.ts
-import { Chain as Chain5, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
+import { Chain as Chain6, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
 import chalk6 from "chalk";
 import inquirer5 from "inquirer";
 async function executeCurrency(ctx2, newCurrency) {
@@ -3336,7 +3737,7 @@ async function executeAddressBook(ctx2, options = {}) {
         type: "list",
         name: "chain",
         message: "Select chain:",
-        choices: Object.values(Chain5)
+        choices: Object.values(Chain6)
       });
     }
     if (!address) {
@@ -3696,130 +4097,2339 @@ function displayDiscountTier(tierInfo) {
   printResult("");
 }
 
-// src/interactive/completer.ts
-import { Chain as Chain6 } from "@vultisig/sdk";
-import fs2 from "fs";
-import path2 from "path";
-var COMMANDS = [
-  // Vault management
-  "vaults",
-  "vault",
-  "import",
-  "delete",
-  "create-from-seedphrase",
-  "create",
-  "join",
-  "info",
-  "export",
-  // Wallet operations
-  "balance",
-  "bal",
-  "send",
-  "portfolio",
-  "addresses",
-  "chains",
-  "tokens",
-  // Swap operations
-  "swap-chains",
-  "swap-quote",
-  "swap",
-  // Session commands (shell-only)
-  "lock",
-  "unlock",
-  "status",
-  // Settings
-  "currency",
-  "server",
-  "address-book",
-  // Help
-  "help",
-  "?",
-  // REPL commands
-  ".help",
-  ".clear",
-  ".exit"
-];
-function createCompleter(ctx2) {
-  return function completer(line) {
+// src/agent/auth.ts
+init_sha3();
+import { randomBytes } from "node:crypto";
+import { Chain as Chain7 } from "@vultisig/sdk";
+async function authenticateVault(client, vault, password, maxAttempts = 3) {
+  const publicKey = vault.publicKeys.ecdsa;
+  const chainCode = vault.hexChainCode;
+  const ethAddress = await vault.address(Chain7.Ethereum);
+  const nonce = "0x" + randomBytes(16).toString("hex");
+  const expiresAt = new Date(Date.now() + 15 * 60 * 1e3).toISOString();
+  const authMessage = JSON.stringify({
+    message: "Sign into Vultisig Plugin Marketplace",
+    nonce,
+    expiresAt,
+    address: ethAddress
+  });
+  const messageHash = computePersonalSignHash(authMessage);
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      const parts = line.split(/\s+/);
-      const command = parts[0]?.toLowerCase();
-      if ((command === "import" || command === "export") && parts.length > 1) {
-        const partial = parts.slice(1).join(" ");
-        return completeFilePath(partial, command === "import");
+      if (attempt > 1) {
+        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
+`);
       }
-      if (command === "vault" && parts.length > 1) {
-        const partial = parts.slice(1).join(" ");
-        return completeVaultName(ctx2, partial);
+      const signature = await vault.signBytes(
+        { data: Buffer.from(messageHash), chain: Chain7.Ethereum },
+        {}
+      );
+      const sigHex = formatSignature65(signature.signature, signature.recovery ?? 0);
+      const authResponse = await client.authenticate({
+        public_key: publicKey,
+        chain_code_hex: chainCode,
+        message: authMessage,
+        signature: sigHex
+      });
+      return {
+        token: authResponse.token,
+        expiresAt: authResponse.expires_at
+      };
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts && err.message?.includes("timeout")) {
+        continue;
       }
-      if (command === "chains" && parts.length >= 2) {
-        const lastPart = parts[parts.length - 1] || "";
-        const lastPartLower = lastPart.toLowerCase();
-        if (lastPartLower.startsWith("-")) {
-          const flags = ["--add", "--add-all", "--remove"];
-          const matches = flags.filter((f) => f.startsWith(lastPartLower));
-          return [matches.length ? matches : flags, lastPart];
+      throw err;
+    }
+  }
+  throw lastError || new Error("Authentication failed after all attempts");
+}
+function computePersonalSignHash(message) {
+  const messageBytes = new TextEncoder().encode(message);
+  const prefix = `Ethereum Signed Message:
+${messageBytes.length}`;
+  const prefixBytes = new TextEncoder().encode(prefix);
+  const combined = new Uint8Array(prefixBytes.length + messageBytes.length);
+  combined.set(prefixBytes);
+  combined.set(messageBytes, prefixBytes.length);
+  return keccak_256(combined);
+}
+function formatSignature65(sigHex, recovery) {
+  const hex = sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex;
+  const bytes = Buffer.from(hex, "hex");
+  if (bytes[0] === 48) {
+    const { r, s } = decodeDERSignature(bytes);
+    const v = (recovery + 27).toString(16).padStart(2, "0");
+    return r + s + v;
+  }
+  if (hex.length >= 128) {
+    const rs = hex.slice(0, 128);
+    const v = (recovery + 27).toString(16).padStart(2, "0");
+    return rs + v;
+  }
+  throw new Error(`Cannot format signature: unrecognized format (${hex.length} hex chars)`);
+}
+function decodeDERSignature(der) {
+  let offset = 0;
+  if (der[offset++] !== 48) throw new Error("Invalid DER: expected SEQUENCE");
+  offset++;
+  if (der[offset++] !== 2) throw new Error("Invalid DER: expected INTEGER for r");
+  const rLen = der[offset++];
+  const rBytes = der.subarray(offset, offset + rLen);
+  offset += rLen;
+  if (der[offset++] !== 2) throw new Error("Invalid DER: expected INTEGER for s");
+  const sLen = der[offset++];
+  const sBytes = der.subarray(offset, offset + sLen);
+  const r = padTo32Bytes(stripLeadingZeros(rBytes));
+  const s = padTo32Bytes(stripLeadingZeros(sBytes));
+  return { r, s };
+}
+function stripLeadingZeros(buf) {
+  let start = 0;
+  while (start < buf.length - 1 && buf[start] === 0) start++;
+  return Buffer.from(buf.subarray(start));
+}
+function padTo32Bytes(buf) {
+  if (buf.length > 32) {
+    return buf.subarray(buf.length - 32).toString("hex");
+  }
+  return buf.toString("hex").padStart(64, "0");
+}
+
+// src/agent/client.ts
+var AgentClient = class {
+  baseUrl;
+  authToken = null;
+  verbose = false;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  // ============================================================================
+  // Authentication
+  // ============================================================================
+  async authenticate(req) {
+    const res = await fetch(`${this.baseUrl}/auth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(req)
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(`Auth failed (${res.status}): ${body.error || res.statusText}`);
+    }
+    const data = await res.json();
+    this.authToken = data.token;
+    return data;
+  }
+  // ============================================================================
+  // Health
+  // ============================================================================
+  async healthCheck() {
+    try {
+      const res = await fetch(`${this.baseUrl}/healthz`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================================================
+  // Conversations
+  // ============================================================================
+  async createConversation(publicKey) {
+    const req = { public_key: publicKey };
+    return this.post("/agent/conversations", req);
+  }
+  async listConversations(publicKey, skip = 0, take = 20) {
+    const req = { public_key: publicKey, skip, take };
+    return this.post("/agent/conversations/list", req);
+  }
+  async getConversation(conversationId, publicKey) {
+    const req = { public_key: publicKey };
+    return this.post(`/agent/conversations/${conversationId}`, req);
+  }
+  async deleteConversation(conversationId, publicKey) {
+    await this.delete(`/agent/conversations/${conversationId}`, { public_key: publicKey });
+  }
+  // ============================================================================
+  // Messages - JSON mode
+  // ============================================================================
+  async sendMessage(conversationId, req) {
+    return this.post(`/agent/conversations/${conversationId}/messages`, req);
+  }
+  // ============================================================================
+  // Messages - SSE Streaming mode
+  // ============================================================================
+  async sendMessageStream(conversationId, req, callbacks, signal) {
+    const res = await fetch(`${this.baseUrl}/agent/conversations/${conversationId}/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}
+      },
+      body: JSON.stringify(req),
+      signal
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(`Message failed (${res.status}): ${body.error || res.statusText}`);
+    }
+    if (!res.body) {
+      throw new Error("No response body for SSE stream");
+    }
+    const result = {
+      fullText: "",
+      actions: [],
+      suggestions: [],
+      transactions: [],
+      message: null
+    };
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        let currentEvent = "";
+        let currentData = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            currentData += (currentData ? "\n" : "") + line.slice(6);
+          } else if (line === "") {
+            if (currentEvent && currentData) {
+              this.handleSSEEvent(currentEvent, currentData, result, callbacks);
+            }
+            currentEvent = "";
+            currentData = "";
+          } else if (line.startsWith(": ")) {
+          }
         }
-        const flag = parts[parts.length - 2]?.toLowerCase();
-        if (flag === "--add" || flag === "--remove") {
-          return completeChainName(lastPart);
+        if (currentEvent && currentData) {
+          this.handleSSEEvent(currentEvent, currentData, result, callbacks);
         }
       }
-      if (["balance", "bal", "tokens", "send", "swap", "swap-quote"].includes(command) && parts.length === 2) {
-        const partial = parts[1] || "";
-        return completeChainName(partial);
-      }
-      if ((command === "create" || command === "create-from-seedphrase") && parts.length === 2) {
-        const types = ["fast", "secure"];
-        const partial = parts[1] || "";
-        const partialLower = partial.toLowerCase();
-        const matches = types.filter((t) => t.startsWith(partialLower));
-        return [matches.length ? matches : types, partial];
-      }
-      if (command === "join" && parts.length === 2) {
-        const types = ["secure"];
-        const partial = parts[1] || "";
-        const partialLower = partial.toLowerCase();
-        const matches = types.filter((t) => t.startsWith(partialLower));
-        return [matches.length ? matches : types, partial];
+    } finally {
+      reader.releaseLock();
+    }
+    return result;
+  }
+  handleSSEEvent(event, data, result, callbacks) {
+    try {
+      const parsed = JSON.parse(data);
+      switch (event) {
+        case "text_delta":
+          result.fullText += parsed.delta;
+          callbacks.onTextDelta?.(parsed.delta);
+          break;
+        case "tool_progress":
+          if (this.verbose) process.stderr.write(`[SSE:tool_progress] raw: ${data.slice(0, 1e3)}
+`);
+          callbacks.onToolProgress?.(parsed.tool, parsed.status, parsed.label);
+          break;
+        case "title":
+          callbacks.onTitle?.(parsed.title);
+          break;
+        case "actions":
+          if (this.verbose) process.stderr.write(`[SSE:actions] raw: ${data.slice(0, 1e3)}
+`);
+          result.actions.push(...parsed.actions || []);
+          callbacks.onActions?.(parsed.actions || []);
+          break;
+        case "suggestions":
+          result.suggestions.push(...parsed.suggestions || []);
+          callbacks.onSuggestions?.(parsed.suggestions || []);
+          break;
+        case "tx_ready":
+          if (this.verbose) process.stderr.write(`[SSE:tx_ready] raw: ${data.slice(0, 2e3)}
+`);
+          result.transactions.push(parsed);
+          callbacks.onTxReady?.(parsed);
+          break;
+        case "message":
+          result.message = parsed.message || parsed;
+          callbacks.onMessage?.(result.message);
+          break;
+        case "error":
+          callbacks.onError?.(parsed.error);
+          break;
+        case "done":
+          break;
       }
-      const hits = COMMANDS.filter((c) => c.startsWith(line));
-      const show = hits.length ? hits : COMMANDS;
-      return [show, line];
     } catch {
-      return [[], line];
     }
+  }
+  // ============================================================================
+  // Private helpers
+  // ============================================================================
+  async post(path3, body) {
+    const res = await fetch(`${this.baseUrl}${path3}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(`Request failed (${res.status}): ${errorBody.error || res.statusText}`);
+    }
+    return await res.json();
+  }
+  async delete(path3, body) {
+    const res = await fetch(`${this.baseUrl}${path3}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(`Delete failed (${res.status}): ${errorBody.error || res.statusText}`);
+    }
+  }
+};
+
+// src/agent/context.ts
+import { Chain as Chain8 } from "@vultisig/sdk";
+async function buildMessageContext(vault) {
+  const context = {
+    vault_address: vault.publicKeys.ecdsa,
+    vault_name: vault.name
   };
-}
-function completeFilePath(partial, filterVult) {
   try {
-    const endsWithSeparator = partial.endsWith("/") || partial.endsWith(path2.sep);
-    let dir;
-    let basename;
-    if (endsWithSeparator) {
-      dir = partial;
-      basename = "";
-    } else {
-      dir = path2.dirname(partial);
-      basename = path2.basename(partial);
-      if (fs2.existsSync(partial) && fs2.statSync(partial).isDirectory()) {
-        dir = partial;
-        basename = "";
+    const chains = vault.chains;
+    const addressEntries = await Promise.allSettled(
+      chains.map(async (chain) => ({
+        chain: chain.toString(),
+        address: await vault.address(chain)
+      }))
+    );
+    const addresses = {};
+    for (const result of addressEntries) {
+      if (result.status === "fulfilled") {
+        addresses[result.value.chain] = result.value.address;
       }
     }
-    const resolvedDir = path2.resolve(dir);
-    if (!fs2.existsSync(resolvedDir) || !fs2.statSync(resolvedDir).isDirectory()) {
-      return [[], partial];
+    context.addresses = addresses;
+  } catch {
+  }
+  try {
+    const balanceRecord = await vault.balances();
+    const balanceInfos = [];
+    for (const [key, balance] of Object.entries(balanceRecord)) {
+      balanceInfos.push({
+        chain: balance.chainId || key.split(":")[0] || "",
+        asset: balance.symbol || "",
+        symbol: balance.symbol || "",
+        amount: balance.formattedAmount || balance.amount?.toString() || "0",
+        decimals: balance.decimals || 18
+      });
     }
-    const files = fs2.readdirSync(resolvedDir);
-    const matches = files.filter((file) => file.startsWith(basename)).map((file) => {
-      const fullPath = path2.join(dir, file);
-      const stats = fs2.statSync(path2.join(resolvedDir, file));
-      if (stats.isDirectory()) {
-        return fullPath + "/";
-      }
-      if (filterVult) {
-        if (file.endsWith(".vult") || stats.isDirectory()) {
+    context.balances = balanceInfos;
+  } catch {
+  }
+  try {
+    const coins = [];
+    const chains = vault.chains;
+    for (const chain of chains) {
+      coins.push({
+        chain: chain.toString(),
+        ticker: getNativeTokenTicker(chain),
+        is_native_token: true,
+        decimals: getNativeTokenDecimals(chain)
+      });
+      const tokens = vault.tokens[chain] || [];
+      for (const token of tokens) {
+        coins.push({
+          chain: chain.toString(),
+          ticker: token.symbol || "",
+          contract_address: token.contractAddress || token.id,
+          is_native_token: false,
+          decimals: token.decimals || 18
+        });
+      }
+    }
+    context.coins = coins;
+  } catch {
+  }
+  return context;
+}
+function getNativeTokenTicker(chain) {
+  const tickers = {
+    [Chain8.Ethereum]: "ETH",
+    [Chain8.Bitcoin]: "BTC",
+    [Chain8.Solana]: "SOL",
+    [Chain8.THORChain]: "RUNE",
+    [Chain8.Cosmos]: "ATOM",
+    [Chain8.Avalanche]: "AVAX",
+    [Chain8.BSC]: "BNB",
+    [Chain8.Polygon]: "MATIC",
+    [Chain8.Arbitrum]: "ETH",
+    [Chain8.Optimism]: "ETH",
+    [Chain8.Base]: "ETH",
+    [Chain8.Blast]: "ETH",
+    [Chain8.Litecoin]: "LTC",
+    [Chain8.Dogecoin]: "DOGE",
+    [Chain8.Dash]: "DASH",
+    [Chain8.MayaChain]: "CACAO",
+    [Chain8.Polkadot]: "DOT",
+    [Chain8.Sui]: "SUI",
+    [Chain8.Ton]: "TON",
+    [Chain8.Tron]: "TRX",
+    [Chain8.Ripple]: "XRP",
+    [Chain8.Dydx]: "DYDX",
+    [Chain8.Osmosis]: "OSMO",
+    [Chain8.Terra]: "LUNA",
+    [Chain8.Noble]: "USDC",
+    [Chain8.Kujira]: "KUJI",
+    [Chain8.Zksync]: "ETH",
+    [Chain8.CronosChain]: "CRO"
+  };
+  return tickers[chain] || chain.toString();
+}
+function getNativeTokenDecimals(chain) {
+  const decimals = {
+    [Chain8.Bitcoin]: 8,
+    [Chain8.Litecoin]: 8,
+    [Chain8.Dogecoin]: 8,
+    [Chain8.Dash]: 8,
+    [Chain8.Solana]: 9,
+    [Chain8.Sui]: 9,
+    [Chain8.Ton]: 9,
+    [Chain8.Polkadot]: 10,
+    [Chain8.Cosmos]: 6,
+    [Chain8.THORChain]: 8,
+    [Chain8.MayaChain]: 10,
+    [Chain8.Osmosis]: 6,
+    [Chain8.Dydx]: 18,
+    [Chain8.Tron]: 6,
+    [Chain8.Ripple]: 6,
+    [Chain8.Noble]: 6,
+    [Chain8.Kujira]: 6,
+    [Chain8.Terra]: 6
+  };
+  return decimals[chain] || 18;
+}
+
+// src/agent/executor.ts
+import { Chain as Chain9, Vultisig as Vultisig6 } from "@vultisig/sdk";
+
+// src/agent/types.ts
+var AUTO_EXECUTE_ACTIONS = /* @__PURE__ */ new Set([
+  "add_chain",
+  "add_coin",
+  "remove_coin",
+  "remove_chain",
+  "address_book_add",
+  "address_book_remove",
+  "get_address_book",
+  "get_market_price",
+  "get_balances",
+  "get_portfolio",
+  "search_token",
+  "list_vaults",
+  "build_swap_tx",
+  "build_send_tx",
+  "build_custom_tx",
+  "build_tx",
+  "sign_tx",
+  "sign_typed_data",
+  "read_evm_contract",
+  "scan_tx",
+  "thorchain_query"
+]);
+var PASSWORD_REQUIRED_ACTIONS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data", "build_custom_tx"]);
+
+// src/agent/executor.ts
+var AgentExecutor = class {
+  vault;
+  pendingPayloads = /* @__PURE__ */ new Map();
+  password = null;
+  verbose;
+  constructor(vault, verbose = false) {
+    this.vault = vault;
+    this.verbose = verbose;
+  }
+  setPassword(password) {
+    this.password = password;
+  }
+  /**
+   * Store a server-built transaction (from tx_ready SSE event).
+   * This allows sign_tx to find and sign it when the backend requests signing.
+   */
+  storeServerTransaction(txReadyData) {
+    if (this.verbose) process.stderr.write(`[executor] storeServerTransaction called, keys: ${Object.keys(txReadyData || {}).join(",")}
+`);
+    const swapTx = txReadyData.swap_tx || txReadyData.send_tx || txReadyData.tx;
+    if (!swapTx) {
+      if (this.verbose) process.stderr.write(`[executor] storeServerTransaction: no swap_tx/send_tx/tx found in data
+`);
+      return;
+    }
+    const chain = resolveChainFromTxReady(txReadyData) || Chain9.Ethereum;
+    this.pendingPayloads.set("latest", {
+      payload: { __serverTx: true, ...txReadyData },
+      coin: { chain, address: "", decimals: 18, ticker: "" },
+      chain,
+      timestamp: Date.now()
+    });
+    if (this.verbose) process.stderr.write(`[executor] Stored server tx for chain ${chain}, pendingPayloads size=${this.pendingPayloads.size}
+`);
+  }
+  hasPendingTransaction() {
+    return this.pendingPayloads.has("latest");
+  }
+  shouldAutoExecute(action) {
+    return action.auto_execute === true || AUTO_EXECUTE_ACTIONS.has(action.type);
+  }
+  requiresPassword(action) {
+    return PASSWORD_REQUIRED_ACTIONS.has(action.type);
+  }
+  /**
+   * Execute a single action and return the result.
+   */
+  async executeAction(action) {
+    try {
+      const data = await this.dispatch(action);
+      return {
+        action: action.type,
+        action_id: action.id,
+        success: true,
+        data
+      };
+    } catch (err) {
+      return {
+        action: action.type,
+        action_id: action.id,
+        success: false,
+        error: err.message || String(err)
+      };
+    }
+  }
+  async dispatch(action) {
+    if (this.verbose) process.stderr.write(`[dispatch] action.type=${action.type} action.id=${action.id}
+`);
+    const params = action.params || {};
+    switch (action.type) {
+      case "get_balances":
+        return this.getBalances(params);
+      case "get_portfolio":
+        return this.getPortfolio(params);
+      case "add_chain":
+        return this.addChain(params);
+      case "remove_chain":
+        return this.removeChain(params);
+      case "add_coin":
+        return this.addCoin(params);
+      case "remove_coin":
+        return this.removeCoin(params);
+      case "build_send_tx":
+        return this.buildSendTx(params);
+      case "build_swap_tx":
+        return this.buildSwapTx(params);
+      case "build_tx":
+      case "build_custom_tx":
+        return this.buildTx(params);
+      case "sign_tx":
+        return this.signTx(params);
+      case "get_address_book":
+        return this.getAddressBook();
+      case "address_book_add":
+        return this.addAddressBookEntry(params);
+      case "address_book_remove":
+        return this.removeAddressBookEntry(params);
+      case "search_token":
+        return this.searchToken(params);
+      case "list_vaults":
+        return this.listVaults();
+      case "sign_typed_data":
+        return this.signTypedData(params);
+      case "scan_tx":
+        return this.scanTx(params);
+      case "read_evm_contract":
+        return this.readEvmContract(params);
+      default:
+        return { message: `Action type '${action.type}' not implemented locally` };
+    }
+  }
+  // ============================================================================
+  // Balance & Portfolio
+  // ============================================================================
+  async getBalances(params) {
+    const chainFilter = params.chain;
+    const tickerFilter = params.ticker;
+    const balanceRecord = await this.vault.balances();
+    let entries = Object.entries(balanceRecord).map(([key, b]) => ({
+      chain: b.chainId || key.split(":")[0] || "",
+      symbol: b.symbol || "",
+      amount: b.formattedAmount || b.amount?.toString() || "0",
+      decimals: b.decimals || 18,
+      raw_amount: b.amount?.toString()
+    }));
+    if (chainFilter) {
+      const chain = resolveChain(chainFilter);
+      if (chain) {
+        entries = entries.filter((b) => b.chain.toLowerCase() === chain.toLowerCase());
+      }
+    }
+    if (tickerFilter) {
+      entries = entries.filter((b) => b.symbol.toLowerCase() === tickerFilter.toLowerCase());
+    }
+    return { balances: entries };
+  }
+  async getPortfolio(_params) {
+    const balanceRecord = await this.vault.balances();
+    const entries = Object.entries(balanceRecord).map(([key, b]) => ({
+      chain: b.chainId || key.split(":")[0] || "",
+      symbol: b.symbol || "",
+      amount: b.formattedAmount || b.amount?.toString() || "0",
+      decimals: b.decimals || 18
+    }));
+    return { balances: entries };
+  }
+  // ============================================================================
+  // Chain & Token Management
+  // ============================================================================
+  async addChain(params) {
+    const chains = params.chains;
+    if (chains && Array.isArray(chains)) {
+      const results = [];
+      for (const c of chains) {
+        const name = typeof c === "string" ? c : c.chain;
+        const chain2 = resolveChain(name);
+        if (!chain2) throw new Error(`Unknown chain: ${name}`);
+        await this.vault.addChain(chain2);
+        const address2 = await this.vault.address(chain2);
+        results.push({ chain: chain2.toString(), address: address2 });
+      }
+      return { added: results };
+    }
+    const chainName = params.chain;
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    await this.vault.addChain(chain);
+    const address = await this.vault.address(chain);
+    return { chain: chain.toString(), address, added: true };
+  }
+  async removeChain(params) {
+    const chainName = params.chain;
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    await this.vault.removeChain(chain);
+    return { chain: chain.toString(), removed: true };
+  }
+  async addCoin(params) {
+    const tokens = params.tokens;
+    if (tokens && Array.isArray(tokens)) {
+      const results = [];
+      for (const t of tokens) {
+        const chain2 = resolveChain(t.chain);
+        if (!chain2) throw new Error(`Unknown chain: ${t.chain}`);
+        const symbol2 = t.symbol || t.ticker || "";
+        await this.vault.addToken(chain2, {
+          id: t.contract_address || t.contractAddress || "",
+          symbol: symbol2,
+          name: t.name || symbol2,
+          decimals: t.decimals || 18,
+          contractAddress: t.contract_address || t.contractAddress,
+          chainId: chain2.toString()
+        });
+        results.push({ chain: chain2.toString(), symbol: symbol2 });
+      }
+      return { added: results };
+    }
+    const chainName = params.chain;
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    const symbol = params.symbol || params.ticker;
+    await this.vault.addToken(chain, {
+      id: params.contract_address || params.contractAddress || "",
+      symbol,
+      name: params.name || symbol,
+      decimals: params.decimals || 18,
+      contractAddress: params.contract_address || params.contractAddress,
+      chainId: chain.toString()
+    });
+    return { chain: chain.toString(), symbol, added: true };
+  }
+  async removeCoin(params) {
+    const chainName = params.chain;
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    const tokenId = params.token_id || params.id || params.contract_address;
+    await this.vault.removeToken(chain, tokenId);
+    return { chain: chain.toString(), removed: true };
+  }
+  // ============================================================================
+  // Transaction Building
+  // ============================================================================
+  async buildSendTx(params) {
+    const chainName = params.chain || params.from_chain;
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    const symbol = params.symbol || params.ticker;
+    const toAddress = params.address || params.to || params.destination;
+    const amountStr = params.amount;
+    if (!toAddress) throw new Error("Destination address is required");
+    if (!amountStr) throw new Error("Amount is required");
+    const address = await this.vault.address(chain);
+    const balance = await this.vault.balance(chain, params.token_id);
+    const coin = {
+      chain,
+      address,
+      decimals: balance.decimals,
+      ticker: symbol || balance.symbol,
+      id: params.token_id
+    };
+    const amount = parseAmount(amountStr, balance.decimals);
+    const memo = params.memo;
+    const payload = await this.vault.prepareSendTx({ coin, receiver: toAddress, amount, memo });
+    const payloadId = `tx_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, { payload, coin, chain, timestamp: Date.now() });
+    this.pendingPayloads.set("latest", { payload, coin, chain, timestamp: Date.now() });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    return {
+      keysign_payload: payloadId,
+      from_chain: chain.toString(),
+      from_symbol: coin.ticker,
+      amount: amountStr,
+      sender: address,
+      destination: toAddress,
+      memo: memo || void 0,
+      message_hashes: messageHashes,
+      tx_details: {
+        chain: chain.toString(),
+        from: address,
+        to: toAddress,
+        amount: amountStr,
+        symbol: coin.ticker
+      }
+    };
+  }
+  async buildSwapTx(params) {
+    if (this.verbose) process.stderr.write(`[build_swap_tx] called with params: ${JSON.stringify(params).slice(0, 500)}
+`);
+    const fromChainName = params.from_chain || params.chain;
+    const toChainName = params.to_chain;
+    const fromChain = resolveChain(fromChainName);
+    const toChain = toChainName ? resolveChain(toChainName) : null;
+    if (!fromChain) throw new Error(`Unknown from_chain: ${fromChainName}`);
+    const amountStr = params.amount;
+    const fromSymbol = params.from_symbol || params.from_token || "";
+    const toSymbol = params.to_symbol || params.to_token || "";
+    const fromToken = params.from_contract || params.from_token_id;
+    const toToken = params.to_contract || params.to_token_id;
+    const fromCoin = { chain: fromChain, token: fromToken || void 0 };
+    const toCoin = { chain: toChain || fromChain, token: toToken || void 0 };
+    const quote = await this.vault.getSwapQuote({
+      fromCoin,
+      toCoin,
+      amount: parseFloat(amountStr)
+    });
+    const swapResult = await this.vault.prepareSwapTx({
+      fromCoin,
+      toCoin,
+      amount: parseFloat(amountStr),
+      swapQuote: quote,
+      autoApprove: true
+    });
+    const chain = fromChain;
+    const payload = swapResult.keysignPayload;
+    const payloadId = `swap_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, { payload, coin: { chain, address: "", decimals: 18, ticker: fromSymbol }, chain, timestamp: Date.now() });
+    this.pendingPayloads.set("latest", { payload, coin: { chain, address: "", decimals: 18, ticker: fromSymbol }, chain, timestamp: Date.now() });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    return {
+      keysign_payload: payloadId,
+      from_chain: fromChain.toString(),
+      to_chain: (toChain || fromChain).toString(),
+      from_symbol: fromSymbol,
+      to_symbol: toSymbol,
+      amount: amountStr,
+      estimated_output: quote.estimatedOutput?.toString(),
+      provider: quote.provider,
+      message_hashes: messageHashes
+    };
+  }
+  async buildTx(params) {
+    if (params.function_name && params.contract_address) {
+      return this.buildContractCallTx(params);
+    }
+    if (params.data || params.calldata || params.hex_payload) {
+      const txData = {
+        to: params.to || params.address || params.contract,
+        value: params.value || "0",
+        data: params.data || params.calldata || params.hex_payload,
+        chain: params.chain,
+        chain_id: params.chain_id
+      };
+      this.storeServerTransaction({
+        tx: txData,
+        chain: params.chain,
+        from_chain: params.chain
+      });
+      const chain = resolveChain(params.chain) || Chain9.Ethereum;
+      const address = await this.vault.address(chain);
+      return {
+        status: "ready",
+        chain: chain.toString(),
+        from: address,
+        to: txData.to,
+        value: txData.value,
+        has_calldata: true,
+        message: "Transaction built. Ready to sign."
+      };
+    }
+    return this.buildSendTx(params);
+  }
+  /**
+   * Build, sign, and broadcast an EVM contract call transaction from structured params.
+   * Encodes function_name + typed params into ABI calldata, then signs via signServerTx.
+   */
+  async buildContractCallTx(params) {
+    const chainName = params.chain || "Ethereum";
+    const chain = resolveChain(chainName);
+    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
+    const contractAddress = params.contract_address;
+    const functionName = params.function_name;
+    const typedParams = params.params;
+    const value = params.value || "0";
+    const calldata = await encodeContractCall(functionName, typedParams || []);
+    if (this.verbose) process.stderr.write(`[build_contract_tx] ${functionName}(${(typedParams || []).map((p) => p.type).join(",")}) on ${contractAddress} chain=${chain}
+`);
+    const serverTxData = {
+      __serverTx: true,
+      tx: {
+        to: contractAddress,
+        value,
+        data: calldata
+      },
+      chain: chainName,
+      from_chain: chainName
+    };
+    this.pendingPayloads.set("latest", {
+      payload: serverTxData,
+      coin: { chain, address: "", decimals: 18, ticker: "" },
+      chain,
+      timestamp: Date.now()
+    });
+    return this.signServerTx(serverTxData, chain, { chain: chainName });
+  }
+  // ============================================================================
+  // Transaction Signing
+  // ============================================================================
+  async signTx(params) {
+    if (this.verbose) process.stderr.write(`[sign_tx] params: ${JSON.stringify(params).slice(0, 500)}
+`);
+    if (this.verbose) process.stderr.write(`[sign_tx] pendingPayloads keys: ${[...this.pendingPayloads.keys()].join(", ")}
+`);
+    const payloadId = params.keysign_payload || params.payload_id || "latest";
+    const stored = this.pendingPayloads.get(payloadId);
+    if (!stored) {
+      throw new Error("No pending transaction to sign. Build a transaction first.");
+    }
+    const { payload, chain } = stored;
+    if (payload.__serverTx) {
+      return this.signServerTx(payload, chain, params);
+    }
+    return this.signSdkTx(payload, chain, payloadId);
+  }
+  /**
+   * Sign and broadcast an SDK-built transaction (keysign payload from local build methods).
+   */
+  async signSdkTx(payload, chain, payloadId) {
+    if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
+      if (this.password) {
+        await this.vault.unlock?.(this.password);
+      }
+    }
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    const signature = await this.vault.sign(
+      {
+        transaction: payload,
+        chain: payload.coin?.chain || chain,
+        messageHashes
+      },
+      {}
+    );
+    const txHash = await this.vault.broadcastTx({
+      chain,
+      keysignPayload: payload,
+      signature
+    });
+    this.pendingPayloads.delete(payloadId);
+    if (payloadId !== "latest") {
+      this.pendingPayloads.delete("latest");
+    }
+    const explorerUrl = Vultisig6.getTxExplorerUrl(chain, txHash);
+    return {
+      tx_hash: txHash,
+      chain: chain.toString(),
+      status: "pending",
+      explorer_url: explorerUrl
+    };
+  }
+  /**
+   * Sign and broadcast a server-built transaction (raw EVM tx from tx_ready SSE).
+   * Uses vault.prepareSendTx with memo field to carry the calldata.
+   */
+  async signServerTx(serverTxData, defaultChain, params) {
+    const swapTx = serverTxData.swap_tx || serverTxData.send_tx || serverTxData.tx;
+    if (!swapTx?.to) {
+      throw new Error("Server transaction missing required fields (to)");
+    }
+    const chainName = params.chain || serverTxData.chain || serverTxData.from_chain;
+    const chainId = serverTxData.chain_id || swapTx.chainId;
+    let chain = defaultChain;
+    if (chainName) {
+      chain = resolveChain(chainName) || defaultChain;
+    } else if (chainId) {
+      chain = resolveChainId(chainId) || defaultChain;
+    }
+    const address = await this.vault.address(chain);
+    const balance = await this.vault.balance(chain);
+    const coin = {
+      chain,
+      address,
+      decimals: balance.decimals || 18,
+      ticker: balance.symbol || chain.toString()
+    };
+    const amount = BigInt(swapTx.value || "0");
+    const hasCalldata = !!(swapTx.data && swapTx.data !== "0x");
+    if (this.verbose) process.stderr.write(`[sign_server_tx] chain=${chain}, to=${swapTx.to}, value=${swapTx.value}, amount=${amount}, hasCalldata=${hasCalldata}
+`);
+    if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
+      if (this.password) {
+        await this.vault.unlock?.(this.password);
+      }
+    }
+    const buildAmount = amount === 0n && hasCalldata ? 1n : amount;
+    const keysignPayload = await this.vault.prepareSendTx({
+      coin,
+      receiver: swapTx.to,
+      amount: buildAmount,
+      memo: swapTx.data
+    });
+    if (amount === 0n && hasCalldata) {
+      ;
+      keysignPayload.toAmount = "0";
+    }
+    const messageHashes = await this.vault.extractMessageHashes(keysignPayload);
+    const signature = await this.vault.sign(
+      {
+        transaction: keysignPayload,
+        chain,
+        messageHashes
+      },
+      {}
+    );
+    const txHash = await this.vault.broadcastTx({
+      chain,
+      keysignPayload,
+      signature
+    });
+    this.pendingPayloads.delete("latest");
+    const explorerUrl = Vultisig6.getTxExplorerUrl(chain, txHash);
+    return {
+      tx_hash: txHash,
+      chain: chain.toString(),
+      status: "pending",
+      explorer_url: explorerUrl
+    };
+  }
+  // ============================================================================
+  // EIP-712 Typed Data Signing
+  // ============================================================================
+  /**
+   * Sign EIP-712 typed data. Computes the EIP-712 hash and signs with vault.signBytes().
+   * Supports two formats:
+   * - Flat: { domain, types, message, primaryType } — single typed data
+   * - Payloads array: { payloads: [{id, domain, types, message, primaryType, chain}, ...] }
+   *   Used by Polymarket which requires signing both an Order and a ClobAuth.
+   */
+  async signTypedData(params) {
+    if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
+      if (this.password) {
+        await this.vault.unlock?.(this.password);
+      }
+    }
+    const payloads = params.payloads;
+    if (payloads && Array.isArray(payloads)) {
+      if (this.verbose) process.stderr.write(`[sign_typed_data] payloads mode, ${payloads.length} items
+`);
+      const signatures = [];
+      for (let i = 0; i < payloads.length; i++) {
+        const payload = payloads[i];
+        const id = payload.id || payload.name || "default";
+        if (i > 0) {
+          if (this.verbose) process.stderr.write(`[sign_typed_data] waiting 5s between MPC sessions...
+`);
+          await new Promise((r) => setTimeout(r, 5e3));
+        }
+        const sig = await this.signSingleTypedData(payload);
+        signatures.push({ id, ...sig });
+        if (this.verbose) process.stderr.write(`[sign_typed_data] signed payload "${id}"
+`);
+      }
+      return {
+        signatures,
+        pm_order_ref: params.pm_order_ref,
+        auto_submit: !!(params.__pm_auto_submit || params.auto_submit)
+      };
+    }
+    return this.signSingleTypedData(params);
+  }
+  /**
+   * Sign a single EIP-712 typed data object.
+   */
+  async signSingleTypedData(params) {
+    const domain = params.domain;
+    const types = params.types;
+    const message = params.message;
+    const primaryType = params.primaryType || params.primary_type;
+    if (!domain || !types || !message || !primaryType) {
+      throw new Error("sign_typed_data requires domain, types, message, and primaryType");
+    }
+    if (this.verbose) process.stderr.write(`[sign_typed_data] primaryType=${primaryType} domain.name=${domain.name}
+`);
+    const eip712Hash = await computeEIP712Hash(domain, types, primaryType, message);
+    if (this.verbose) process.stderr.write(`[sign_typed_data] hash=${eip712Hash}
+`);
+    const chainName = params.chain;
+    const chainId = domain.chainId;
+    let chain = Chain9.Ethereum;
+    if (chainName) {
+      chain = resolveChain(chainName) || Chain9.Ethereum;
+    } else if (chainId) {
+      chain = resolveChainId(chainId) || Chain9.Ethereum;
+    }
+    const sigResult = await this.vault.signBytes({
+      data: eip712Hash,
+      chain
+    });
+    if (this.verbose) process.stderr.write(`[sign_typed_data] signed, format=${sigResult.format}, recovery=${sigResult.recovery}
+`);
+    const { r, s } = parseDERSignature(sigResult.signature);
+    const v = (sigResult.recovery ?? 0) + 27;
+    const ethSignature = "0x" + r + s + v.toString(16).padStart(2, "0");
+    if (this.verbose) process.stderr.write(`[sign_typed_data] r=${r.slice(0, 16)}... s=${s.slice(0, 16)}... v=${v}
+`);
+    return {
+      signature: ethSignature,
+      r: "0x" + r,
+      s: "0x" + s,
+      v,
+      recovery: sigResult.recovery,
+      hash: eip712Hash
+    };
+  }
+  // ============================================================================
+  // Address Book
+  // ============================================================================
+  async getAddressBook() {
+    return { entries: [], message: "Address book retrieved" };
+  }
+  async addAddressBookEntry(params) {
+    return { added: true, name: params.name, address: params.address, chain: params.chain };
+  }
+  async removeAddressBookEntry(params) {
+    return { removed: true, address: params.address };
+  }
+  // ============================================================================
+  // Token Search & Other
+  // ============================================================================
+  async searchToken(params) {
+    return { message: `Token search for '${params.query || params.symbol}' - delegated to backend` };
+  }
+  async listVaults() {
+    return {
+      vaults: [{
+        name: this.vault.name,
+        id: this.vault.id,
+        type: this.vault.type,
+        chains: this.vault.chains.map((c) => c.toString())
+      }]
+    };
+  }
+  async scanTx(params) {
+    return { message: `Transaction scan for ${params.tx_hash || "unknown"} - delegated to backend` };
+  }
+  async readEvmContract(params) {
+    return { message: `EVM contract read for ${params.contract || "unknown"} - delegated to backend` };
+  }
+};
+async function encodeContractCall(functionName, params) {
+  const types = params.map((p) => p.type);
+  const sig = `${functionName}(${types.join(",")})`;
+  const selector = await keccak256Selector(sig);
+  let encoded = "";
+  for (const param of params) {
+    encoded += abiEncodeParam(param.type, param.value);
+  }
+  return "0x" + selector + encoded;
+}
+async function keccak256Selector(sig) {
+  const { keccak_256: keccak_2562 } = await Promise.resolve().then(() => (init_sha3(), sha3_exports));
+  const hash = keccak_2562(new TextEncoder().encode(sig));
+  return Buffer.from(hash).toString("hex").slice(0, 8);
+}
+function abiEncodeParam(type, value) {
+  if (type === "address") {
+    const addr = value.startsWith("0x") ? value.slice(2) : value;
+    return addr.toLowerCase().padStart(64, "0");
+  }
+  if (type.startsWith("uint") || type.startsWith("int")) {
+    const n = BigInt(value);
+    const hex = n.toString(16);
+    return hex.padStart(64, "0");
+  }
+  if (type === "bool") {
+    return (value === "true" || value === "1" ? "1" : "0").padStart(64, "0");
+  }
+  if (type === "bytes32") {
+    const b2 = value.startsWith("0x") ? value.slice(2) : value;
+    return b2.padEnd(64, "0");
+  }
+  const b = value.startsWith("0x") ? value.slice(2) : Buffer.from(value).toString("hex");
+  return b.padStart(64, "0");
+}
+function resolveChain(name) {
+  if (!name) return null;
+  if (Object.values(Chain9).includes(name)) {
+    return name;
+  }
+  const lower = name.toLowerCase();
+  for (const [, value] of Object.entries(Chain9)) {
+    if (typeof value === "string" && value.toLowerCase() === lower) {
+      return value;
+    }
+  }
+  const aliases = {
+    eth: "Ethereum",
+    btc: "Bitcoin",
+    sol: "Solana",
+    bnb: "BSC",
+    avax: "Avalanche",
+    matic: "Polygon",
+    arb: "Arbitrum",
+    op: "Optimism",
+    ltc: "Litecoin",
+    doge: "Dogecoin",
+    dot: "Polkadot",
+    atom: "Cosmos",
+    rune: "THORChain",
+    thor: "THORChain",
+    sui: "Sui",
+    ton: "Ton",
+    trx: "Tron",
+    xrp: "Ripple"
+  };
+  const aliased = aliases[lower];
+  if (aliased && Object.values(Chain9).includes(aliased)) {
+    return aliased;
+  }
+  return null;
+}
+function parseAmount(amountStr, decimals) {
+  const [whole, frac = ""] = amountStr.split(".");
+  const paddedFrac = frac.slice(0, decimals).padEnd(decimals, "0");
+  return BigInt(whole || "0") * 10n ** BigInt(decimals) + BigInt(paddedFrac || "0");
+}
+function resolveChainFromTxReady(txReadyData) {
+  if (txReadyData.chain) {
+    const chain = resolveChain(txReadyData.chain);
+    if (chain) return chain;
+  }
+  if (txReadyData.from_chain) {
+    const chain = resolveChain(txReadyData.from_chain);
+    if (chain) return chain;
+  }
+  if (txReadyData.chain_id) {
+    const chain = resolveChainId(txReadyData.chain_id);
+    if (chain) return chain;
+  }
+  const swapTx = txReadyData.swap_tx || txReadyData.send_tx || txReadyData.tx;
+  if (swapTx?.chainId) {
+    const chain = resolveChainId(swapTx.chainId);
+    if (chain) return chain;
+  }
+  return null;
+}
+function resolveChainId(chainId) {
+  const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
+  if (isNaN(id)) return null;
+  const chainIdMap = {
+    1: Chain9.Ethereum,
+    56: Chain9.BSC,
+    137: Chain9.Polygon,
+    43114: Chain9.Avalanche,
+    42161: Chain9.Arbitrum,
+    10: Chain9.Optimism,
+    8453: Chain9.Base,
+    81457: Chain9.Blast,
+    324: Chain9.Zksync,
+    25: Chain9.CronosChain
+  };
+  return chainIdMap[id] || null;
+}
+async function computeEIP712Hash(domain, types, primaryType, message) {
+  const { keccak_256: keccak_2562 } = await Promise.resolve().then(() => (init_sha3(), sha3_exports));
+  const domainSeparator = hashStruct("EIP712Domain", domain, types, keccak_2562);
+  const messageHash = hashStruct(primaryType, message, types, keccak_2562);
+  const prefix = new Uint8Array([25, 1]);
+  const combined = new Uint8Array(2 + 32 + 32);
+  combined.set(prefix, 0);
+  combined.set(domainSeparator, 2);
+  combined.set(messageHash, 34);
+  const finalHash = keccak_2562(combined);
+  return "0x" + Buffer.from(finalHash).toString("hex");
+}
+function hashStruct(typeName, data, types, keccak) {
+  const typeHash = hashType(typeName, types, keccak);
+  const encodedData = encodeData(typeName, data, types, keccak);
+  const combined = new Uint8Array(32 + encodedData.length);
+  combined.set(typeHash, 0);
+  combined.set(encodedData, 32);
+  return keccak(combined);
+}
+function hashType(typeName, types, keccak) {
+  const encoded = encodeType(typeName, types);
+  return keccak(new TextEncoder().encode(encoded));
+}
+function encodeType(typeName, types) {
+  const fields = getTypeFields(typeName, types);
+  if (!fields) return "";
+  const refs = /* @__PURE__ */ new Set();
+  findReferencedTypes(typeName, types, refs);
+  refs.delete(typeName);
+  const sortedRefs = [...refs].sort();
+  let result = `${typeName}(${fields.map((f) => `${f.type} ${f.name}`).join(",")})`;
+  for (const ref of sortedRefs) {
+    const refFields = getTypeFields(ref, types);
+    if (refFields) {
+      result += `${ref}(${refFields.map((f) => `${f.type} ${f.name}`).join(",")})`;
+    }
+  }
+  return result;
+}
+function findReferencedTypes(typeName, types, refs) {
+  if (refs.has(typeName)) return;
+  const fields = getTypeFields(typeName, types);
+  if (!fields) return;
+  refs.add(typeName);
+  for (const field of fields) {
+    const baseType = field.type.replace(/\[\d*\]$/, "");
+    if (types[baseType]) {
+      findReferencedTypes(baseType, types, refs);
+    }
+  }
+}
+function getTypeFields(typeName, types) {
+  if (types[typeName]) return types[typeName];
+  if (typeName === "EIP712Domain") {
+    return [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ];
+  }
+  return void 0;
+}
+function encodeData(typeName, data, types, keccak) {
+  const fields = getTypeFields(typeName, types);
+  if (!fields) return new Uint8Array(0);
+  const chunks = [];
+  for (const field of fields) {
+    const value = data[field.name];
+    if (value === void 0 || value === null) continue;
+    chunks.push(encodeField(field.type, value, types, keccak));
+  }
+  const totalLen = chunks.reduce((sum, c) => sum + c.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function encodeField(type, value, types, keccak) {
+  if (type === "string") {
+    return keccak(new TextEncoder().encode(value));
+  }
+  if (type === "bytes") {
+    const hex2 = value.startsWith("0x") ? value.slice(2) : value;
+    const bytes2 = hexToBytes(hex2);
+    return keccak(bytes2);
+  }
+  const baseType = type.replace(/\[\d*\]$/, "");
+  if (types[baseType] && !type.endsWith("]")) {
+    return hashStruct(baseType, value, types, keccak);
+  }
+  if (type.endsWith("]")) {
+    const arr = value;
+    const elementType = type.replace(/\[\d*\]$/, "");
+    const encodedElements = arr.map((el) => encodeField(elementType, el, types, keccak));
+    const totalLen = encodedElements.reduce((sum, e) => sum + e.length, 0);
+    const concat = new Uint8Array(totalLen);
+    let off = 0;
+    for (const el of encodedElements) {
+      concat.set(el, off);
+      off += el.length;
+    }
+    return keccak(concat);
+  }
+  const result = new Uint8Array(32);
+  if (type === "address") {
+    const addr = value.startsWith("0x") ? value.slice(2) : value;
+    const bytes2 = hexToBytes(addr.toLowerCase());
+    result.set(bytes2, 32 - bytes2.length);
+    return result;
+  }
+  if (type === "bool") {
+    if (value === true || value === "true" || value === 1 || value === "1") {
+      result[31] = 1;
+    }
+    return result;
+  }
+  if (type.startsWith("uint") || type.startsWith("int")) {
+    const n2 = BigInt(value);
+    const hex2 = n2.toString(16).padStart(64, "0");
+    const bytes2 = hexToBytes(hex2);
+    result.set(bytes2, 32 - bytes2.length);
+    return result;
+  }
+  if (type.startsWith("bytes")) {
+    const hex2 = value.startsWith("0x") ? value.slice(2) : value;
+    const bytes2 = hexToBytes(hex2);
+    result.set(bytes2, 0);
+    return result;
+  }
+  const n = BigInt(value);
+  const hex = n.toString(16).padStart(64, "0");
+  const bytes = hexToBytes(hex);
+  result.set(bytes, 32 - bytes.length);
+  return result;
+}
+function hexToBytes(hex) {
+  const clean2 = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const padded = clean2.length % 2 === 1 ? "0" + clean2 : clean2;
+  const bytes = new Uint8Array(padded.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function parseDERSignature(sigHex) {
+  const raw = sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex;
+  if (raw.length === 128) {
+    return { r: raw.slice(0, 64), s: raw.slice(64) };
+  }
+  let offset = 0;
+  if (raw.slice(offset, offset + 2) !== "30") {
+    return { r: raw.slice(0, 64).padStart(64, "0"), s: raw.slice(64).padStart(64, "0") };
+  }
+  offset += 2;
+  offset += 2;
+  if (raw.slice(offset, offset + 2) !== "02") throw new Error("Invalid DER: expected 02 for R");
+  offset += 2;
+  const rLen = parseInt(raw.slice(offset, offset + 2), 16);
+  offset += 2;
+  let rHex = raw.slice(offset, offset + rLen * 2);
+  offset += rLen * 2;
+  if (rHex.length > 64 && rHex.startsWith("00")) {
+    rHex = rHex.slice(rHex.length - 64);
+  }
+  rHex = rHex.padStart(64, "0");
+  if (raw.slice(offset, offset + 2) !== "02") throw new Error("Invalid DER: expected 02 for S");
+  offset += 2;
+  const sLen = parseInt(raw.slice(offset, offset + 2), 16);
+  offset += 2;
+  let sHex = raw.slice(offset, offset + sLen * 2);
+  if (sHex.length > 64 && sHex.startsWith("00")) {
+    sHex = sHex.slice(sHex.length - 64);
+  }
+  sHex = sHex.padStart(64, "0");
+  return { r: rHex, s: sHex };
+}
+
+// src/agent/pipe.ts
+import * as readline from "node:readline";
+var PipeInterface = class {
+  session;
+  rl = null;
+  stopped = false;
+  pendingPasswordResolve = null;
+  pendingConfirmResolve = null;
+  constructor(session) {
+    this.session = session;
+    process.stdin.pause();
+  }
+  /**
+   * Start the pipe interface.
+   */
+  async start(vaultName, addresses) {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: void 0,
+      // Don't write prompts to stdout
+      terminal: false
+    });
+    this.emit({ type: "ready", vault: vaultName, addresses });
+    const lines = [];
+    let inputDone = false;
+    let processing = false;
+    this.rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      lines.push(trimmed);
+      if (!processing) {
+        processing = true;
+        while (lines.length > 0) {
+          const nextLine = lines.shift();
+          try {
+            const cmd = JSON.parse(nextLine);
+            await this.handleCommand(cmd);
+          } catch (err) {
+            this.emit({ type: "error", message: `Invalid input: ${err.message}` });
+          }
+        }
+        processing = false;
+        if (inputDone && lines.length === 0) {
+          this.stop();
+        }
+      }
+    });
+    this.rl.on("close", () => {
+      inputDone = true;
+      if (!processing && lines.length === 0) {
+        this.stop();
+      }
+    });
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (this.stopped) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.rl?.close();
+    this.session.dispose();
+  }
+  /**
+   * Get UI callbacks for the session.
+   */
+  getCallbacks() {
+    return {
+      onTextDelta: (delta) => {
+        this.emit({ type: "text_delta", delta });
+      },
+      onToolCall: (id, action, params) => {
+        this.emit({ type: "tool_call", id, action, params, status: "running" });
+      },
+      onToolResult: (id, action, success2, data, error2) => {
+        this.emit({ type: "tool_result", id, action, success: success2, data, error: error2 });
+      },
+      onAssistantMessage: (content) => {
+        this.emit({ type: "assistant", content });
+      },
+      onSuggestions: (suggestions) => {
+        this.emit({ type: "suggestions", suggestions });
+      },
+      onTxStatus: (txHash, chain, status, explorerUrl) => {
+        this.emit({
+          type: "tx_status",
+          tx_hash: txHash,
+          chain,
+          status,
+          explorer_url: explorerUrl
+        });
+      },
+      onError: (message) => {
+        this.emit({ type: "error", message });
+      },
+      onDone: () => {
+        this.emit({ type: "done" });
+      },
+      requestPassword: async () => {
+        return new Promise((resolve) => {
+          this.pendingPasswordResolve = resolve;
+          this.emit({ type: "error", message: "PASSWORD_REQUIRED" });
+        });
+      },
+      requestConfirmation: async (message) => {
+        return new Promise((resolve) => {
+          this.pendingConfirmResolve = resolve;
+          this.emit({ type: "error", message: `CONFIRMATION_REQUIRED: ${message}` });
+        });
+      }
+    };
+  }
+  async handleCommand(cmd) {
+    switch (cmd.type) {
+      case "message": {
+        const callbacks = this.getCallbacks();
+        try {
+          await this.session.sendMessage(cmd.content, callbacks);
+        } catch (err) {
+          this.emit({ type: "error", message: err.message });
+          this.emit({ type: "done" });
+        }
+        break;
+      }
+      case "password": {
+        if (this.pendingPasswordResolve) {
+          this.pendingPasswordResolve(cmd.password);
+          this.pendingPasswordResolve = null;
+        }
+        break;
+      }
+      case "confirm": {
+        if (this.pendingConfirmResolve) {
+          this.pendingConfirmResolve(cmd.confirmed);
+          this.pendingConfirmResolve = null;
+        }
+        break;
+      }
+      default:
+        this.emit({ type: "error", message: `Unknown command type: ${cmd.type}` });
+    }
+  }
+  emit(event) {
+    process.stdout.write(JSON.stringify(event) + "\n");
+  }
+};
+
+// src/agent/session.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var AgentSession = class {
+  client;
+  vault;
+  executor;
+  config;
+  conversationId = null;
+  publicKey;
+  cachedContext = null;
+  abortController = null;
+  constructor(vault, config) {
+    this.vault = vault;
+    this.config = config;
+    this.client = new AgentClient(config.backendUrl);
+    this.client.verbose = !!config.verbose;
+    this.executor = new AgentExecutor(vault, !!config.verbose);
+    this.publicKey = vault.publicKeys.ecdsa;
+    if (config.password) {
+      this.executor.setPassword(config.password);
+    }
+  }
+  /**
+   * Initialize the session: health check, authenticate, create conversation.
+   */
+  async initialize(ui) {
+    const healthy = await this.client.healthCheck();
+    if (!healthy) {
+      throw new Error(`Agent backend unreachable at ${this.config.backendUrl}`);
+    }
+    try {
+      if (this.vault.isEncrypted) {
+        const password = this.config.password || await ui.requestPassword();
+        await this.vault.unlock?.(password);
+        this.executor.setPassword(password);
+      }
+      const cached = loadCachedToken(this.publicKey);
+      if (cached) {
+        this.client.setAuthToken(cached);
+      } else {
+        const auth = await authenticateVault(this.client, this.vault, this.config.password);
+        this.client.setAuthToken(auth.token);
+        saveCachedToken(this.publicKey, auth.token, auth.expiresAt);
+      }
+    } catch (err) {
+      throw new Error(`Authentication failed: ${err.message}`);
+    }
+    if (this.config.conversationId) {
+      this.conversationId = this.config.conversationId;
+    } else {
+      const conv = await this.client.createConversation(this.publicKey);
+      this.conversationId = conv.id;
+    }
+    this.cachedContext = await buildMessageContext(this.vault);
+  }
+  getConversationId() {
+    return this.conversationId;
+  }
+  getVaultAddresses() {
+    return this.cachedContext?.addresses || {};
+  }
+  /**
+   * Send a user message and process the full response cycle.
+   *
+   * Flow:
+   * 1. Send message to backend via SSE stream
+   * 2. Collect text deltas and actions
+   * 3. Execute auto-execute actions locally
+   * 4. Report results back to backend
+   * 5. Repeat if backend sends more actions
+   */
+  async sendMessage(content, ui) {
+    if (!this.conversationId) {
+      throw new Error("Session not initialized");
+    }
+    this.abortController = new AbortController();
+    try {
+      this.cachedContext = await buildMessageContext(this.vault);
+    } catch {
+    }
+    try {
+      await this.processMessageLoop(content, null, ui);
+    } catch (err) {
+      if (err.message?.includes("401") || err.message?.includes("403")) {
+        clearCachedToken(this.publicKey);
+        const auth = await authenticateVault(this.client, this.vault, this.config.password);
+        this.client.setAuthToken(auth.token);
+        saveCachedToken(this.publicKey, auth.token, auth.expiresAt);
+        await this.processMessageLoop(content, null, ui);
+      } else {
+        throw err;
+      }
+    } finally {
+      this.abortController = null;
+    }
+  }
+  /**
+   * Core message processing loop.
+   * Sends content or action results, executes returned actions, repeats.
+   */
+  async processMessageLoop(content, actionResults, ui) {
+    if (!this.conversationId) return;
+    const request = {
+      public_key: this.publicKey,
+      context: this.cachedContext
+    };
+    if (content) {
+      request.content = content;
+    }
+    if (actionResults && actionResults.length > 0) {
+      const result = actionResults[0];
+      request.action_result = {
+        action: result.action,
+        action_id: result.action_id,
+        success: result.success,
+        data: result.data || {},
+        error: result.error || ""
+      };
+    }
+    const streamResult = await this.client.sendMessageStream(
+      this.conversationId,
+      request,
+      {
+        onTextDelta: (delta) => ui.onTextDelta(delta),
+        onToolProgress: (tool, status, label) => {
+          if (status === "running") {
+            ui.onToolCall(`mcp-${tool}`, tool);
+          } else {
+            ui.onToolResult(`mcp-${tool}`, tool, true, { label });
+          }
+        },
+        onTitle: (_title) => {
+        },
+        onActions: (_actions) => {
+        },
+        onSuggestions: (suggestions) => {
+          ui.onSuggestions(suggestions);
+        },
+        onTxReady: (tx) => {
+          this.executor.storeServerTransaction(tx);
+          if (this.config.password) {
+            this.executor.setPassword(this.config.password);
+          }
+        },
+        onMessage: (_msg) => {
+        },
+        onError: (error2) => {
+          ui.onError(error2);
+        }
+      },
+      this.abortController?.signal
+    );
+    const responseText = streamResult.fullText || streamResult.message?.content || "";
+    const inlineActions = parseInlineToolCalls(responseText);
+    if (inlineActions.length > 0) {
+      const cleanText = responseText.replace(/<invoke\s+name="[^"]*">[\s\S]*?<\/invoke>/g, "").replace(/<\/?minimax:tool_call>/g, "").trim();
+      if (cleanText) {
+        ui.onAssistantMessage(cleanText);
+      }
+      streamResult.actions.push(...inlineActions);
+    } else if (responseText) {
+      ui.onAssistantMessage(responseText);
+    }
+    const nonSignActions = streamResult.actions.filter((a) => a.type !== "sign_tx");
+    const backendSignActions = streamResult.actions.filter((a) => a.type === "sign_tx");
+    if (nonSignActions.length > 0) {
+      const results = await this.executeActions(nonSignActions, ui);
+      const hasBuildSuccess = results.some(
+        (r) => r.success && r.action.startsWith("build_")
+      );
+      if (hasBuildSuccess && this.executor.hasPendingTransaction()) {
+        if (this.config.verbose) process.stderr.write(`[session] build_* action produced pending tx, auto-chaining sign_tx
+`);
+        const signAction = {
+          id: `tx_sign_${Date.now()}`,
+          type: "sign_tx",
+          title: "Sign transaction",
+          params: {},
+          auto_execute: true
+        };
+        const signResults = await this.executeActions([signAction], ui);
+        const allResults = [...results, ...signResults];
+        for (const result of allResults) {
+          await this.processMessageLoop(null, [result], ui);
+        }
+        return;
+      }
+      if (results.length > 0) {
+        for (const result of results) {
+          await this.processMessageLoop(null, [result], ui);
+        }
+        return;
+      }
+    }
+    if (streamResult.transactions.length > 0 && this.executor.hasPendingTransaction()) {
+      if (this.config.verbose) process.stderr.write(`[session] ${streamResult.transactions.length} tx_ready events, signing client-side
+`);
+      const signAction = {
+        id: `tx_sign_${Date.now()}`,
+        type: "sign_tx",
+        title: "Sign transaction",
+        params: {},
+        auto_execute: true
+      };
+      const results = await this.executeActions([signAction], ui);
+      if (results.length > 0) {
+        for (const result of results) {
+          await this.processMessageLoop(null, [result], ui);
+        }
+        return;
+      }
+    } else if (backendSignActions.length > 0 && this.executor.hasPendingTransaction()) {
+      if (this.config.verbose) process.stderr.write(`[session] Backend sent sign_tx action, using it
+`);
+      const results = await this.executeActions(backendSignActions, ui);
+      if (results.length > 0) {
+        for (const result of results) {
+          await this.processMessageLoop(null, [result], ui);
+        }
+        return;
+      }
+    } else if (backendSignActions.length > 0 && !this.executor.hasPendingTransaction()) {
+      if (this.config.verbose) process.stderr.write(`[session] Backend sent sign_tx but no pending tx, reporting error
+`);
+      const errorResult = {
+        action: "sign_tx",
+        action_id: backendSignActions[0].id,
+        success: false,
+        error: "No pending transaction. The swap transaction data was not received."
+      };
+      await this.processMessageLoop(null, [errorResult], ui);
+      return;
+    }
+    ui.onDone();
+  }
+  /**
+   * Execute a list of actions, handling password requirements.
+   */
+  async executeActions(actions, ui) {
+    const results = [];
+    for (const action of actions) {
+      if (!this.executor.shouldAutoExecute(action)) {
+        continue;
+      }
+      if (PASSWORD_REQUIRED_ACTIONS.has(action.type)) {
+        if (!this.config.password) {
+          try {
+            const password = await ui.requestPassword();
+            this.executor.setPassword(password);
+            this.config.password = password;
+          } catch {
+            results.push({
+              action: action.type,
+              action_id: action.id,
+              success: false,
+              error: "Password not provided"
+            });
+            continue;
+          }
+        }
+      }
+      ui.onToolCall(action.id, action.type, action.params);
+      const result = await this.executor.executeAction(action);
+      results.push(result);
+      ui.onToolResult(action.id, action.type, result.success, result.data, result.error);
+      if (action.type === "sign_tx" && result.success && result.data) {
+        const txHash = result.data.tx_hash;
+        const chain = result.data.chain;
+        const explorerUrl = result.data.explorer_url;
+        if (txHash) {
+          ui.onTxStatus(txHash, chain, "pending", explorerUrl);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Cancel the current operation.
+   */
+  cancel() {
+    this.abortController?.abort();
+  }
+  /**
+   * Clean up session resources.
+   */
+  dispose() {
+    this.cancel();
+    this.cachedContext = null;
+    this.conversationId = null;
+  }
+};
+function parseInlineToolCalls(text) {
+  const actions = [];
+  const invokeRegex = /<invoke\s+name="([^"]+)">([\s\S]*?)<\/invoke>/g;
+  let match;
+  while ((match = invokeRegex.exec(text)) !== null) {
+    const actionType = match[1];
+    const body = match[2];
+    const params = {};
+    const paramRegex = /<parameter\s+name="([^"]+)">([\s\S]*?)<\/parameter>/g;
+    let paramMatch;
+    while ((paramMatch = paramRegex.exec(body)) !== null) {
+      const key = paramMatch[1];
+      const value = paramMatch[2];
+      try {
+        params[key] = JSON.parse(value);
+      } catch {
+        params[key] = value;
+      }
+    }
+    actions.push({
+      id: `inline_${actionType}_${Date.now()}`,
+      type: actionType,
+      title: actionType,
+      params,
+      auto_execute: true
+    });
+  }
+  return actions;
+}
+function getTokenCachePath() {
+  const dir = process.env.VULTISIG_CONFIG_DIR ?? join(homedir(), ".vultisig");
+  return join(dir, "agent-tokens.json");
+}
+function readTokenStore() {
+  try {
+    const path3 = getTokenCachePath();
+    if (!existsSync(path3)) return {};
+    return JSON.parse(readFileSync(path3, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeTokenStore(store) {
+  const path3 = getTokenCachePath();
+  const dir = join(path3, "..");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path3, JSON.stringify(store, null, 2), { mode: 384 });
+}
+function loadCachedToken(publicKey) {
+  const store = readTokenStore();
+  const entry = store[publicKey];
+  if (!entry) return null;
+  const now = Date.now();
+  const expiresMs = entry.expiresAt * (entry.expiresAt < 1e12 ? 1e3 : 1);
+  if (now >= expiresMs - 6e4) {
+    delete store[publicKey];
+    try {
+      writeTokenStore(store);
+    } catch {
+    }
+    return null;
+  }
+  return entry.token;
+}
+function saveCachedToken(publicKey, token, expiresAt) {
+  const store = readTokenStore();
+  store[publicKey] = { token, expiresAt };
+  try {
+    writeTokenStore(store);
+  } catch {
+  }
+}
+function clearCachedToken(publicKey) {
+  const store = readTokenStore();
+  delete store[publicKey];
+  try {
+    writeTokenStore(store);
+  } catch {
+  }
+}
+
+// src/agent/tui.ts
+import * as readline2 from "node:readline";
+import chalk8 from "chalk";
+var ChatTUI = class {
+  rl;
+  session;
+  isStreaming = false;
+  currentStreamText = "";
+  vaultName;
+  stopped = false;
+  verbose;
+  constructor(session, vaultName, verbose = false) {
+    this.session = session;
+    this.vaultName = vaultName;
+    this.verbose = verbose;
+    this.rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: "",
+      terminal: true
+    });
+  }
+  /**
+   * Start the interactive chat loop.
+   */
+  async start() {
+    this.printHeader();
+    this.printHelp();
+    this.showPrompt();
+    this.rl.on("line", async (line) => {
+      const input = line.trim();
+      readline2.moveCursor(process.stdout, 0, -1);
+      readline2.clearLine(process.stdout, 0);
+      if (!input) {
+        this.showPrompt();
+        return;
+      }
+      if (input === "/quit" || input === "/exit" || input === "/q") {
+        this.stop();
+        return;
+      }
+      if (input === "/help" || input === "/h") {
+        this.printHelp();
+        this.showPrompt();
+        return;
+      }
+      if (input === "/clear") {
+        console.clear();
+        this.printHeader();
+        this.showPrompt();
+        return;
+      }
+      this.printUserMessage(input);
+      await this.handleMessage(input);
+      this.showPrompt();
+    });
+    this.rl.on("close", () => {
+      this.stop();
+    });
+    process.on("SIGINT", () => {
+      if (this.isStreaming) {
+        this.session.cancel();
+        this.isStreaming = false;
+        console.log(chalk8.yellow("\n  [cancelled]"));
+        this.showPrompt();
+      } else {
+        this.stop();
+      }
+    });
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (this.stopped) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    console.log(chalk8.gray("\n  Goodbye!\n"));
+    this.rl.close();
+    this.session.dispose();
+  }
+  /**
+   * Get UI callbacks for the session.
+   */
+  getCallbacks() {
+    return {
+      onTextDelta: (delta) => {
+        if (!this.isStreaming) {
+          this.isStreaming = true;
+          this.currentStreamText = "";
+          const ts = this.timestamp();
+          process.stdout.write(`${chalk8.gray(ts)} ${chalk8.cyan.bold("Agent")}: `);
+        }
+        this.currentStreamText += delta;
+      },
+      onToolCall: (_id, action, params) => {
+        if (this.isStreaming) {
+          process.stdout.write("\n");
+          this.isStreaming = false;
+        }
+        if (this.verbose) {
+          const paramStr = params ? chalk8.gray(` ${JSON.stringify(params).slice(0, 80)}`) : "";
+          console.log(`  ${chalk8.yellow("\u26A1")} ${chalk8.yellow(action)}${paramStr} ${chalk8.gray("...")}`);
+        } else {
+          console.log(`  ${chalk8.yellow("\u26A1")} ${chalk8.yellow(action)} ${chalk8.gray("...")}`);
+        }
+      },
+      onToolResult: (_id, action, success2, data, error2) => {
+        if (success2) {
+          if (this.verbose) {
+            const summary = data ? summarizeData(data) : "";
+            console.log(`  ${chalk8.green("\u2713")} ${chalk8.green(action)}${summary ? chalk8.gray(` \u2192 ${summary}`) : ""}`);
+          } else {
+            console.log(`  ${chalk8.green("\u2713")} ${chalk8.green(action)}`);
+          }
+        } else {
+          console.log(`  ${chalk8.red("\u2717")} ${chalk8.red(action)}: ${chalk8.red(error2 || "failed")}`);
+        }
+      },
+      onAssistantMessage: (content) => {
+        if (this.isStreaming) {
+          process.stdout.write(renderMarkdown(this.currentStreamText) + "\n");
+          this.isStreaming = false;
+        } else if (content && content !== this.currentStreamText) {
+          const ts = this.timestamp();
+          console.log(`${chalk8.gray(ts)} ${chalk8.cyan.bold("Agent")}: ${renderMarkdown(content)}`);
+        }
+        this.currentStreamText = "";
+      },
+      onSuggestions: (suggestions) => {
+        if (suggestions.length > 0) {
+          console.log(chalk8.gray("  Suggestions:"));
+          for (const s of suggestions) {
+            console.log(chalk8.gray(`    \u2022 ${s.title}`));
+          }
+        }
+      },
+      onTxStatus: (txHash, chain, status, explorerUrl) => {
+        const statusIcon = status === "confirmed" ? chalk8.green("\u2713") : status === "failed" ? chalk8.red("\u2717") : chalk8.yellow("\u23F3");
+        console.log(`  ${statusIcon} ${chalk8.bold("TX")} [${chain}]: ${txHash.slice(0, 12)}...${txHash.slice(-8)}`);
+        if (explorerUrl) {
+          console.log(`     ${chalk8.blue.underline(explorerUrl)}`);
+        }
+      },
+      onError: (message) => {
+        if (this.isStreaming) {
+          process.stdout.write("\n");
+          this.isStreaming = false;
+        }
+        console.log(`  ${chalk8.red("Error")}: ${message}`);
+      },
+      onDone: () => {
+        if (this.isStreaming) {
+          process.stdout.write(renderMarkdown(this.currentStreamText) + "\n");
+          this.isStreaming = false;
+          this.currentStreamText = "";
+        }
+      },
+      requestPassword: async () => {
+        return new Promise((resolve, reject) => {
+          const rl2 = readline2.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true
+          });
+          if (process.stdin.isTTY) {
+            process.stdout.write(chalk8.yellow("  \u{1F510} Enter vault password: "));
+            const wasRaw = process.stdin.isRaw;
+            process.stdin.setRawMode(true);
+            let password = "";
+            const onData = (key) => {
+              const ch = key.toString();
+              if (ch === "\r" || ch === "\n") {
+                process.stdin.setRawMode(wasRaw || false);
+                process.stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+                rl2.close();
+                resolve(password);
+              } else if (ch === "") {
+                process.stdin.setRawMode(wasRaw || false);
+                process.stdin.removeListener("data", onData);
+                rl2.close();
+                reject(new Error("Password input cancelled"));
+              } else if (ch === "\x7F" || ch === "\b") {
+                if (password.length > 0) {
+                  password = password.slice(0, -1);
+                  process.stdout.write("\b \b");
+                }
+              } else if (ch.charCodeAt(0) >= 32) {
+                password += ch;
+                process.stdout.write("*");
+              }
+            };
+            process.stdin.on("data", onData);
+          } else {
+            rl2.question("Password: ", (answer) => {
+              rl2.close();
+              resolve(answer.trim());
+            });
+          }
+        });
+      },
+      requestConfirmation: async (message) => {
+        return new Promise((resolve) => {
+          this.rl.question(chalk8.yellow(`  ${message} (y/N): `), (answer) => {
+            resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+          });
+        });
+      }
+    };
+  }
+  async handleMessage(content) {
+    const callbacks = this.getCallbacks();
+    this.isStreaming = false;
+    try {
+      await this.session.sendMessage(content, callbacks);
+    } catch (err) {
+      if (err.name === "AbortError") {
+        console.log(chalk8.yellow("  [cancelled]"));
+      } else {
+        console.log(chalk8.red(`  Error: ${err.message}`));
+      }
+    }
+  }
+  printHeader() {
+    console.log("");
+    console.log(chalk8.bold.cyan(`  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`));
+    console.log(chalk8.bold.cyan(`  \u2551`) + chalk8.bold(`     Vultisig Agent - ${this.vaultName}`.padEnd(38).slice(0, 38)) + chalk8.bold.cyan(`\u2551`));
+    console.log(chalk8.bold.cyan(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`));
+    console.log("");
+  }
+  printHelp() {
+    console.log(chalk8.gray("  Commands: /help, /clear, /quit"));
+    console.log(chalk8.gray("  Press Ctrl+C to cancel a response, or to exit"));
+    console.log("");
+  }
+  printUserMessage(content) {
+    const ts = this.timestamp();
+    console.log(`${chalk8.gray(ts)} ${chalk8.green.bold("You")}: ${content}`);
+  }
+  showPrompt() {
+    if (this.stopped) return;
+    const prompt = chalk8.gray(`${this.timestamp()} `) + chalk8.green.bold("You") + ": ";
+    this.rl.setPrompt(prompt);
+    this.rl.prompt();
+  }
+  timestamp() {
+    const now = /* @__PURE__ */ new Date();
+    return `[${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}]`;
+  }
+};
+function renderMarkdown(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, (_m, p1) => chalk8.bold(p1)).replace(/__(.+?)__/g, (_m, p1) => chalk8.bold(p1)).replace(/(?<!\w)\*([^*]+?)\*(?!\w)/g, (_m, p1) => chalk8.italic(p1)).replace(/(?<!\w)_([^_]+?)_(?!\w)/g, (_m, p1) => chalk8.italic(p1)).replace(/`([^`]+?)`/g, (_m, p1) => chalk8.cyan(p1)).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, p1, p2) => `${p1} ${chalk8.blue.underline(`(${p2})`)}`);
+}
+function summarizeData(data) {
+  if (data.balances && Array.isArray(data.balances)) {
+    const balances = data.balances;
+    if (balances.length === 1) {
+      return `${balances[0].amount} ${balances[0].symbol}`;
+    }
+    return `${balances.length} balances`;
+  }
+  if (data.tx_hash) {
+    return `tx: ${data.tx_hash.slice(0, 12)}...`;
+  }
+  if (data.added) return "added";
+  if (data.removed) return "removed";
+  if (data.message) return data.message;
+  return "";
+}
+
+// src/commands/agent.ts
+async function executeAgent(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  const config = {
+    backendUrl: options.backendUrl || process.env.VULTISIG_AGENT_URL || "http://localhost:9998",
+    vaultName: vault.name,
+    password: options.password,
+    viaAgent: options.viaAgent,
+    conversationId: options.conversationId,
+    verbose: options.verbose
+  };
+  const session = new AgentSession(vault, config);
+  if (options.viaAgent) {
+    const pipe = new PipeInterface(session);
+    const callbacks = pipe.getCallbacks();
+    try {
+      await session.initialize(callbacks);
+      const addresses = session.getVaultAddresses();
+      await pipe.start(vault.name, addresses);
+    } catch (err) {
+      process.stdout.write(JSON.stringify({ type: "error", message: err.message }) + "\n");
+      process.exit(1);
+    }
+  } else {
+    const tui = new ChatTUI(session, vault.name, config.verbose);
+    const callbacks = tui.getCallbacks();
+    try {
+      await session.initialize(callbacks);
+      await tui.start();
+    } catch (err) {
+      console.error(`Agent error: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+// src/interactive/completer.ts
+import { Chain as Chain10 } from "@vultisig/sdk";
+import fs2 from "fs";
+import path2 from "path";
+var COMMANDS = [
+  // Vault management
+  "vaults",
+  "vault",
+  "import",
+  "delete",
+  "create-from-seedphrase",
+  "create",
+  "join",
+  "info",
+  "export",
+  // Wallet operations
+  "balance",
+  "bal",
+  "send",
+  "tx-status",
+  "portfolio",
+  "addresses",
+  "chains",
+  "tokens",
+  // Swap operations
+  "swap-chains",
+  "swap-quote",
+  "swap",
+  // Session commands (shell-only)
+  "lock",
+  "unlock",
+  "status",
+  // Settings
+  "currency",
+  "server",
+  "address-book",
+  // Help
+  "help",
+  "?",
+  // REPL commands
+  ".help",
+  ".clear",
+  ".exit"
+];
+function createCompleter(ctx2) {
+  return function completer(line) {
+    try {
+      const parts = line.split(/\s+/);
+      const command = parts[0]?.toLowerCase();
+      if ((command === "import" || command === "export") && parts.length > 1) {
+        const partial = parts.slice(1).join(" ");
+        return completeFilePath(partial, command === "import");
+      }
+      if (command === "vault" && parts.length > 1) {
+        const partial = parts.slice(1).join(" ");
+        return completeVaultName(ctx2, partial);
+      }
+      if (command === "chains" && parts.length >= 2) {
+        const lastPart = parts[parts.length - 1] || "";
+        const lastPartLower = lastPart.toLowerCase();
+        if (lastPartLower.startsWith("-")) {
+          const flags = ["--add", "--add-all", "--remove"];
+          const matches = flags.filter((f) => f.startsWith(lastPartLower));
+          return [matches.length ? matches : flags, lastPart];
+        }
+        const flag = parts[parts.length - 2]?.toLowerCase();
+        if (flag === "--add" || flag === "--remove") {
+          return completeChainName(lastPart);
+        }
+      }
+      if (["balance", "bal", "tokens", "send", "swap", "swap-quote", "tx-status"].includes(command) && parts.length === 2) {
+        const partial = parts[1] || "";
+        return completeChainName(partial);
+      }
+      if ((command === "create" || command === "create-from-seedphrase") && parts.length === 2) {
+        const types = ["fast", "secure"];
+        const partial = parts[1] || "";
+        const partialLower = partial.toLowerCase();
+        const matches = types.filter((t) => t.startsWith(partialLower));
+        return [matches.length ? matches : types, partial];
+      }
+      if (command === "join" && parts.length === 2) {
+        const types = ["secure"];
+        const partial = parts[1] || "";
+        const partialLower = partial.toLowerCase();
+        const matches = types.filter((t) => t.startsWith(partialLower));
+        return [matches.length ? matches : types, partial];
+      }
+      const hits = COMMANDS.filter((c) => c.startsWith(line));
+      const show = hits.length ? hits : COMMANDS;
+      return [show, line];
+    } catch {
+      return [[], line];
+    }
+  };
+}
+function completeFilePath(partial, filterVult) {
+  try {
+    const endsWithSeparator = partial.endsWith("/") || partial.endsWith(path2.sep);
+    let dir;
+    let basename;
+    if (endsWithSeparator) {
+      dir = partial;
+      basename = "";
+    } else {
+      dir = path2.dirname(partial);
+      basename = path2.basename(partial);
+      if (fs2.existsSync(partial) && fs2.statSync(partial).isDirectory()) {
+        dir = partial;
+        basename = "";
+      }
+    }
+    const resolvedDir = path2.resolve(dir);
+    if (!fs2.existsSync(resolvedDir) || !fs2.statSync(resolvedDir).isDirectory()) {
+      return [[], partial];
+    }
+    const files = fs2.readdirSync(resolvedDir);
+    const matches = files.filter((file) => file.startsWith(basename)).map((file) => {
+      const fullPath = path2.join(dir, file);
+      const stats = fs2.statSync(path2.join(resolvedDir, file));
+      if (stats.isDirectory()) {
+        return fullPath + "/";
+      }
+      if (filterVult) {
+        if (file.endsWith(".vult") || stats.isDirectory()) {
           return fullPath;
         }
         return null;
@@ -3840,7 +6450,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain6);
+  const allChains = Object.values(Chain10);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -3848,14 +6458,14 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain6);
+  const allChains = Object.values(Chain10);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;
 }
 
 // src/interactive/event-buffer.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 var EventBuffer = class {
   eventBuffer = [];
   isCommandRunning = false;
@@ -3895,17 +6505,17 @@ var EventBuffer = class {
   displayEvent(message, type) {
     switch (type) {
       case "success":
-        console.log(chalk8.green(message));
+        console.log(chalk9.green(message));
         break;
       case "warning":
-        console.log(chalk8.yellow(message));
+        console.log(chalk9.yellow(message));
         break;
       case "error":
-        console.error(chalk8.red(message));
+        console.error(chalk9.red(message));
         break;
       case "info":
       default:
-        console.log(chalk8.blue(message));
+        console.log(chalk9.blue(message));
         break;
     }
   }
@@ -3916,13 +6526,13 @@ var EventBuffer = class {
     if (this.eventBuffer.length === 0) {
       return;
     }
-    console.log(chalk8.gray("\n--- Background Events ---"));
+    console.log(chalk9.gray("\n--- Background Events ---"));
     this.eventBuffer.forEach((event) => {
       const timeStr = event.timestamp.toLocaleTimeString();
       const message = `[${timeStr}] ${event.message}`;
       this.displayEvent(message, event.type);
     });
-    console.log(chalk8.gray("--- End Events ---\n"));
+    console.log(chalk9.gray("--- End Events ---\n"));
   }
   /**
    * Setup all vault event listeners
@@ -3939,6 +6549,12 @@ var EventBuffer = class {
       this.handleEvent(`+ Transaction broadcast on ${chain}`, "success");
       this.handleEvent(`  TX Hash: ${txHash}`, "info");
     });
+    vault.on("transactionConfirmed", ({ chain, txHash }) => {
+      this.handleEvent(`+ Transaction confirmed on ${chain}: ${txHash}`, "success");
+    });
+    vault.on("transactionFailed", ({ chain, txHash }) => {
+      this.handleEvent(`x Transaction failed on ${chain}: ${txHash}`, "error");
+    });
     vault.on("signingProgress", ({ step }) => {
       this.handleEvent(`i Signing: ${step}`, "info");
     });
@@ -4002,6 +6618,8 @@ var EventBuffer = class {
     vault.removeAllListeners("balanceUpdated");
     vault.removeAllListeners("transactionSigned");
     vault.removeAllListeners("transactionBroadcast");
+    vault.removeAllListeners("transactionConfirmed");
+    vault.removeAllListeners("transactionFailed");
     vault.removeAllListeners("signingProgress");
     vault.removeAllListeners("chainAdded");
     vault.removeAllListeners("chainRemoved");
@@ -4024,12 +6642,12 @@ var EventBuffer = class {
 
 // src/interactive/session.ts
 import { fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import ora3 from "ora";
-import * as readline from "readline";
+import * as readline3 from "readline";
 
 // src/interactive/shell-commands.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import Table from "cli-table3";
 import inquirer6 from "inquirer";
 import ora2 from "ora";
@@ -4046,25 +6664,25 @@ function formatTimeRemaining(ms) {
 async function executeLock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk9.red("No active vault."));
-    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk10.red("No active vault."));
+    console.log(chalk10.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   ctx2.lockVault(vault.id);
-  console.log(chalk9.green("\n+ Vault locked"));
-  console.log(chalk9.gray("Password cache cleared. You will need to enter the password again."));
+  console.log(chalk10.green("\n+ Vault locked"));
+  console.log(chalk10.gray("Password cache cleared. You will need to enter the password again."));
 }
 async function executeUnlock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk9.red("No active vault."));
-    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk10.red("No active vault."));
+    console.log(chalk10.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   if (ctx2.isVaultUnlocked(vault.id)) {
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
-    console.log(chalk9.yellow("\nVault is already unlocked."));
-    console.log(chalk9.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
+    console.log(chalk10.yellow("\nVault is already unlocked."));
+    console.log(chalk10.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
     return;
   }
   const { password } = await inquirer6.prompt([
@@ -4081,19 +6699,19 @@ async function executeUnlock(ctx2) {
     ctx2.cachePassword(vault.id, password);
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
     spinner.succeed("Vault unlocked");
-    console.log(chalk9.green(`
+    console.log(chalk10.green(`
 + Vault unlocked for ${formatTimeRemaining(timeRemaining)}`));
   } catch (err) {
     spinner.fail("Failed to unlock vault");
-    console.error(chalk9.red(`
+    console.error(chalk10.red(`
 x ${err.message}`));
   }
 }
 async function executeStatus(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk9.red("No active vault."));
-    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk10.red("No active vault."));
+    console.log(chalk10.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   const isUnlocked = ctx2.isVaultUnlocked(vault.id);
@@ -4124,30 +6742,30 @@ async function executeStatus(ctx2) {
   displayStatus(status);
 }
 function displayStatus(status) {
-  console.log(chalk9.cyan("\n+----------------------------------------+"));
-  console.log(chalk9.cyan("|            Vault Status                |"));
-  console.log(chalk9.cyan("+----------------------------------------+\n"));
-  console.log(chalk9.bold("Vault:"));
-  console.log(`  Name:     ${chalk9.green(status.name)}`);
+  console.log(chalk10.cyan("\n+----------------------------------------+"));
+  console.log(chalk10.cyan("|            Vault Status                |"));
+  console.log(chalk10.cyan("+----------------------------------------+\n"));
+  console.log(chalk10.bold("Vault:"));
+  console.log(`  Name:     ${chalk10.green(status.name)}`);
   console.log(`  ID:       ${status.id}`);
-  console.log(`  Type:     ${chalk9.yellow(status.type)}`);
-  console.log(chalk9.bold("\nSecurity:"));
+  console.log(`  Type:     ${chalk10.yellow(status.type)}`);
+  console.log(chalk10.bold("\nSecurity:"));
   if (status.isUnlocked) {
-    console.log(`  Status:   ${chalk9.green("Unlocked")} ${chalk9.green("\u{1F513}")}`);
+    console.log(`  Status:   ${chalk10.green("Unlocked")} ${chalk10.green("\u{1F513}")}`);
     console.log(`  Expires:  ${status.timeRemainingFormatted}`);
   } else {
-    console.log(`  Status:   ${chalk9.yellow("Locked")} ${chalk9.yellow("\u{1F512}")}`);
+    console.log(`  Status:   ${chalk10.yellow("Locked")} ${chalk10.yellow("\u{1F512}")}`);
   }
-  console.log(`  Encrypted: ${status.isEncrypted ? chalk9.green("Yes") : chalk9.gray("No")}`);
-  console.log(`  Backed Up: ${status.isBackedUp ? chalk9.green("Yes") : chalk9.yellow("No")}`);
-  console.log(chalk9.bold("\nMPC Configuration:"));
+  console.log(`  Encrypted: ${status.isEncrypted ? chalk10.green("Yes") : chalk10.gray("No")}`);
+  console.log(`  Backed Up: ${status.isBackedUp ? chalk10.green("Yes") : chalk10.yellow("No")}`);
+  console.log(chalk10.bold("\nMPC Configuration:"));
   console.log(`  Library:   ${status.libType}`);
-  console.log(`  Threshold: ${chalk9.cyan(status.threshold)} of ${chalk9.cyan(status.totalSigners)}`);
-  console.log(chalk9.bold("\nSigning Modes:"));
+  console.log(`  Threshold: ${chalk10.cyan(status.threshold)} of ${chalk10.cyan(status.totalSigners)}`);
+  console.log(chalk10.bold("\nSigning Modes:"));
   status.availableSigningModes.forEach((mode) => {
     console.log(`  - ${mode}`);
   });
-  console.log(chalk9.bold("\nDetails:"));
+  console.log(chalk10.bold("\nDetails:"));
   console.log(`  Chains:   ${status.chains}`);
   console.log(`  Currency: ${status.currency.toUpperCase()}`);
   console.log(`  Created:  ${new Date(status.createdAt).toLocaleString()}`);
@@ -4156,7 +6774,7 @@ function displayStatus(status) {
 }
 function showHelp() {
   const table = new Table({
-    head: [chalk9.bold("Available Commands")],
+    head: [chalk10.bold("Available Commands")],
     colWidths: [50],
     chars: {
       mid: "",
@@ -4170,7 +6788,7 @@ function showHelp() {
     }
   });
   table.push(
-    [chalk9.bold("Vault Management:")],
+    [chalk10.bold("Vault Management:")],
     ["  vaults              - List all vaults"],
     ["  vault <name>        - Switch to vault"],
     ["  import <file>       - Import vault from file"],
@@ -4179,30 +6797,31 @@ function showHelp() {
     ["  info                - Show vault details"],
     ["  export [path]       - Export vault to file"],
     [""],
-    [chalk9.bold("Wallet Operations:")],
+    [chalk10.bold("Wallet Operations:")],
     ["  balance [chain]     - Show balances"],
     ["  send <chain> <to> <amount> - Send transaction"],
+    ["  tx-status <chain> <txHash> - Check transaction status"],
     ["  portfolio [-c usd]  - Show portfolio value"],
     ["  addresses           - Show all addresses"],
     ["  chains [--add/--remove/--add-all] - Manage chains"],
     ["  tokens <chain>      - Manage tokens"],
     [""],
-    [chalk9.bold("Swap Operations:")],
+    [chalk10.bold("Swap Operations:")],
     ["  swap-chains         - List swap-enabled chains"],
     ["  swap-quote <from> <to> <amount> - Get quote"],
     ["  swap <from> <to> <amount> - Execute swap"],
     [""],
-    [chalk9.bold("Session Commands (shell only):")],
+    [chalk10.bold("Session Commands (shell only):")],
     ["  lock                - Lock vault"],
     ["  unlock              - Unlock vault"],
     ["  status              - Show vault status"],
     [""],
-    [chalk9.bold("Settings:")],
+    [chalk10.bold("Settings:")],
     ["  currency [code]     - View/set currency"],
     ["  server              - Check server status"],
     ["  address-book        - Manage saved addresses"],
     [""],
-    [chalk9.bold("Help & Navigation:")],
+    [chalk10.bold("Help & Navigation:")],
     ["  help, ?             - Show this help"],
     ["  .clear              - Clear screen"],
     ["  .exit               - Exit shell"]
@@ -4340,12 +6959,12 @@ var ShellSession = class {
    */
   async start() {
     console.clear();
-    console.log(chalk10.cyan.bold("\n=============================================="));
-    console.log(chalk10.cyan.bold("         Vultisig Interactive Shell"));
-    console.log(chalk10.cyan.bold("==============================================\n"));
+    console.log(chalk11.cyan.bold("\n=============================================="));
+    console.log(chalk11.cyan.bold("         Vultisig Interactive Shell"));
+    console.log(chalk11.cyan.bold("==============================================\n"));
     await this.loadAllVaults();
     this.displayVaultList();
-    console.log(chalk10.gray('Type "help" for available commands, "exit" to quit\n'));
+    console.log(chalk11.gray('Type "help" for available commands, "exit" to quit\n'));
     this.promptLoop().catch(() => {
     });
   }
@@ -4363,7 +6982,7 @@ var ShellSession = class {
    */
   readLine(prompt) {
     return new Promise((resolve) => {
-      const rl = readline.createInterface({
+      const rl = readline3.createInterface({
         input: process.stdin,
         output: process.stdout,
         completer: (line, cb) => {
@@ -4379,12 +6998,12 @@ var ShellSession = class {
         const now = Date.now();
         if (now - this.lastSigintTime < this.DOUBLE_CTRL_C_TIMEOUT) {
           rl.close();
-          console.log(chalk10.yellow("\nGoodbye!"));
+          console.log(chalk11.yellow("\nGoodbye!"));
           this.ctx.dispose();
           process.exit(0);
         }
         this.lastSigintTime = now;
-        console.log(chalk10.yellow("\n(Press Ctrl+C again to exit)"));
+        console.log(chalk11.yellow("\n(Press Ctrl+C again to exit)"));
         rl.close();
         resolve("");
       });
@@ -4396,7 +7015,7 @@ var ShellSession = class {
   prompt(message, defaultValue) {
     return new Promise((resolve, reject) => {
       const displayPrompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
-      const rl = readline.createInterface({
+      const rl = readline3.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: true
@@ -4416,7 +7035,7 @@ var ShellSession = class {
    */
   promptPassword(message) {
     return new Promise((resolve, reject) => {
-      const rl = readline.createInterface({
+      const rl = readline3.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: true
@@ -4479,7 +7098,7 @@ var ShellSession = class {
       stopAllSpinners();
       process.stdout.write("\x1B[?25h");
       process.stdout.write("\r\x1B[K");
-      console.log(chalk10.yellow("\nCancelling operation..."));
+      console.log(chalk11.yellow("\nCancelling operation..."));
     };
     const cleanup = () => {
       process.removeListener("SIGINT", onSigint);
@@ -4516,10 +7135,10 @@ var ShellSession = class {
         stopAllSpinners();
         process.stdout.write("\x1B[?25h");
         process.stdout.write("\r\x1B[K");
-        console.log(chalk10.yellow("Operation cancelled"));
+        console.log(chalk11.yellow("Operation cancelled"));
         return;
       }
-      console.error(chalk10.red(`
+      console.error(chalk11.red(`
 Error: ${error2.message}`));
     }
   }
@@ -4552,7 +7171,7 @@ Error: ${error2.message}`));
         break;
       case "rename":
         if (args.length === 0) {
-          console.log(chalk10.yellow("Usage: rename <newName>"));
+          console.log(chalk11.yellow("Usage: rename <newName>"));
           return;
         }
         await executeRename(this.ctx, args.join(" "));
@@ -4572,6 +7191,9 @@ Error: ${error2.message}`));
       case "send":
         await this.runSend(args);
         break;
+      case "tx-status":
+        await this.runTxStatus(args);
+        break;
       // Chain management
       case "addresses":
         await executeAddresses(this.ctx);
@@ -4625,41 +7247,41 @@ Error: ${error2.message}`));
       // Exit
       case "exit":
       case "quit":
-        console.log(chalk10.yellow("\nGoodbye!"));
+        console.log(chalk11.yellow("\nGoodbye!"));
         this.ctx.dispose();
         process.exit(0);
         break;
       // eslint requires break even after process.exit
       default:
-        console.log(chalk10.yellow(`Unknown command: ${command}`));
-        console.log(chalk10.gray('Type "help" for available commands'));
+        console.log(chalk11.yellow(`Unknown command: ${command}`));
+        console.log(chalk11.gray('Type "help" for available commands'));
         break;
     }
   }
   // ===== Command Helpers =====
   async switchVault(args) {
     if (args.length === 0) {
-      console.log(chalk10.yellow("Usage: vault <name>"));
-      console.log(chalk10.gray('Run "vaults" to see available vaults'));
+      console.log(chalk11.yellow("Usage: vault <name>"));
+      console.log(chalk11.gray('Run "vaults" to see available vaults'));
       return;
     }
     const vaultName = args.join(" ");
     const vault = this.ctx.findVaultByName(vaultName);
     if (!vault) {
-      console.log(chalk10.red(`Vault not found: ${vaultName}`));
-      console.log(chalk10.gray('Run "vaults" to see available vaults'));
+      console.log(chalk11.red(`Vault not found: ${vaultName}`));
+      console.log(chalk11.gray('Run "vaults" to see available vaults'));
       return;
     }
     await this.ctx.setActiveVault(vault);
-    console.log(chalk10.green(`
+    console.log(chalk11.green(`
 + Switched to: ${vault.name}`));
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk10.green("Unlocked") : chalk10.yellow("Locked");
+    const status = isUnlocked ? chalk11.green("Unlocked") : chalk11.yellow("Locked");
     console.log(`Status: ${status}`);
   }
   async importVault(args) {
     if (args.length === 0) {
-      console.log(chalk10.yellow("Usage: import <file>"));
+      console.log(chalk11.yellow("Usage: import <file>"));
       return;
     }
     const filePath = args.join(" ");
@@ -4674,45 +7296,45 @@ Error: ${error2.message}`));
   async createVault(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk10.yellow("Usage: create <fast|secure>"));
-      console.log(chalk10.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
-      console.log(chalk10.gray("  create secure - Create a secure vault (multi-device MPC)"));
+      console.log(chalk11.yellow("Usage: create <fast|secure>"));
+      console.log(chalk11.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
+      console.log(chalk11.gray("  create secure - Create a secure vault (multi-device MPC)"));
       return;
     }
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk10.red("Name is required"));
+        console.log(chalk11.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk10.red("Password is required"));
+        console.log(chalk11.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk10.red("Valid email is required"));
+        console.log(chalk11.red("Valid email is required"));
         return;
       }
       vault = await this.withCancellation((signal) => executeCreateFast(this.ctx, { name, password, email, signal }));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk10.red("Name is required"));
+        console.log(chalk11.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk10.red("Must have at least 2 shares"));
+        console.log(chalk11.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk10.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk11.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, press Enter to skip)");
@@ -4734,37 +7356,37 @@ Error: ${error2.message}`));
   async importSeedphrase(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk10.cyan("Usage: create-from-seedphrase <fast|secure>"));
-      console.log(chalk10.gray("  fast   - Import with VultiServer (2-of-2)"));
-      console.log(chalk10.gray("  secure - Import with device coordination (N-of-M)"));
+      console.log(chalk11.cyan("Usage: create-from-seedphrase <fast|secure>"));
+      console.log(chalk11.gray("  fast   - Import with VultiServer (2-of-2)"));
+      console.log(chalk11.gray("  secure - Import with device coordination (N-of-M)"));
       return;
     }
-    console.log(chalk10.cyan("\nEnter your recovery phrase (words separated by spaces):"));
+    console.log(chalk11.cyan("\nEnter your recovery phrase (words separated by spaces):"));
     const mnemonic = await this.promptPassword("Seedphrase");
     const validation = await this.ctx.sdk.validateSeedphrase(mnemonic);
     if (!validation.valid) {
-      console.log(chalk10.red(`Invalid seedphrase: ${validation.error}`));
+      console.log(chalk11.red(`Invalid seedphrase: ${validation.error}`));
       if (validation.invalidWords?.length) {
-        console.log(chalk10.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
+        console.log(chalk11.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
       }
       return;
     }
-    console.log(chalk10.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
+    console.log(chalk11.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk10.red("Name is required"));
+        console.log(chalk11.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk10.red("Password is required"));
+        console.log(chalk11.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk10.red("Valid email is required"));
+        console.log(chalk11.red("Valid email is required"));
         return;
       }
       const discoverStr = await this.prompt("Discover chains with balances? (y/n)", "y");
@@ -4782,19 +7404,19 @@ Error: ${error2.message}`));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk10.red("Name is required"));
+        console.log(chalk11.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk10.red("Must have at least 2 shares"));
+        console.log(chalk11.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk10.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk11.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, Enter to skip)");
@@ -4838,8 +7460,8 @@ Error: ${error2.message}`));
       }
     }
     if (!fiatCurrencies3.includes(currency)) {
-      console.log(chalk10.red(`Invalid currency: ${currency}`));
-      console.log(chalk10.yellow(`Supported currencies: ${fiatCurrencies3.join(", ")}`));
+      console.log(chalk11.red(`Invalid currency: ${currency}`));
+      console.log(chalk11.yellow(`Supported currencies: ${fiatCurrencies3.join(", ")}`));
       return;
     }
     const raw = args.includes("--raw");
@@ -4847,7 +7469,7 @@ Error: ${error2.message}`));
   }
   async runSend(args) {
     if (args.length < 3) {
-      console.log(chalk10.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
+      console.log(chalk11.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
       return;
     }
     const [chainStr, to, amount, ...rest] = args;
@@ -4867,12 +7489,22 @@ Error: ${error2.message}`));
       await this.withAbortHandler((signal) => executeSend(this.ctx, { chain, to, amount, tokenId, memo, signal }));
     } catch (err) {
       if (err.message === "Transaction cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk10.yellow("\nTransaction cancelled"));
+        console.log(chalk11.yellow("\nTransaction cancelled"));
         return;
       }
       throw err;
     }
   }
+  async runTxStatus(args) {
+    if (args.length < 2) {
+      console.log(chalk11.yellow("Usage: tx-status <chain> <txHash> [--no-wait]"));
+      return;
+    }
+    const [chainStr, txHash, ...rest] = args;
+    const chain = findChainByName(chainStr) || chainStr;
+    const noWait = rest.includes("--no-wait");
+    await this.withCancellation(() => executeTxStatus(this.ctx, { chain, txHash, noWait }));
+  }
   async runChains(args) {
     let addChain;
     let removeChain;
@@ -4883,8 +7515,8 @@ Error: ${error2.message}`));
       } else if (args[i] === "--add" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk10.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk10.gray("Use tab completion to see available chains"));
+          console.log(chalk11.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk11.gray("Use tab completion to see available chains"));
           return;
         }
         addChain = chain;
@@ -4892,8 +7524,8 @@ Error: ${error2.message}`));
       } else if (args[i] === "--remove" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk10.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk10.gray("Use tab completion to see available chains"));
+          console.log(chalk11.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk11.gray("Use tab completion to see available chains"));
           return;
         }
         removeChain = chain;
@@ -4904,7 +7536,7 @@ Error: ${error2.message}`));
   }
   async runTokens(args) {
     if (args.length === 0) {
-      console.log(chalk10.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
+      console.log(chalk11.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
       return;
     }
     const chainStr = args[0];
@@ -4925,7 +7557,7 @@ Error: ${error2.message}`));
   async runSwapQuote(args) {
     if (args.length < 3) {
       console.log(
-        chalk10.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
+        chalk11.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
       );
       return;
     }
@@ -4949,7 +7581,7 @@ Error: ${error2.message}`));
   async runSwap(args) {
     if (args.length < 3) {
       console.log(
-        chalk10.yellow(
+        chalk11.yellow(
           "Usage: swap <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>] [--slippage <pct>]"
         )
       );
@@ -4980,7 +7612,7 @@ Error: ${error2.message}`));
       );
     } catch (err) {
       if (err.message === "Swap cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk10.yellow("\nSwap cancelled"));
+        console.log(chalk11.yellow("\nSwap cancelled"));
         return;
       }
       throw err;
@@ -5042,24 +7674,24 @@ Error: ${error2.message}`));
   }
   getPrompt() {
     const vault = this.ctx.getActiveVault();
-    if (!vault) return chalk10.cyan("wallet> ");
+    if (!vault) return chalk11.cyan("wallet> ");
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk10.green("\u{1F513}") : chalk10.yellow("\u{1F512}");
-    return chalk10.cyan(`wallet[${vault.name}]${status}> `);
+    const status = isUnlocked ? chalk11.green("\u{1F513}") : chalk11.yellow("\u{1F512}");
+    return chalk11.cyan(`wallet[${vault.name}]${status}> `);
   }
   displayVaultList() {
     const vaults = Array.from(this.ctx.getVaults().values());
     const activeVault = this.ctx.getActiveVault();
     if (vaults.length === 0) {
-      console.log(chalk10.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
+      console.log(chalk11.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
       return;
     }
-    console.log(chalk10.cyan("Loaded Vaults:\n"));
+    console.log(chalk11.cyan("Loaded Vaults:\n"));
     vaults.forEach((vault) => {
       const isActive = vault.id === activeVault?.id;
       const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-      const activeMarker = isActive ? chalk10.green(" (active)") : "";
-      const lockIcon = isUnlocked ? chalk10.green("\u{1F513}") : chalk10.yellow("\u{1F512}");
+      const activeMarker = isActive ? chalk11.green(" (active)") : "";
+      const lockIcon = isUnlocked ? chalk11.green("\u{1F513}") : chalk11.yellow("\u{1F512}");
       console.log(`  ${lockIcon} ${vault.name}${activeMarker} - ${vault.type}`);
     });
     console.log();
@@ -5067,23 +7699,23 @@ Error: ${error2.message}`));
 };
 
 // src/lib/errors.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/lib/version.ts
-import chalk12 from "chalk";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import chalk13 from "chalk";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "0.5.0";
+    cachedVersion = "0.7.0";
     return cachedVersion;
   }
   try {
     const packagePath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(packagePath, "utf-8"));
     cachedVersion = pkg.version;
     return cachedVersion;
   } catch {
@@ -5091,13 +7723,13 @@ function getVersion() {
     return cachedVersion;
   }
 }
-var CACHE_DIR = join(homedir(), ".vultisig", "cache");
-var VERSION_CACHE_FILE = join(CACHE_DIR, "version-check.json");
+var CACHE_DIR = join2(homedir2(), ".vultisig", "cache");
+var VERSION_CACHE_FILE = join2(CACHE_DIR, "version-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function readVersionCache() {
   try {
-    if (!existsSync(VERSION_CACHE_FILE)) return null;
-    const data = readFileSync(VERSION_CACHE_FILE, "utf-8");
+    if (!existsSync2(VERSION_CACHE_FILE)) return null;
+    const data = readFileSync2(VERSION_CACHE_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -5105,10 +7737,10 @@ function readVersionCache() {
 }
 function writeVersionCache(cache) {
   try {
-    if (!existsSync(CACHE_DIR)) {
-      mkdirSync(CACHE_DIR, { recursive: true });
+    if (!existsSync2(CACHE_DIR)) {
+      mkdirSync2(CACHE_DIR, { recursive: true });
     }
-    writeFileSync(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
+    writeFileSync2(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
@@ -5132,8 +7764,8 @@ async function fetchLatestVersion() {
 }
 function isNewerVersion(v1, v2) {
   const parse = (v) => {
-    const clean = v.replace(/^v/, "").replace(/-.*$/, "");
-    return clean.split(".").map((n) => parseInt(n, 10) || 0);
+    const clean2 = v.replace(/^v/, "").replace(/-.*$/, "");
+    return clean2.split(".").map((n) => parseInt(n, 10) || 0);
   };
   const p1 = parse(v1);
   const p2 = parse(v2);
@@ -5175,7 +7807,7 @@ function formatVersionShort() {
 }
 function formatVersionDetailed() {
   const lines = [];
-  lines.push(chalk12.bold(`Vultisig CLI v${getVersion()}`));
+  lines.push(chalk13.bold(`Vultisig CLI v${getVersion()}`));
   lines.push("");
   lines.push(`  Node.js:   ${process.version}`);
   lines.push(`  Platform:  ${process.platform}-${process.arch}`);
@@ -5213,9 +7845,9 @@ function getUpdateCommand() {
 }
 
 // src/lib/completion.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 var tabtab = null;
 async function getTabtab() {
   if (!tabtab) {
@@ -5280,15 +7912,15 @@ var CHAINS = [
 ];
 function getVaultNames() {
   try {
-    const vaultDir = join2(homedir2(), ".vultisig", "vaults");
-    if (!existsSync2(vaultDir)) return [];
+    const vaultDir = join3(homedir3(), ".vultisig", "vaults");
+    if (!existsSync3(vaultDir)) return [];
     const { readdirSync } = __require("fs");
     const files = readdirSync(vaultDir);
     const names = [];
     for (const file of files) {
       if (file.startsWith("vault:") && file.endsWith(".json")) {
         try {
-          const content = readFileSync2(join2(vaultDir, file), "utf-8");
+          const content = readFileSync3(join3(vaultDir, file), "utf-8");
           const vault = JSON.parse(content);
           if (vault.name) names.push(vault.name);
           if (vault.id) names.push(vault.id);
@@ -5526,7 +8158,26 @@ complete -c vsig -n "__fish_seen_subcommand_from import export" -a "(__fish_comp
 `.trim();
 }
 
+// src/lib/user-agent.ts
+function setupUserAgent() {
+  const userAgent = `vultisig-cli/${getVersion()}`;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (input, init2) => {
+    const headers = new Headers(input instanceof Request ? input.headers : void 0);
+    if (init2?.headers) {
+      new Headers(init2.headers).forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    if (!headers.has("User-Agent")) {
+      headers.set("User-Agent", userAgent);
+    }
+    return originalFetch(input, { ...init2, headers });
+  };
+}
+
 // src/index.ts
+setupUserAgent();
 (async () => {
   const handled = await handleCompletion();
   if (handled) process.exit(0);
@@ -5552,7 +8203,7 @@ async function init(vaultOverride, unlockPassword) {
     if (unlockPassword && vaultSelector) {
       cachePassword(vaultSelector, unlockPassword);
     }
-    const sdk = new Vultisig5({
+    const sdk = new Vultisig7({
       onPasswordRequired: createPasswordCallback()
     });
     await sdk.initialize();
@@ -5574,10 +8225,10 @@ async function init(vaultOverride, unlockPassword) {
   return ctx;
 }
 var createCmd = program.command("create").description("Create a vault");
-createCmd.command("fast").description("Create a fast vault (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").action(
+createCmd.command("fast").description("Create a fast vault (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").option("--two-step", 'Create vault without verifying OTP (verify later with "vultisig verify")').action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
-    await executeCreateFast(context, options);
+    await executeCreateFast(context, { ...options, twoStep: options.twoStep });
   })
 );
 createCmd.command("secure").description("Create a secure vault (multi-device MPC)").requiredOption("--name <name>", "Vault name").option("--password <password>", "Vault password (optional)").option("--threshold <m>", "Signing threshold", "2").option("--shares <n>", "Total shares", "3").action(
@@ -5823,6 +8474,16 @@ program.command("broadcast").description("Broadcast a pre-signed raw transaction
     });
   })
 );
+program.command("tx-status").description("Check the status of a transaction (polls until confirmed)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--tx-hash <hash>", "Transaction hash to check").option("--no-wait", "Return immediately without waiting for confirmation").action(
+  withExit(async (options) => {
+    const context = await init(program.opts().vault);
+    await executeTxStatus(context, {
+      chain: findChainByName(options.chain) || options.chain,
+      txHash: options.txHash,
+      noWait: !options.wait
+    });
+  })
+);
 program.command("portfolio").description("Show total portfolio value").option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").option("--raw", "Show raw values (wei/satoshis) for programmatic use").action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
@@ -6051,14 +8712,24 @@ rujiraCmd.command("withdraw <asset> <amount> <l1Address>").description("Withdraw
     }
   )
 );
+program.command("agent").description("AI-powered chat interface for wallet operations").option("--via-agent", "Use NDJSON pipe mode for agent-to-agent communication").option("--verbose", "Show detailed tool call parameters and debug output").option("--backend-url <url>", "Agent backend URL (default: http://localhost:9998)").option("--password <password>", "Vault password for signing operations").option("--conversation <id>", "Resume an existing conversation").action(async (options) => {
+  const context = await init(program.opts().vault, options.password);
+  await executeAgent(context, {
+    viaAgent: options.viaAgent,
+    verbose: options.verbose,
+    backendUrl: options.backendUrl,
+    password: options.password,
+    conversationId: options.conversation
+  });
+});
 program.command("version").description("Show detailed version information").action(
   withExit(async () => {
     printResult(formatVersionDetailed());
     const result = await checkForUpdates();
     if (result?.updateAvailable && result.latestVersion) {
       info("");
-      info(chalk13.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
-      info(chalk13.gray(`Run "${getUpdateCommand()}" to update`));
+      info(chalk14.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      info(chalk14.gray(`Run "${getUpdateCommand()}" to update`));
     }
   })
 );
@@ -6067,28 +8738,28 @@ program.command("update").description("Check for updates and show update command
     info("Checking for updates...");
     const result = await checkForUpdates();
     if (!result) {
-      printResult(chalk13.gray("Update checking is disabled"));
+      printResult(chalk14.gray("Update checking is disabled"));
       return;
     }
     if (result.updateAvailable && result.latestVersion) {
       printResult("");
-      printResult(chalk13.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      printResult(chalk14.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
       printResult("");
       if (options.check) {
         printResult(`Run "${getUpdateCommand()}" to update`);
       } else {
         const updateCmd = getUpdateCommand();
         printResult(`To update, run:`);
-        printResult(chalk13.cyan(`  ${updateCmd}`));
+        printResult(chalk14.cyan(`  ${updateCmd}`));
       }
     } else {
-      printResult(chalk13.green(`You're on the latest version (${result.currentVersion})`));
+      printResult(chalk14.green(`You're on the latest version (${result.currentVersion})`));
     }
   })
 );
 setupCompletionCommand(program);
 async function startInteractiveMode() {
-  const sdk = new Vultisig5({
+  const sdk = new Vultisig7({
     onPasswordRequired: createPasswordCallback()
   });
   await sdk.initialize();
@@ -6110,3 +8781,8 @@ if (isInteractiveMode) {
 } else {
   program.parse();
 }
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/