@vultisig/cli 2.22.0 → 2.23.0

package/dist/index.js

@@ -1687,7 +1687,7 @@ function createHasher(hashCons) {
   hashC.create = () => hashCons();
   return hashC;
 }
-function randomBytes3(bytesLength = 32) {
+function randomBytes2(bytesLength = 32) {
   if (crypto2 && typeof crypto2.getRandomValues === "function") {
     return crypto2.getRandomValues(new Uint8Array(bytesLength));
   }
@@ -4467,7 +4467,7 @@ function getHash(hash) {
   return {
     hash,
     hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),
-    randomBytes: randomBytes3
+    randomBytes: randomBytes2
   };
 }
 function createCurve(curveDef, defHash) {
@@ -4700,7 +4700,7 @@ function challenge(...args) {
 function schnorrGetPublicKey(privateKey) {
   return schnorrGetExtPubKey(privateKey).bytes;
 }
-function schnorrSign(message, privateKey, auxRand = randomBytes3(32)) {
+function schnorrSign(message, privateKey, auxRand = randomBytes2(32)) {
   const m = ensureBytes("message", message);
   const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
   const a = ensureBytes("auxRand", auxRand, 32);
@@ -8890,210 +8890,624 @@ Please specify more characters of the vault ID.`
   throw new Error(`Vault not found: "${idOrName}"`);
 }
 
-// src/commands/swap.ts
-async function executeSwapChains(ctx2) {
-  const vault = await ctx2.ensureActiveVault();
-  const spinner = createSpinner("Loading supported swap chains...");
-  const chains = await vault.getSupportedSwapChains();
-  spinner.succeed("Swap chains loaded");
-  if (isJsonOutput()) {
-    outputJson({ swapChains: [...chains] });
-    return chains;
-  }
-  displaySwapChains(chains);
-  return chains;
-}
-async function executeSwapQuote(ctx2, options) {
-  const vault = await ctx2.ensureActiveVault();
-  const isMax = options.amount === "max";
-  if (!isMax && (isNaN(options.amount) || options.amount <= 0)) {
-    throw new Error("Invalid amount");
-  }
-  const spinner = createSpinner("Getting swap quote...");
-  const result = await vault.swap({
-    fromChain: options.fromChain,
-    fromSymbol: options.fromToken || "",
-    toChain: options.toChain,
-    toSymbol: options.toToken || "",
-    amount: isMax ? "max" : String(options.amount),
-    dryRun: true
-  });
-  if (!result.dryRun) throw new Error("unreachable");
-  spinner.succeed("Quote received");
-  const quote = result.quote;
-  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(options.amount);
-  if (isJsonOutput()) {
-    outputJson({
-      fromChain: options.fromChain,
-      toChain: options.toChain,
-      amount: isMax ? "max" : options.amount,
-      isMax,
-      quote
-    });
-    return quote;
-  }
-  const feeBalance = await vault.balance(options.fromChain);
-  const discountTier = await vault.getDiscountTier();
-  displaySwapPreview(quote, fromAmountDisplay, quote.fromCoin.ticker, quote.toCoin.ticker, {
-    fromDecimals: quote.fromCoin.decimals,
-    toDecimals: quote.toCoin.decimals,
-    feeDecimals: feeBalance.decimals,
-    feeSymbol: feeBalance.symbol,
-    discountTier
-  });
-  info('\nTo execute this swap, use the "swap" command');
-  return quote;
-}
-function validateSwapAmount(amount) {
-  if (amount === "max") return;
-  if (isNaN(amount) || amount <= 0) throw new Error("Invalid amount");
-}
-function getSwapAmountString(amount) {
-  return amount === "max" ? "max" : String(amount);
-}
-function toSwapRequest(options, amount, dryRun) {
-  return {
-    fromChain: options.fromChain,
-    fromSymbol: options.fromToken || "",
-    toChain: options.toChain,
-    toSymbol: options.toToken || "",
-    amount,
-    ...options.slippage !== void 0 && { slippageTolerance: options.slippage },
-    ...dryRun && { dryRun: true }
-  };
-}
-function toDryRunResult(options, quote, fromAmountRaw) {
-  const result = {
-    dryRun: true,
-    fromChain: String(options.fromChain),
-    fromToken: quote.fromCoin.ticker,
-    toChain: String(options.toChain),
-    toToken: quote.toCoin.ticker,
-    inputAmount: fromAmountRaw,
-    ...options.amount === "max" && { isMax: true },
-    estimatedOutput: formatBigintAmount(quote.estimatedOutput, quote.toCoin.decimals),
-    provider: quote.provider
-  };
-  if (quote.estimatedOutputFiat != null) result.estimatedOutputFiat = parseFloat(quote.estimatedOutputFiat.toFixed(2));
-  if (quote.requiresApproval) result.requiresApproval = true;
-  if (quote.warnings?.length) result.warnings = [...quote.warnings];
-  return result;
+// ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
+init_getAddress();
+init_keccak256();
+function publicKeyToAddress(publicKey) {
+  const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
+  return checksumAddress(`0x${address}`);
 }
-function displayDryRunResult(result) {
-  info(`
-Dry-run preview:`);
-  info(`  From:             ${result.inputAmount} ${result.fromToken} (${result.fromChain})`);
-  info(`  To:               ${result.estimatedOutput} ${result.toToken} (${result.toChain})`);
-  info(`  Provider:         ${result.provider}`);
-  if (result.estimatedOutputFiat != null) info(`  Est. value (USD): $${result.estimatedOutputFiat}`);
-  if (result.requiresApproval) info(`  Requires approval: yes`);
-  if (result.warnings?.length) result.warnings.forEach((w) => warn(`  Warning: ${w}`));
+
+// ../../node_modules/viem/_esm/utils/signature/recoverPublicKey.js
+init_isHex();
+init_size();
+init_fromHex();
+init_toHex();
+async function recoverPublicKey({ hash, signature }) {
+  const hashHex = isHex(hash) ? hash : toHex(hash);
+  const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
+  const signature_ = (() => {
+    if (typeof signature === "object" && "r" in signature && "s" in signature) {
+      const { r, s, v, yParity } = signature;
+      const yParityOrV2 = Number(yParity ?? v);
+      const recoveryBit2 = toRecoveryBit(yParityOrV2);
+      return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
+    }
+    const signatureHex = isHex(signature) ? signature : toHex(signature);
+    if (size(signatureHex) !== 65)
+      throw new Error("invalid signature length");
+    const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
+    const recoveryBit = toRecoveryBit(yParityOrV);
+    return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
+  })();
+  const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
+  return `0x${publicKey}`;
 }
-function refuseSwapWhenNonInteractive() {
-  throw new ConfirmationRequiredError(
-    "Swap requires confirmation.",
-    "Pass --yes to confirm, or --dry-run to preview without signing."
-  );
+function toRecoveryBit(yParityOrV) {
+  if (yParityOrV === 0 || yParityOrV === 1)
+    return yParityOrV;
+  if (yParityOrV === 27)
+    return 0;
+  if (yParityOrV === 28)
+    return 1;
+  throw new Error("Invalid yParityOrV value");
 }
-async function confirmSwapIfNeeded(options) {
-  if (options.yes) return;
-  if (isNonInteractive()) {
-    refuseSwapWhenNonInteractive();
-  }
-  const confirmed = await confirmSwap();
-  if (!confirmed) {
-    throw new ConfirmationRequiredError("Swap declined at the confirmation prompt");
-  }
+
+// ../../node_modules/viem/_esm/utils/signature/recoverAddress.js
+async function recoverAddress({ hash, signature }) {
+  return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
 }
-async function executeSwap(ctx2, options) {
-  const vault = await ctx2.ensureActiveVault();
-  validateSwapAmount(options.amount);
-  const amountStr = getSwapAmountString(options.amount);
-  if (!options.dryRun && !options.yes && isNonInteractive()) {
-    refuseSwapWhenNonInteractive();
-  }
-  const quoteSpinner = createSpinner("Getting swap quote...");
-  const dryResult = await vault.swap(toSwapRequest(options, amountStr, true));
-  if (!dryResult.dryRun) throw new Error("unreachable");
-  quoteSpinner.succeed("Quote received");
-  const quote = dryResult.quote;
-  const fromAmountRaw = options.amount === "max" ? formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals) : String(options.amount);
-  const fromAmountDisplay = options.amount === "max" ? `${fromAmountRaw} (max)` : fromAmountRaw;
-  if (options.dryRun) {
-    const result = toDryRunResult(options, quote, fromAmountRaw);
-    if (isJsonOutput()) {
-      outputJson(result);
-    } else {
-      displayDryRunResult(result);
-    }
-    return result;
+
+// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
+init_encodeAbiParameters();
+init_concat();
+init_toHex();
+init_keccak256();
+
+// ../../node_modules/viem/_esm/utils/typedData.js
+init_abi();
+init_address();
+
+// ../../node_modules/viem/_esm/errors/typedData.js
+init_stringify();
+init_base();
+var InvalidDomainError = class extends BaseError {
+  constructor({ domain }) {
+    super(`Invalid domain "${stringify(domain)}".`, {
+      metaMessages: ["Must be a valid EIP-712 domain."]
+    });
   }
-  const feeBalance = await vault.balance(options.fromChain);
-  const discountTier = await vault.getDiscountTier();
-  if (!isJsonOutput()) {
-    displaySwapPreview(quote, fromAmountDisplay, quote.fromCoin.ticker, quote.toCoin.ticker, {
-      fromDecimals: quote.fromCoin.decimals,
-      toDecimals: quote.toCoin.decimals,
-      feeDecimals: feeBalance.decimals,
-      feeSymbol: feeBalance.symbol,
-      discountTier
+};
+var InvalidPrimaryTypeError = class extends BaseError {
+  constructor({ primaryType, types }) {
+    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
+      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
+      metaMessages: ["Check that the primary type is a key in `types`."]
     });
   }
-  await confirmSwapIfNeeded(options);
-  await ensureVaultUnlocked(vault, options.password);
-  const intent = buildSwapBroadcastIntent(vault, {
-    fromChain: options.fromChain,
-    toChain: options.toChain,
-    fromToken: options.fromToken,
-    toToken: options.toToken,
-    amount: fromAmountRaw,
-    isMax: options.amount === "max"
-  });
-  let signSpinner;
-  try {
-    const broadcast = await guardedBroadcast(intent, options.force ?? false, async () => {
-      signSpinner = createSpinner("Signing swap transaction...");
-      vault.on("signingProgress", ({ step }) => {
-        if (signSpinner) signSpinner.text = `${step.message} (${step.progress}%)`;
-      });
-      const result = await vault.swap(toSwapRequest(options, amountStr));
-      if (result.dryRun) throw new Error("unreachable");
-      return result;
+};
+var InvalidStructTypeError = class extends BaseError {
+  constructor({ type }) {
+    super(`Struct type "${type}" is invalid.`, {
+      metaMessages: ["Struct type must not be a Solidity type."],
+      name: "InvalidStructTypeError"
     });
-    signSpinner?.succeed(`Swap broadcast: ${broadcast.txHash}`);
-    if (isJsonOutput()) {
-      outputJson({
-        txHash: broadcast.txHash,
-        fromChain: options.fromChain,
-        toChain: options.toChain,
-        quote
-      });
-    } else {
-      displaySwapResult(options.fromChain, options.toChain, broadcast.txHash, quote, quote.toCoin.decimals);
-    }
-    return { txHash: broadcast.txHash, quote };
-  } catch (err) {
-    signSpinner?.stop();
-    throw err;
-  } finally {
-    vault.removeAllListeners("signingProgress");
   }
-}
+};
 
-// src/commands/settings.ts
-import { Chain as Chain9, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
-import chalk6 from "chalk";
-async function executeCurrency(ctx2, newCurrency) {
-  const vault = await ctx2.ensureActiveVault();
-  if (!newCurrency) {
-    const currentCurrency = vault.currency;
-    const currencyName2 = fiatCurrencyNameRecord3[currentCurrency];
-    printResult(chalk6.cyan("\nCurrent Currency Preference:"));
-    printResult(`  ${chalk6.green(currentCurrency.toUpperCase())} - ${currencyName2}`);
-    info(chalk6.gray(`
-Supported currencies: ${fiatCurrencies2.join(", ")}`));
-    info(chalk6.gray('Use "vultisig currency <code>" to change'));
-    return currentCurrency;
+// ../../node_modules/viem/_esm/utils/typedData.js
+init_isAddress();
+init_size();
+init_toHex();
+init_regex();
+function validateTypedData(parameters) {
+  const { domain, message, primaryType, types } = parameters;
+  const validateData = (struct, data) => {
+    for (const param of struct) {
+      const { name, type } = param;
+      const value = data[name];
+      const integerMatch = type.match(integerRegex);
+      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
+        const [_type, base, size_] = integerMatch;
+        numberToHex(value, {
+          signed: base === "int",
+          size: Number.parseInt(size_, 10) / 8
+        });
+      }
+      if (type === "address" && typeof value === "string" && !isAddress(value))
+        throw new InvalidAddressError2({ address: value });
+      const bytesMatch = type.match(bytesRegex);
+      if (bytesMatch) {
+        const [_type, size_] = bytesMatch;
+        if (size_ && size(value) !== Number.parseInt(size_, 10))
+          throw new BytesSizeMismatchError({
+            expectedSize: Number.parseInt(size_, 10),
+            givenSize: size(value)
+          });
+      }
+      const struct2 = types[type];
+      if (struct2) {
+        validateReference(type);
+        validateData(struct2, value);
+      }
+    }
+  };
+  if (types.EIP712Domain && domain) {
+    if (typeof domain !== "object")
+      throw new InvalidDomainError({ domain });
+    validateData(types.EIP712Domain, domain);
+  }
+  if (primaryType !== "EIP712Domain") {
+    if (types[primaryType])
+      validateData(types[primaryType], message);
+    else
+      throw new InvalidPrimaryTypeError({ primaryType, types });
+  }
+}
+function getTypesForEIP712Domain({ domain }) {
+  return [
+    typeof domain?.name === "string" && { name: "name", type: "string" },
+    domain?.version && { name: "version", type: "string" },
+    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
+      name: "chainId",
+      type: "uint256"
+    },
+    domain?.verifyingContract && {
+      name: "verifyingContract",
+      type: "address"
+    },
+    domain?.salt && { name: "salt", type: "bytes32" }
+  ].filter(Boolean);
+}
+function validateReference(type) {
+  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
+    throw new InvalidStructTypeError({ type });
+}
+
+// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
+function hashTypedData(parameters) {
+  const { domain = {}, message, primaryType } = parameters;
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...parameters.types
+  };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
+  const parts = ["0x1901"];
+  if (domain)
+    parts.push(hashDomain({
+      domain,
+      types
+    }));
+  if (primaryType !== "EIP712Domain")
+    parts.push(hashStruct({
+      data: message,
+      primaryType,
+      types
+    }));
+  return keccak256(concat(parts));
+}
+function hashDomain({ domain, types }) {
+  return hashStruct({
+    data: domain,
+    primaryType: "EIP712Domain",
+    types
+  });
+}
+function hashStruct({ data, primaryType, types }) {
+  const encoded = encodeData({
+    data,
+    primaryType,
+    types
+  });
+  return keccak256(encoded);
+}
+function encodeData({ data, primaryType, types }) {
+  const encodedTypes = [{ type: "bytes32" }];
+  const encodedValues = [hashType({ primaryType, types })];
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+function hashType({ primaryType, types }) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+function encodeType({ primaryType, types }) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+  }
+  return result;
+}
+function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0];
+  if (results.has(primaryType) || types[primaryType] === void 0) {
+    return results;
+  }
+  results.add(primaryType);
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+function encodeField({ types, name, type, value }) {
+  if (types[type] !== void 0) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types }))
+    ];
+  }
+  if (type === "bytes")
+    return [{ type: "bytes32" }, keccak256(value)];
+  if (type === "string")
+    return [{ type: "bytes32" }, keccak256(toHex(value))];
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    const typeValuePairs = value.map((item) => encodeField({
+      name,
+      type: parsedType,
+      types,
+      value: item
+    }));
+    return [
+      { type: "bytes32" },
+      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
+    ];
+  }
+  return [{ type }, value];
+}
+
+// ../../node_modules/viem/_esm/errors/unit.js
+init_base();
+var InvalidDecimalNumberError = class extends BaseError {
+  constructor({ value }) {
+    super(`Number \`${value}\` is not a valid decimal number.`, {
+      name: "InvalidDecimalNumberError"
+    });
+  }
+};
+
+// ../../node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
+    throw new InvalidDecimalNumberError({ value });
+  let [integer, fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    if (Math.round(Number(`.${fraction}`)) === 1)
+      integer = `${BigInt(integer) + 1n}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [left, unit, right] = [
+      fraction.slice(0, decimals - 1),
+      fraction.slice(decimals - 1, decimals),
+      fraction.slice(decimals)
+    ];
+    const rounded = Math.round(Number(`${unit}.${right}`));
+    if (rounded > 9)
+      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
+    else
+      fraction = `${left}${rounded}`;
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1);
+      integer = `${BigInt(integer) + 1n}`;
+    }
+    fraction = fraction.slice(0, decimals);
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+
+// ../../node_modules/viem/_esm/index.js
+init_formatUnits();
+
+// ../../packages/core/chain/dist/amount/toChainAmount.js
+var ChainAmountParseError = class extends Error {
+  name = "ChainAmountParseError";
+  constructor(message) {
+    super(message);
+  }
+};
+var SCIENTIFIC_DECIMAL = /^([+-]?)(?:(\d+)\.?(\d*)|\.(\d+))[eE]([+-]?\d+)$/i;
+var MAX_SCALE_ABS = 10000n;
+var padFractionDigits = (frac, totalLen) => {
+  const need = totalLen - BigInt(frac.length);
+  if (need <= 0n) {
+    return frac;
+  }
+  if (need <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return `${"0".repeat(Number(need))}${frac}`;
+  }
+  let out = frac;
+  while (BigInt(out.length) < totalLen) {
+    out = `0${out}`;
+  }
+  return out;
+};
+var expandScientificNotationToDecimalString = (s) => {
+  const m = SCIENTIFIC_DECIMAL.exec(s.trim());
+  if (!m) {
+    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
+  }
+  const signNeg = m[1] === "-";
+  let digitStr;
+  let fracLen;
+  if (m[4] !== void 0) {
+    digitStr = m[4];
+    fracLen = digitStr.length;
+  } else {
+    digitStr = `${m[2] ?? ""}${m[3] ?? ""}`;
+    fracLen = (m[3] ?? "").length;
+  }
+  if (!/^\d+$/.test(digitStr)) {
+    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
+  }
+  const expStr = m[5] ?? "";
+  if (expStr === "" || expStr === "+" || expStr === "-") {
+    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
+  }
+  const allDigits = BigInt(digitStr);
+  const exp = BigInt(expStr);
+  const scale = exp - BigInt(fracLen);
+  const scaleAbs = scale < 0n ? -scale : scale;
+  if (scaleAbs > MAX_SCALE_ABS) {
+    throw new ChainAmountParseError(`Amount exponent out of supported range: "${s}"`);
+  }
+  let absResult;
+  if (scale >= 0n) {
+    const mult = 10n ** scale;
+    absResult = (allDigits * mult).toString();
+  } else {
+    const k = -scale;
+    const divisor = 10n ** k;
+    const intPart = allDigits / divisor;
+    const rem = allDigits % divisor;
+    const frac = padFractionDigits(rem.toString(), k);
+    absResult = intPart === 0n ? `0.${frac}` : `${intPart.toString()}.${frac}`;
+  }
+  if (signNeg && allDigits !== 0n) {
+    return `-${absResult}`;
+  }
+  return absResult;
+};
+var formatNumberAmount = (amount) => {
+  const str2 = amount.toString();
+  return /[eE]/.test(str2) ? expandScientificNotationToDecimalString(str2) : str2;
+};
+var truncateToDecimals = (s, decimals) => {
+  const dotIdx = s.indexOf(".");
+  if (dotIdx === -1)
+    return s;
+  if (decimals === 0)
+    return s.slice(0, dotIdx);
+  const fracPart = s.slice(dotIdx + 1);
+  if (fracPart.length <= decimals)
+    return s;
+  return `${s.slice(0, dotIdx + 1)}${fracPart.slice(0, decimals)}`;
+};
+var toChainAmount = (amount, decimals) => {
+  if (typeof amount === "string") {
+    const trimmed = amount.trim();
+    if (!trimmed) {
+      throw new ChainAmountParseError("Amount cannot be empty");
+    }
+    if (/[eE]/.test(trimmed)) {
+      const expanded = expandScientificNotationToDecimalString(trimmed);
+      return parseUnits(truncateToDecimals(expanded, decimals), decimals);
+    }
+    return parseUnits(truncateToDecimals(trimmed, decimals), decimals);
+  }
+  return parseUnits(truncateToDecimals(formatNumberAmount(amount), decimals), decimals);
+};
+
+// src/commands/swap.ts
+async function executeSwapChains(ctx2) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner("Loading supported swap chains...");
+  const chains = await vault.getSupportedSwapChains();
+  spinner.succeed("Swap chains loaded");
+  if (isJsonOutput()) {
+    outputJson({ swapChains: [...chains] });
+    return chains;
+  }
+  displaySwapChains(chains);
+  return chains;
+}
+async function executeSwapQuote(ctx2, options) {
+  const isMax = options.amount === "max";
+  const amount = normalizeSwapAmount(options.amount);
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner("Getting swap quote...");
+  const result = await vault.swap({
+    fromChain: options.fromChain,
+    fromSymbol: options.fromToken || "",
+    toChain: options.toChain,
+    toSymbol: options.toToken || "",
+    amount,
+    dryRun: true
+  });
+  if (!result.dryRun) throw new Error("unreachable");
+  spinner.succeed("Quote received");
+  const quote = result.quote;
+  const semanticAmount = isMax ? amount : normalizeSwapAmount(amount, quote.fromCoin.decimals);
+  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : semanticAmount;
+  if (isJsonOutput()) {
+    outputJson({
+      fromChain: options.fromChain,
+      toChain: options.toChain,
+      amount: semanticAmount,
+      isMax,
+      quote
+    });
+    return quote;
+  }
+  const feeBalance = await vault.balance(options.fromChain);
+  const discountTier = await vault.getDiscountTier();
+  displaySwapPreview(quote, fromAmountDisplay, quote.fromCoin.ticker, quote.toCoin.ticker, {
+    fromDecimals: quote.fromCoin.decimals,
+    toDecimals: quote.toCoin.decimals,
+    feeDecimals: feeBalance.decimals,
+    feeSymbol: feeBalance.symbol,
+    discountTier
+  });
+  info('\nTo execute this swap, use the "swap" command');
+  return quote;
+}
+var SWAP_AMOUNT_CANONICAL_DECIMALS = 1e4;
+function normalizeSwapAmount(amount, decimals = SWAP_AMOUNT_CANONICAL_DECIMALS) {
+  if (amount === "max") return amount;
+  try {
+    const chainAmount = toChainAmount(amount, decimals);
+    if (chainAmount <= 0n) throw new Error("Invalid amount");
+    return formatUnits(chainAmount, decimals);
+  } catch {
+    throw new Error("Invalid amount");
+  }
+}
+function toSwapRequest(options, amount, dryRun) {
+  return {
+    fromChain: options.fromChain,
+    fromSymbol: options.fromToken || "",
+    toChain: options.toChain,
+    toSymbol: options.toToken || "",
+    amount,
+    ...options.slippage !== void 0 && { slippageTolerance: options.slippage },
+    ...dryRun && { dryRun: true }
+  };
+}
+function toDryRunResult(options, quote, fromAmountRaw) {
+  const result = {
+    dryRun: true,
+    fromChain: String(options.fromChain),
+    fromToken: quote.fromCoin.ticker,
+    toChain: String(options.toChain),
+    toToken: quote.toCoin.ticker,
+    inputAmount: fromAmountRaw,
+    ...options.amount === "max" && { isMax: true },
+    estimatedOutput: formatBigintAmount(quote.estimatedOutput, quote.toCoin.decimals),
+    provider: quote.provider
+  };
+  if (quote.estimatedOutputFiat != null) result.estimatedOutputFiat = parseFloat(quote.estimatedOutputFiat.toFixed(2));
+  if (quote.requiresApproval) result.requiresApproval = true;
+  if (quote.warnings?.length) result.warnings = [...quote.warnings];
+  return result;
+}
+function displayDryRunResult(result) {
+  info(`
+Dry-run preview:`);
+  info(`  From:             ${result.inputAmount} ${result.fromToken} (${result.fromChain})`);
+  info(`  To:               ${result.estimatedOutput} ${result.toToken} (${result.toChain})`);
+  info(`  Provider:         ${result.provider}`);
+  if (result.estimatedOutputFiat != null) info(`  Est. value (USD): $${result.estimatedOutputFiat}`);
+  if (result.requiresApproval) info(`  Requires approval: yes`);
+  if (result.warnings?.length) result.warnings.forEach((w) => warn(`  Warning: ${w}`));
+}
+function refuseSwapWhenNonInteractive() {
+  throw new ConfirmationRequiredError(
+    "Swap requires confirmation.",
+    "Pass --yes to confirm, or --dry-run to preview without signing."
+  );
+}
+async function confirmSwapIfNeeded(options) {
+  if (options.yes) return;
+  if (isNonInteractive()) {
+    refuseSwapWhenNonInteractive();
+  }
+  const confirmed = await confirmSwap();
+  if (!confirmed) {
+    throw new ConfirmationRequiredError("Swap declined at the confirmation prompt");
+  }
+}
+async function executeSwap(ctx2, options) {
+  const amountStr = normalizeSwapAmount(options.amount);
+  const vault = await ctx2.ensureActiveVault();
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    refuseSwapWhenNonInteractive();
+  }
+  const quoteSpinner = createSpinner("Getting swap quote...");
+  const dryResult = await vault.swap(toSwapRequest(options, amountStr, true));
+  if (!dryResult.dryRun) throw new Error("unreachable");
+  quoteSpinner.succeed("Quote received");
+  const quote = dryResult.quote;
+  const semanticAmount = options.amount === "max" ? amountStr : normalizeSwapAmount(amountStr, quote.fromCoin.decimals);
+  const fromAmountRaw = options.amount === "max" ? formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals) : semanticAmount;
+  const fromAmountDisplay = options.amount === "max" ? `${fromAmountRaw} (max)` : fromAmountRaw;
+  if (options.dryRun) {
+    const result = toDryRunResult(options, quote, fromAmountRaw);
+    if (isJsonOutput()) {
+      outputJson(result);
+    } else {
+      displayDryRunResult(result);
+    }
+    return result;
+  }
+  const feeBalance = await vault.balance(options.fromChain);
+  const discountTier = await vault.getDiscountTier();
+  if (!isJsonOutput()) {
+    displaySwapPreview(quote, fromAmountDisplay, quote.fromCoin.ticker, quote.toCoin.ticker, {
+      fromDecimals: quote.fromCoin.decimals,
+      toDecimals: quote.toCoin.decimals,
+      feeDecimals: feeBalance.decimals,
+      feeSymbol: feeBalance.symbol,
+      discountTier
+    });
+  }
+  await confirmSwapIfNeeded(options);
+  await ensureVaultUnlocked(vault, options.password);
+  const intent = buildSwapBroadcastIntent(vault, {
+    fromChain: options.fromChain,
+    toChain: options.toChain,
+    fromToken: options.fromToken,
+    toToken: options.toToken,
+    amount: fromAmountRaw,
+    isMax: options.amount === "max"
+  });
+  let signSpinner;
+  try {
+    const broadcast = await guardedBroadcast(intent, options.force ?? false, async () => {
+      signSpinner = createSpinner("Signing swap transaction...");
+      vault.on("signingProgress", ({ step }) => {
+        if (signSpinner) signSpinner.text = `${step.message} (${step.progress}%)`;
+      });
+      const result = await vault.swap(toSwapRequest(options, semanticAmount));
+      if (result.dryRun) throw new Error("unreachable");
+      return result;
+    });
+    signSpinner?.succeed(`Swap broadcast: ${broadcast.txHash}`);
+    if (isJsonOutput()) {
+      outputJson({
+        txHash: broadcast.txHash,
+        fromChain: options.fromChain,
+        toChain: options.toChain,
+        quote
+      });
+    } else {
+      displaySwapResult(options.fromChain, options.toChain, broadcast.txHash, quote, quote.toCoin.decimals);
+    }
+    return { txHash: broadcast.txHash, quote };
+  } catch (err) {
+    signSpinner?.stop();
+    throw err;
+  } finally {
+    vault.removeAllListeners("signingProgress");
+  }
+}
+
+// src/commands/settings.ts
+import { Chain as Chain9, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
+import chalk6 from "chalk";
+async function executeCurrency(ctx2, newCurrency) {
+  const vault = await ctx2.ensureActiveVault();
+  if (!newCurrency) {
+    const currentCurrency = vault.currency;
+    const currencyName2 = fiatCurrencyNameRecord3[currentCurrency];
+    printResult(chalk6.cyan("\nCurrent Currency Preference:"));
+    printResult(`  ${chalk6.green(currentCurrency.toUpperCase())} - ${currencyName2}`);
+    info(chalk6.gray(`
+Supported currencies: ${fiatCurrencies2.join(", ")}`));
+    info(chalk6.gray('Use "vultisig currency <code>" to change'));
+    return currentCurrency;
   }
   const currency = newCurrency.toLowerCase();
   if (!fiatCurrencies2.includes(currency)) {
@@ -9682,540 +10096,273 @@ var AskInterface = class {
 `);
         } else {
           process.stderr.write(`[confirm] auto-approved (--yes): ${message}
-`);
-        }
-        return this.autoApprove;
-      }
-    };
-  }
-  /**
-   * Send a message and wait for the complete response.
-   * All tool calls and actions are executed automatically.
-   */
-  async ask(message) {
-    this.responseParts = [];
-    this.toolCalls = [];
-    this.transactions = [];
-    this.cards = [];
-    this.warnings = [];
-    this.outcome = void 0;
-    this.error = void 0;
-    this.errorIsTerminal = false;
-    const callbacks = this.getCallbacks();
-    await this.session.sendMessage(message, callbacks);
-    return this.partialResult();
-  }
-  /**
-   * Snapshot of everything collected so far this turn. Identical to a normal
-   * `ask()` return, but callable from a catch block when `ask()` THREW mid-turn
-   * — e.g. the follow-up request that reports recent_actions back to the backend
-   * fails (timeout/5xx/auth) AFTER a tx has already broadcast and `onTxStatus`
-   * fired. Lets the caller still surface the already-broadcast tx hash in the
-   * error envelope instead of stranding funds the turn just moved.
-   */
-  partialResult() {
-    return {
-      sessionId: this.session.getConversationId() || "",
-      response: this.responseParts[this.responseParts.length - 1] || "",
-      toolCalls: this.toolCalls,
-      transactions: this.transactions,
-      cards: this.cards,
-      warnings: this.warnings,
-      error: this.error,
-      ...this.outcome ? { outcome: this.outcome } : {}
-    };
-  }
-};
-
-// src/agent/auth.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { Chain as Chain10, computePersonalSignHash, formatEcdsaSignature65 } 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(Chain10.Ethereum);
-  const nonce = "0x" + randomBytes2(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 {
-      if (attempt > 1) {
-        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
-`);
-      }
-      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain10.Ethereum }, {});
-      if (signature.recovery === void 0) {
-        throw new Error("Agent authentication requires an ECDSA recovery id");
-      }
-      const sigHex = formatEcdsaSignature65(signature.signature, signature.recovery);
-      const authResponse = await client.authenticate({
-        public_key: publicKey,
-        chain_code_hex: chainCode,
-        message: authMessage,
-        signature: sigHex
-      });
-      return {
-        token: authResponse.token,
-        expiresAt: authResponse.expires_at,
-        // Captured + persisted by the session token cache. The backend exposes
-        // POST /auth/refresh to exchange it for a fresh access token without a
-        // new MPC round; wiring that exchange is a future enhancement — today
-        // the CLI re-auths via a full MPC re-sign (authenticateVault), which is
-        // always available and avoids depending on refresh-token rotation.
-        refreshToken: authResponse.refresh_token
-      };
-    } catch (err) {
-      lastError = err;
-      if (attempt < maxAttempts && err.message?.includes("timeout")) {
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw lastError || new Error("Authentication failed after all attempts");
-}
-
-// src/agent/cards.ts
-import chalk8 from "chalk";
-var CLI_SUPPORTED_SURFACES = ["balance_summary", "turn_outcome"];
-function parseTurnOutcome(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const kind = raw.kind;
-  if (kind !== "success" && kind !== "blocked" && kind !== "refusal" && kind !== "error") return null;
-  const code = raw.code;
-  const detail = raw.detail;
-  return {
-    kind,
-    ...typeof code === "string" ? { code } : {},
-    ...typeof detail === "string" ? { detail } : {}
-  };
-}
-function stripControlChars(s) {
-  let out = "";
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code <= 31 || code >= 127 && code <= 159) continue;
-    out += ch;
-  }
-  return out;
-}
-function asString(v) {
-  return typeof v === "string" ? stripControlChars(v) : "";
-}
-function parseToken(v) {
-  if (!v || typeof v !== "object") return null;
-  const o = v;
-  const symbol = asString(o.symbol);
-  const amountDecimal = asString(o.amountDecimal);
-  if (!symbol && !amountDecimal) return null;
-  const token = { symbol, amountDecimal };
-  const amountUsd = asString(o.amountUsd);
-  if (amountUsd) token.amountUsd = amountUsd;
-  return token;
-}
-function parseAccount(v) {
-  if (!v || typeof v !== "object") return null;
-  const o = v;
-  const chainId = asString(o.chainId);
-  if (!chainId) return null;
-  const tokensRaw = Array.isArray(o.tokens) ? o.tokens : [];
-  const tokens = tokensRaw.map(parseToken).filter((t) => t !== null);
-  return { chainId, address: asString(o.address) || "\u2014", tokens };
-}
-function parseBalanceSummaryEnvelope(value) {
-  if (!value || typeof value !== "object") return null;
-  const o = value;
-  if (o.surface !== "balance_summary") return null;
-  if (!Array.isArray(o.accounts)) return null;
-  const accounts = o.accounts.map(parseAccount).filter((a) => a !== null);
-  if (accounts.length === 0) return null;
-  const card = { surface: "balance_summary", accounts };
-  if (o.stale === true) {
-    card.stale = true;
-    if (typeof o.stale_secs === "number") card.staleSecs = o.stale_secs;
-  }
-  return card;
-}
-function matchBrace(text, start) {
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (ch === '"') inString = true;
-    else if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return i;
-    }
-  }
-  return -1;
-}
-function extractBalanceSummaryFromText(content) {
-  if (!content || !content.includes("balance_summary")) return null;
-  if (content.length > 2e5) return null;
-  for (let i = content.indexOf("{"); i !== -1; i = content.indexOf("{", i + 1)) {
-    const end = matchBrace(content, i);
-    if (end === -1) break;
-    const blob = content.slice(i, end + 1);
-    if (!blob.includes("balance_summary")) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(blob);
-    } catch {
-      continue;
-    }
-    const card = parseBalanceSummaryEnvelope(parsed);
-    if (!card) continue;
-    const before = content.slice(0, i).replace(/```(?:json)?\s*$/i, "");
-    const after = content.slice(end + 1).replace(/^\s*```/, "");
-    const remainingText = (before + after).trim();
-    return { card, remainingText };
-  }
-  return null;
-}
-function shortenAddress(address) {
-  if (!address || address === "\u2014") return address || "\u2014";
-  if (address.length <= 16) return address;
-  return `${address.slice(0, 8)}\u2026${address.slice(-6)}`;
-}
-function parseUsd(amountUsd) {
-  if (!amountUsd) return null;
-  const cleaned = amountUsd.replace(/[$,\s]/g, "");
-  if (!cleaned) return null;
-  const n = Number(cleaned);
-  return Number.isFinite(n) ? n : null;
-}
-function formatUsd(n) {
-  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-}
-function renderBalanceSummaryCard(card) {
-  const lines = [];
-  const staleCue = card.stale ? chalk8.gray(` (stale${card.staleSecs ? ` ~${Math.round(card.staleSecs / 60)}m` : ""}, refreshing\u2026)`) : "";
-  lines.push(chalk8.bold("  Balances") + staleCue);
-  let total = 0;
-  let sawUsd = false;
-  for (const account of card.accounts) {
-    lines.push(`  ${chalk8.cyan(account.chainId)} ${chalk8.gray(`(${shortenAddress(account.address)})`)}`);
-    if (account.tokens.length === 0) {
-      lines.push(chalk8.gray("    (no balances)"));
-      continue;
-    }
-    for (const token of account.tokens) {
-      const usd = parseUsd(token.amountUsd);
-      if (usd !== null) {
-        total += usd;
-        sawUsd = true;
+`);
+        }
+        return this.autoApprove;
       }
-      const symbol = token.symbol.padEnd(10);
-      const amount = token.amountDecimal.padStart(16);
-      const usdCol = token.amountUsd ? chalk8.gray(`  ${token.amountUsd}`) : "";
-      lines.push(`    ${chalk8.bold(symbol)}${amount}${usdCol}`);
-    }
-  }
-  if (sawUsd) {
-    lines.push(chalk8.gray("  " + "\u2500".repeat(36)));
-    lines.push(`  ${chalk8.bold("Total")}  ${chalk8.green(formatUsd(total))}`);
-  }
-  return lines.join("\n");
-}
-
-// src/agent/client.ts
-import { randomUUID } from "node:crypto";
-
-// src/agent/toolOutputSigning.ts
-import { getChainKind as getChainKind4 } from "@vultisig/sdk";
-
-// src/agent/executor.ts
-import {
-  Chain as Chain11,
-  chainFeeCoin,
-  getChainKind as getChainKind3,
-  resolveChainReference,
-  VaultError as VaultError3,
-  VaultErrorCode as VaultErrorCode3,
-  Vultisig as VultisigSdk
-} from "@vultisig/sdk";
-
-// ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
-init_getAddress();
-init_keccak256();
-function publicKeyToAddress(publicKey) {
-  const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
-  return checksumAddress(`0x${address}`);
-}
-
-// ../../node_modules/viem/_esm/utils/signature/recoverPublicKey.js
-init_isHex();
-init_size();
-init_fromHex();
-init_toHex();
-async function recoverPublicKey({ hash, signature }) {
-  const hashHex = isHex(hash) ? hash : toHex(hash);
-  const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
-  const signature_ = (() => {
-    if (typeof signature === "object" && "r" in signature && "s" in signature) {
-      const { r, s, v, yParity } = signature;
-      const yParityOrV2 = Number(yParity ?? v);
-      const recoveryBit2 = toRecoveryBit(yParityOrV2);
-      return new secp256k12.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit2);
-    }
-    const signatureHex = isHex(signature) ? signature : toHex(signature);
-    if (size(signatureHex) !== 65)
-      throw new Error("invalid signature length");
-    const yParityOrV = hexToNumber(`0x${signatureHex.slice(130)}`);
-    const recoveryBit = toRecoveryBit(yParityOrV);
-    return secp256k12.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
-  })();
-  const publicKey = signature_.recoverPublicKey(hashHex.substring(2)).toHex(false);
-  return `0x${publicKey}`;
-}
-function toRecoveryBit(yParityOrV) {
-  if (yParityOrV === 0 || yParityOrV === 1)
-    return yParityOrV;
-  if (yParityOrV === 27)
-    return 0;
-  if (yParityOrV === 28)
-    return 1;
-  throw new Error("Invalid yParityOrV value");
-}
-
-// ../../node_modules/viem/_esm/utils/signature/recoverAddress.js
-async function recoverAddress({ hash, signature }) {
-  return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
-}
-
-// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
-init_encodeAbiParameters();
-init_concat();
-init_toHex();
-init_keccak256();
-
-// ../../node_modules/viem/_esm/utils/typedData.js
-init_abi();
-init_address();
-
-// ../../node_modules/viem/_esm/errors/typedData.js
-init_stringify();
-init_base();
-var InvalidDomainError = class extends BaseError {
-  constructor({ domain }) {
-    super(`Invalid domain "${stringify(domain)}".`, {
-      metaMessages: ["Must be a valid EIP-712 domain."]
-    });
+    };
   }
-};
-var InvalidPrimaryTypeError = class extends BaseError {
-  constructor({ primaryType, types }) {
-    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
-      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
-      metaMessages: ["Check that the primary type is a key in `types`."]
-    });
+  /**
+   * Send a message and wait for the complete response.
+   * All tool calls and actions are executed automatically.
+   */
+  async ask(message) {
+    this.responseParts = [];
+    this.toolCalls = [];
+    this.transactions = [];
+    this.cards = [];
+    this.warnings = [];
+    this.outcome = void 0;
+    this.error = void 0;
+    this.errorIsTerminal = false;
+    const callbacks = this.getCallbacks();
+    await this.session.sendMessage(message, callbacks);
+    return this.partialResult();
   }
-};
-var InvalidStructTypeError = class extends BaseError {
-  constructor({ type }) {
-    super(`Struct type "${type}" is invalid.`, {
-      metaMessages: ["Struct type must not be a Solidity type."],
-      name: "InvalidStructTypeError"
-    });
+  /**
+   * Snapshot of everything collected so far this turn. Identical to a normal
+   * `ask()` return, but callable from a catch block when `ask()` THREW mid-turn
+   * — e.g. the follow-up request that reports recent_actions back to the backend
+   * fails (timeout/5xx/auth) AFTER a tx has already broadcast and `onTxStatus`
+   * fired. Lets the caller still surface the already-broadcast tx hash in the
+   * error envelope instead of stranding funds the turn just moved.
+   */
+  partialResult() {
+    return {
+      sessionId: this.session.getConversationId() || "",
+      response: this.responseParts[this.responseParts.length - 1] || "",
+      toolCalls: this.toolCalls,
+      transactions: this.transactions,
+      cards: this.cards,
+      warnings: this.warnings,
+      error: this.error,
+      ...this.outcome ? { outcome: this.outcome } : {}
+    };
   }
 };
 
-// ../../node_modules/viem/_esm/utils/typedData.js
-init_isAddress();
-init_size();
-init_toHex();
-init_regex();
-function validateTypedData(parameters) {
-  const { domain, message, primaryType, types } = parameters;
-  const validateData = (struct, data) => {
-    for (const param of struct) {
-      const { name, type } = param;
-      const value = data[name];
-      const integerMatch = type.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base === "int",
-          size: Number.parseInt(size_, 10) / 8
-        });
-      }
-      if (type === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError2({ address: value });
-      const bytesMatch = type.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== Number.parseInt(size_, 10))
-          throw new BytesSizeMismatchError({
-            expectedSize: Number.parseInt(size_, 10),
-            givenSize: size(value)
-          });
+// src/agent/auth.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { Chain as Chain10, computePersonalSignHash, formatEcdsaSignature65 } 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(Chain10.Ethereum);
+  const nonce = "0x" + randomBytes3(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 {
+      if (attempt > 1) {
+        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
+`);
       }
-      const struct2 = types[type];
-      if (struct2) {
-        validateReference(type);
-        validateData(struct2, value);
+      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain10.Ethereum }, {});
+      if (signature.recovery === void 0) {
+        throw new Error("Agent authentication requires an ECDSA recovery id");
       }
-    }
-  };
-  if (types.EIP712Domain && domain) {
-    if (typeof domain !== "object")
-      throw new InvalidDomainError({ domain });
-    validateData(types.EIP712Domain, domain);
-  }
-  if (primaryType !== "EIP712Domain") {
-    if (types[primaryType])
-      validateData(types[primaryType], message);
-    else
-      throw new InvalidPrimaryTypeError({ primaryType, types });
-  }
-}
-function getTypesForEIP712Domain({ domain }) {
-  return [
-    typeof domain?.name === "string" && { name: "name", type: "string" },
-    domain?.version && { name: "version", type: "string" },
-    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
-      name: "chainId",
-      type: "uint256"
-    },
-    domain?.verifyingContract && {
-      name: "verifyingContract",
-      type: "address"
-    },
-    domain?.salt && { name: "salt", type: "bytes32" }
-  ].filter(Boolean);
-}
-function validateReference(type) {
-  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
-    throw new InvalidStructTypeError({ type });
+      const sigHex = formatEcdsaSignature65(signature.signature, signature.recovery);
+      const authResponse = await client.authenticate({
+        public_key: publicKey,
+        chain_code_hex: chainCode,
+        message: authMessage,
+        signature: sigHex
+      });
+      return {
+        token: authResponse.token,
+        expiresAt: authResponse.expires_at,
+        // Captured + persisted by the session token cache. The backend exposes
+        // POST /auth/refresh to exchange it for a fresh access token without a
+        // new MPC round; wiring that exchange is a future enhancement — today
+        // the CLI re-auths via a full MPC re-sign (authenticateVault), which is
+        // always available and avoids depending on refresh-token rotation.
+        refreshToken: authResponse.refresh_token
+      };
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts && err.message?.includes("timeout")) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError || new Error("Authentication failed after all attempts");
 }
 
-// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
-function hashTypedData(parameters) {
-  const { domain = {}, message, primaryType } = parameters;
-  const types = {
-    EIP712Domain: getTypesForEIP712Domain({ domain }),
-    ...parameters.types
+// src/agent/cards.ts
+import chalk8 from "chalk";
+var CLI_SUPPORTED_SURFACES = ["balance_summary", "turn_outcome"];
+function parseTurnOutcome(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const kind = raw.kind;
+  if (kind !== "success" && kind !== "blocked" && kind !== "refusal" && kind !== "error") return null;
+  const code = raw.code;
+  const detail = raw.detail;
+  return {
+    kind,
+    ...typeof code === "string" ? { code } : {},
+    ...typeof detail === "string" ? { detail } : {}
   };
-  validateTypedData({
-    domain,
-    message,
-    primaryType,
-    types
-  });
-  const parts = ["0x1901"];
-  if (domain)
-    parts.push(hashDomain({
-      domain,
-      types
-    }));
-  if (primaryType !== "EIP712Domain")
-    parts.push(hashStruct({
-      data: message,
-      primaryType,
-      types
-    }));
-  return keccak256(concat(parts));
 }
-function hashDomain({ domain, types }) {
-  return hashStruct({
-    data: domain,
-    primaryType: "EIP712Domain",
-    types
-  });
+function stripControlChars(s) {
+  let out = "";
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code <= 31 || code >= 127 && code <= 159) continue;
+    out += ch;
+  }
+  return out;
 }
-function hashStruct({ data, primaryType, types }) {
-  const encoded = encodeData({
-    data,
-    primaryType,
-    types
-  });
-  return keccak256(encoded);
+function asString(v) {
+  return typeof v === "string" ? stripControlChars(v) : "";
 }
-function encodeData({ data, primaryType, types }) {
-  const encodedTypes = [{ type: "bytes32" }];
-  const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
-    const [type, value] = encodeField({
-      types,
-      name: field.name,
-      type: field.type,
-      value: data[field.name]
-    });
-    encodedTypes.push(type);
-    encodedValues.push(value);
-  }
-  return encodeAbiParameters(encodedTypes, encodedValues);
+function parseToken(v) {
+  if (!v || typeof v !== "object") return null;
+  const o = v;
+  const symbol = asString(o.symbol);
+  const amountDecimal = asString(o.amountDecimal);
+  if (!symbol && !amountDecimal) return null;
+  const token = { symbol, amountDecimal };
+  const amountUsd = asString(o.amountUsd);
+  if (amountUsd) token.amountUsd = amountUsd;
+  return token;
 }
-function hashType({ primaryType, types }) {
-  const encodedHashType = toHex(encodeType({ primaryType, types }));
-  return keccak256(encodedHashType);
+function parseAccount(v) {
+  if (!v || typeof v !== "object") return null;
+  const o = v;
+  const chainId = asString(o.chainId);
+  if (!chainId) return null;
+  const tokensRaw = Array.isArray(o.tokens) ? o.tokens : [];
+  const tokens = tokensRaw.map(parseToken).filter((t) => t !== null);
+  return { chainId, address: asString(o.address) || "\u2014", tokens };
 }
-function encodeType({ primaryType, types }) {
-  let result = "";
-  const unsortedDeps = findTypeDependencies({ primaryType, types });
-  unsortedDeps.delete(primaryType);
-  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
-  for (const type of deps) {
-    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+function parseBalanceSummaryEnvelope(value) {
+  if (!value || typeof value !== "object") return null;
+  const o = value;
+  if (o.surface !== "balance_summary") return null;
+  if (!Array.isArray(o.accounts)) return null;
+  const accounts = o.accounts.map(parseAccount).filter((a) => a !== null);
+  if (accounts.length === 0) return null;
+  const card = { surface: "balance_summary", accounts };
+  if (o.stale === true) {
+    card.stale = true;
+    if (typeof o.stale_secs === "number") card.staleSecs = o.stale_secs;
   }
-  return result;
+  return card;
 }
-function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
-  const match = primaryType_.match(/^\w*/u);
-  const primaryType = match?.[0];
-  if (results.has(primaryType) || types[primaryType] === void 0) {
-    return results;
+function matchBrace(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
   }
-  results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
+  return -1;
+}
+function extractBalanceSummaryFromText(content) {
+  if (!content || !content.includes("balance_summary")) return null;
+  if (content.length > 2e5) return null;
+  for (let i = content.indexOf("{"); i !== -1; i = content.indexOf("{", i + 1)) {
+    const end = matchBrace(content, i);
+    if (end === -1) break;
+    const blob = content.slice(i, end + 1);
+    if (!blob.includes("balance_summary")) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(blob);
+    } catch {
+      continue;
+    }
+    const card = parseBalanceSummaryEnvelope(parsed);
+    if (!card) continue;
+    const before = content.slice(0, i).replace(/```(?:json)?\s*$/i, "");
+    const after = content.slice(end + 1).replace(/^\s*```/, "");
+    const remainingText = (before + after).trim();
+    return { card, remainingText };
   }
-  return results;
+  return null;
 }
-function encodeField({ types, name, type, value }) {
-  if (types[type] !== void 0) {
-    return [
-      { type: "bytes32" },
-      keccak256(encodeData({ data: value, primaryType: type, types }))
-    ];
+function shortenAddress(address) {
+  if (!address || address === "\u2014") return address || "\u2014";
+  if (address.length <= 16) return address;
+  return `${address.slice(0, 8)}\u2026${address.slice(-6)}`;
+}
+function parseUsd(amountUsd) {
+  if (!amountUsd) return null;
+  const cleaned = amountUsd.replace(/[$,\s]/g, "");
+  if (!cleaned) return null;
+  const n = Number(cleaned);
+  return Number.isFinite(n) ? n : null;
+}
+function formatUsd(n) {
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function renderBalanceSummaryCard(card) {
+  const lines = [];
+  const staleCue = card.stale ? chalk8.gray(` (stale${card.staleSecs ? ` ~${Math.round(card.staleSecs / 60)}m` : ""}, refreshing\u2026)`) : "";
+  lines.push(chalk8.bold("  Balances") + staleCue);
+  let total = 0;
+  let sawUsd = false;
+  for (const account of card.accounts) {
+    lines.push(`  ${chalk8.cyan(account.chainId)} ${chalk8.gray(`(${shortenAddress(account.address)})`)}`);
+    if (account.tokens.length === 0) {
+      lines.push(chalk8.gray("    (no balances)"));
+      continue;
+    }
+    for (const token of account.tokens) {
+      const usd = parseUsd(token.amountUsd);
+      if (usd !== null) {
+        total += usd;
+        sawUsd = true;
+      }
+      const symbol = token.symbol.padEnd(10);
+      const amount = token.amountDecimal.padStart(16);
+      const usdCol = token.amountUsd ? chalk8.gray(`  ${token.amountUsd}`) : "";
+      lines.push(`    ${chalk8.bold(symbol)}${amount}${usdCol}`);
+    }
   }
-  if (type === "bytes")
-    return [{ type: "bytes32" }, keccak256(value)];
-  if (type === "string")
-    return [{ type: "bytes32" }, keccak256(toHex(value))];
-  if (type.lastIndexOf("]") === type.length - 1) {
-    const parsedType = type.slice(0, type.lastIndexOf("["));
-    const typeValuePairs = value.map((item) => encodeField({
-      name,
-      type: parsedType,
-      types,
-      value: item
-    }));
-    return [
-      { type: "bytes32" },
-      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
-    ];
+  if (sawUsd) {
+    lines.push(chalk8.gray("  " + "\u2500".repeat(36)));
+    lines.push(`  ${chalk8.bold("Total")}  ${chalk8.green(formatUsd(total))}`);
   }
-  return [{ type }, value];
+  return lines.join("\n");
 }
 
-// ../../node_modules/viem/_esm/index.js
-init_formatUnits();
+// src/agent/client.ts
+import { randomUUID } from "node:crypto";
+
+// src/agent/toolOutputSigning.ts
+import { getChainKind as getChainKind4 } from "@vultisig/sdk";
+
+// src/agent/executor.ts
+import {
+  Chain as Chain11,
+  chainFeeCoin,
+  getChainKind as getChainKind3,
+  resolveChainReference,
+  VaultError as VaultError3,
+  VaultErrorCode as VaultErrorCode3,
+  Vultisig as VultisigSdk
+} from "@vultisig/sdk";
 
 // src/core/VaultStateStore.ts
 import * as fs3 from "node:fs";
@@ -15132,7 +15279,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.22.0";
+    cachedVersion = "2.23.0";
     return cachedVersion;
   }
   try {
@@ -16529,7 +16676,7 @@ Error: ${error2.message}`));
     const [fromChainStr, toChainStr, amountStr, ...rest] = args;
     const fromChain = findChainByName(fromChainStr) || fromChainStr;
     const toChain = findChainByName(toChainStr) || toChainStr;
-    const amount = parseFloat(amountStr);
+    const amount = amountStr;
     let fromToken;
     let toToken;
     for (let i = 0; i < rest.length; i++) {
@@ -16555,7 +16702,7 @@ Error: ${error2.message}`));
     const [fromChainStr, toChainStr, amountStr, ...rest] = args;
     const fromChain = findChainByName(fromChainStr) || fromChainStr;
     const toChain = findChainByName(toChainStr) || toChainStr;
-    const amount = parseFloat(amountStr);
+    const amount = amountStr;
     let fromToken;
     let toToken;
     let slippage;
@@ -17558,7 +17705,7 @@ Examples:
       await executeSwapQuote(context, {
         fromChain,
         toChain,
-        amount: options.max ? "max" : parseFloat(amountStr),
+        amount: options.max ? "max" : amountStr,
         fromToken: options.fromToken,
         toToken: options.toToken
       });
@@ -17583,7 +17730,7 @@ See also: swap-quote, swap-chains, balance`
       await executeSwap(context, {
         fromChain: findChainByName(fromChainStr) || fromChainStr,
         toChain: findChainByName(toChainStr) || toChainStr,
-        amount: options.max ? "max" : parseFloat(amountStr),
+        amount: options.max ? "max" : amountStr,
         fromToken: options.fromToken,
         toToken: options.toToken,
         slippage: options.slippage ? parseFloat(options.slippage) : void 0,