@vultisig/cli 2.22.0 → 3.0.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);
@@ -5855,12 +5855,20 @@ function displayPortfolio(portfolio, currency, _raw = false) {
   printResult(chalk2.cyan("|  ") + chalk2.bold.green(totalDisplay) + chalk2.cyan("  |"));
   printResult(chalk2.cyan("+----------------------------------------+\n"));
   printResult(chalk2.bold("Chain Breakdown:\n"));
-  const table = portfolio.chainBalances.map(({ chain, balance, value }) => ({
-    Chain: chain,
-    Amount: balance.formattedAmount,
-    Symbol: balance.symbol,
-    Value: value ? `${value.amount} ${value.currency.toUpperCase()}` : "N/A"
-  }));
+  const table = portfolio.chainBalances.flatMap(({ chain, balance, value, tokens }) => [
+    {
+      Chain: chain,
+      Amount: balance.formattedAmount,
+      Symbol: balance.symbol,
+      Value: value ? `${value.amount} ${value.currency.toUpperCase()}` : "N/A"
+    },
+    ...(tokens ?? []).map((token) => ({
+      Chain: chain,
+      Amount: token.balance?.formattedAmount ?? "-",
+      Symbol: token.balance?.symbol ?? token.tokenId,
+      Value: `${token.value.amount} ${token.value.currency.toUpperCase()}`
+    }))
+  ]);
   printTable(table);
 }
 function displayAddresses(addresses) {
@@ -6085,6 +6093,16 @@ async function executeBalance(ctx2, options = {}) {
   const spinner = createSpinner("Loading balances...");
   const raw = options.raw ?? false;
   if (options.chain) {
+    if (options.includeTokens) {
+      const balances = await vault.balances([options.chain], true);
+      spinner.succeed("Balances loaded");
+      if (isJsonOutput()) {
+        outputJson({ chain: options.chain, balances });
+        return;
+      }
+      displayBalancesTable(balances, raw);
+      return;
+    }
     const balance = await vault.balance(options.chain);
     spinner.succeed("Balance loaded");
     if (isJsonOutput()) {
@@ -6115,7 +6133,6 @@ async function executePortfolio(ctx2, options = {}) {
   }
   const currencyName = fiatCurrencyNameRecord2[currency];
   const spinner = createSpinner(`Loading portfolio in ${currencyName}...`);
-  const totalValue = await vault.getTotalValue(currency);
   const chains = vault.chains;
   const results = await Promise.all(
     chains.map(async (chain) => {
@@ -6125,12 +6142,34 @@ async function executePortfolio(ctx2, options = {}) {
       } catch (err) {
         return { failure: { chain, stage: "balance", error: conciseError(err) } };
       }
+      let values;
       try {
-        const value = await vault.getValue(chain, void 0, currency);
-        return { entry: { chain, balance, value } };
+        values = await vault.getValues(chain, currency);
       } catch (err) {
         return { entry: { chain, balance }, failure: { chain, stage: "value", error: conciseError(err) } };
       }
+      const { native, ...tokenValues } = values;
+      if (!native) {
+        try {
+          const retried = await vault.getValue(chain, void 0, currency);
+          return { entry: { chain, balance, value: retried, tokens: await withAmounts(tokenValues) } };
+        } catch (err) {
+          return {
+            entry: { chain, balance, tokens: await withAmounts(tokenValues) },
+            failure: { chain, stage: "value", error: conciseError(err) }
+          };
+        }
+      }
+      return { entry: { chain, balance, value: native, tokens: await withAmounts(tokenValues) } };
+      async function withAmounts(byTokenId) {
+        return Promise.all(
+          Object.entries(byTokenId).map(async ([tokenId, value]) => ({
+            tokenId,
+            value,
+            balance: await vault.balance(chain, tokenId).catch(() => void 0)
+          }))
+        );
+      }
     })
   );
   const chainBalances = [];
@@ -6147,6 +6186,11 @@ async function executePortfolio(ctx2, options = {}) {
       ["Check your internet connection", "Retry in a few moments"]
     );
   }
+  const total = chainBalances.reduce(
+    (sum, entry) => sum + parseFloat(entry.value?.amount ?? "0") + (entry.tokens ?? []).reduce((tokenSum, token) => tokenSum + parseFloat(token.value.amount), 0),
+    0
+  );
+  const totalValue = { amount: total.toFixed(2), currency, lastUpdated: Date.now() };
   const portfolio = { totalValue, chainBalances };
   spinner.succeed("Portfolio loaded");
   if (isJsonOutput()) {
@@ -6324,8 +6368,8 @@ import {
   writeFileSync,
   writeSync
 } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { getVultisigConfigDir } from "@vultisig/client-shared";
 
 // src/agent/agentErrors.ts
 import { VaultError as VaultError2, VaultErrorCode as VaultErrorCode2, VaultImportError as VaultImportError2, VaultImportErrorCode as VaultImportErrorCode2 } from "@vultisig/sdk";
@@ -6560,8 +6604,7 @@ function nowMs() {
 function journalPath() {
   const explicit = process.env.VULTISIG_BROADCAST_JOURNAL_PATH;
   if (explicit && explicit.trim()) return explicit;
-  const dir = process.env.VULTISIG_CONFIG_DIR && process.env.VULTISIG_CONFIG_DIR.trim() ? process.env.VULTISIG_CONFIG_DIR : join(homedir(), ".vultisig");
-  return join(dir, "broadcasts.jsonl");
+  return join(getVultisigConfigDir(), "broadcasts.jsonl");
 }
 function normalize(v, canonicalizeEmptyCalldata = false) {
   const normalized = (v ?? "").trim().toLowerCase();
@@ -7289,7 +7332,7 @@ async function discoverTokens(ctx2, chain) {
     });
   }
   const allTokens = vault.getTokens(chain);
-  spinner.succeed(`Discovered ${newTokens.length} new token(s) on ${chain}`);
+  spinner.succeed(`Now tracking ${newTokens.length} new token(s) on ${chain}`);
   if (isJsonOutput()) {
     outputJson({
       chain,
@@ -7306,6 +7349,9 @@ async function discoverTokens(ctx2, chain) {
     printResult(`  ${d.ticker} (${d.contractAddress})`);
   }
   info(chalk4.gray(`
+Saved to this vault \u2014 tracked tokens count toward portfolio and balance --tokens.`));
+  info(chalk4.gray(`Use --remove <tokenId> to stop tracking one.`));
+  info(chalk4.gray(`
 ${allTokens.length} total token(s) tracked on ${chain}`));
 }
 async function listTokens(ctx2, chain) {
@@ -7378,6 +7424,51 @@ async function executeSend(ctx2, params) {
   }
   return sendTransaction(vault, params);
 }
+async function previewDryRun(vault, params, dryResult, to, destinationTag) {
+  const balance = await vault.balance(params.chain, params.tokenId);
+  const hasInsufficientBalance = parseFloat(dryResult.total) > parseFloat(balance.formattedAmount);
+  const isTokenSend = balance.tokenId !== void 0;
+  const feeBalance = isTokenSend ? await vault.balance(params.chain).catch(() => void 0) : void 0;
+  const warnings = [];
+  if (hasInsufficientBalance) {
+    warnings.push(`Insufficient balance: you have ${balance.formattedAmount} ${balance.symbol}`);
+  }
+  if (isTokenSend && feeBalance === void 0) {
+    warnings.push(`Could not check your ${dryResult.feeSymbol} balance for the network fee`);
+  } else if (feeBalance && parseFloat(dryResult.fee) > parseFloat(feeBalance.formattedAmount)) {
+    warnings.push(
+      `Insufficient ${dryResult.feeSymbol} for the network fee: you have ${feeBalance.formattedAmount} ${dryResult.feeSymbol}, the fee is ${dryResult.fee}`
+    );
+  }
+  const result = {
+    dryRun: true,
+    chain: params.chain,
+    to,
+    amount: params.amount,
+    symbol: balance.symbol,
+    fee: dryResult.fee,
+    feeSymbol: dryResult.feeSymbol,
+    total: dryResult.total,
+    balance: balance.formattedAmount,
+    destinationTag,
+    ...warnings.length > 0 ? { warning: warnings.join(". ") } : {}
+  };
+  if (isJsonOutput()) {
+    outputJson(result);
+    return result;
+  }
+  info(`
+Dry-run preview:`);
+  info(`  Chain:   ${result.chain}`);
+  info(`  To:      ${result.to}`);
+  info(`  Amount:  ${result.amount} ${result.symbol}`);
+  if (result.destinationTag !== void 0) info(`  Destination tag: ${result.destinationTag}`);
+  info(`  Fee:     ${result.fee} ${result.feeSymbol}`);
+  info(`  Total:   ${result.total} ${result.symbol}`);
+  info(`  Balance: ${result.balance} ${result.symbol}`);
+  if (result.warning) warn(`  Warning: ${result.warning}`);
+  return result;
+}
 async function sendTransaction(vault, params) {
   if (!params.dryRun && !params.yes && isNonInteractive()) {
     throw new ConfirmationRequiredError(
@@ -7406,37 +7497,7 @@ async function sendTransaction(vault, params) {
   prepareSpinner.succeed("Transaction prepared");
   if (!dryResult.dryRun) throw new Error("unreachable");
   if (params.dryRun) {
-    const balance2 = await vault.balance(params.chain, params.tokenId);
-    const hasInsufficientBalance = parseFloat(dryResult.total) > parseFloat(balance2.formattedAmount);
-    const result = {
-      dryRun: true,
-      chain: params.chain,
-      to,
-      amount: params.amount,
-      symbol: balance2.symbol,
-      fee: dryResult.fee,
-      total: dryResult.total,
-      balance: balance2.formattedAmount,
-      destinationTag
-    };
-    if (hasInsufficientBalance) {
-      result.warning = `Insufficient balance: you have ${balance2.formattedAmount} ${balance2.symbol}`;
-    }
-    if (isJsonOutput()) {
-      outputJson(result);
-    } else {
-      info(`
-Dry-run preview:`);
-      info(`  Chain:   ${result.chain}`);
-      info(`  To:      ${result.to}`);
-      info(`  Amount:  ${result.amount} ${result.symbol}`);
-      if (result.destinationTag !== void 0) info(`  Destination tag: ${result.destinationTag}`);
-      info(`  Fee:     ${result.fee} ${result.symbol}`);
-      info(`  Total:   ${result.total} ${result.symbol}`);
-      info(`  Balance: ${result.balance} ${result.symbol}`);
-      if (result.warning) warn(`  Warning: ${result.warning}`);
-    }
-    return result;
+    return previewDryRun(vault, params, dryResult, to, destinationTag);
   }
   let gas;
   try {
@@ -8890,1337 +8951,1485 @@ 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();
+
+// ../../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 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;
+};
+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`."]
+    });
   }
-  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 InvalidStructTypeError = class extends BaseError {
+  constructor({ type }) {
+    super(`Struct type "${type}" is invalid.`, {
+      metaMessages: ["Struct type must not be a Solidity type."],
+      name: "InvalidStructTypeError"
     });
   }
-  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;
-    });
-    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);
+};
+
+// ../../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);
+      }
     }
-    return { txHash: broadcast.txHash, quote };
-  } catch (err) {
-    signSpinner?.stop();
-    throw err;
-  } finally {
-    vault.removeAllListeners("signingProgress");
+  };
+  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 });
+}
 
-// 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)) {
-    error(`x Invalid currency: ${newCurrency}`);
-    warn(`Supported currencies: ${fiatCurrencies2.join(", ")}`);
-    throw new Error("Invalid currency");
+// ../../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);
   }
-  const spinner = createSpinner("Updating currency preference...");
-  await vault.setCurrency(currency);
-  spinner.succeed("Currency updated");
-  const currencyName = fiatCurrencyNameRecord3[currency];
-  if (isJsonOutput()) {
-    outputJson({ currency, name: currencyName, updated: true });
-    return currency;
+  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(",")})`;
   }
-  success(`
-+ Currency preference set to ${currency.toUpperCase()} (${currencyName})`);
-  return currency;
+  return result;
 }
-async function executeServer(ctx2) {
-  const spinner = createSpinner("Checking server status...");
-  try {
-    const status = await ctx2.sdk.getServerStatus();
-    spinner.succeed("Server status retrieved");
-    if (isJsonOutput()) {
-      outputJson({ server: status });
-      return status;
-    }
-    printResult(chalk6.cyan("\nServer Status:\n"));
-    printResult(chalk6.bold("Fast Vault Server:"));
-    printResult(`  Online:   ${status.fastVault.online ? chalk6.green("Yes") : chalk6.red("No")}`);
-    if (status.fastVault.latency) {
-      printResult(`  Latency:  ${status.fastVault.latency}ms`);
-    }
-    printResult(chalk6.bold("\nMessage Relay:"));
-    printResult(`  Online:   ${status.messageRelay.online ? chalk6.green("Yes") : chalk6.red("No")}`);
-    if (status.messageRelay.latency) {
-      printResult(`  Latency:  ${status.messageRelay.latency}ms`);
-    }
-    return status;
-  } catch (err) {
-    spinner.fail("Failed to check server status");
-    error(`
-x ${err.message}`);
-    throw err;
+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;
 }
-async function executeAddressBook(ctx2, options = {}) {
-  if (options.add) {
-    let chain = options.chain;
-    let address = options.address;
-    let name = options.name;
-    const prompts = [];
-    if (!chain) {
-      prompts.push({
-        type: "select",
-        name: "chain",
-        message: "Select chain:",
-        choices: Object.values(Chain9)
-      });
-    }
-    if (!address) {
-      prompts.push({
-        type: "input",
-        name: "address",
-        message: "Enter address:",
-        validate: (input) => input.trim() !== "" || "Address is required"
-      });
-    }
-    if (!name) {
-      prompts.push({
-        type: "input",
-        name: "name",
-        message: "Enter name/label:",
-        validate: (input) => input.trim() !== "" || "Name is required"
-      });
-    }
-    if (prompts.length > 0) {
-      const answers = await prompt(prompts);
-      chain = chain || answers.chain;
-      address = address || answers.address?.trim();
-      name = name || answers.name?.trim();
-    }
-    const spinner2 = createSpinner("Adding address to address book...");
-    const entry = {
-      chain,
-      address,
-      name,
-      source: "saved",
-      dateAdded: Date.now()
-    };
-    await ctx2.sdk.addAddressBookEntry([entry]);
-    spinner2.succeed("Address added");
-    if (isJsonOutput()) {
-      outputJson({ added: entry });
-      return [];
-    }
-    success(`
-+ Added ${name} (${chain}: ${address})`);
-    return [];
-  }
-  if (options.remove) {
-    const spinner2 = createSpinner("Removing address from address book...");
-    await ctx2.sdk.removeAddressBookEntry([{ address: options.remove, chain: options.chain }]);
-    spinner2.succeed("Address removed");
-    if (isJsonOutput()) {
-      outputJson({ removed: { address: options.remove, chain: options.chain } });
-      return [];
-    }
-    success(`
-+ Removed ${options.remove}`);
-    return [];
-  }
-  const spinner = createSpinner("Loading address book...");
-  const addressBook = await ctx2.sdk.getAddressBook(options.chain);
-  spinner.succeed("Address book loaded");
-  const allEntries = [...addressBook.saved, ...addressBook.vaults];
-  if (isJsonOutput()) {
-    outputJson({ addressBook: allEntries, chain: options.chain });
-    return allEntries;
+function encodeField({ types, name, type, value }) {
+  if (types[type] !== void 0) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types }))
+    ];
   }
-  if (allEntries.length === 0) {
-    warn(`
-No addresses in address book${options.chain ? ` for ${options.chain}` : ""}`);
-    info(chalk6.gray("\nUse --add to add an address to the address book"));
-  } else {
-    printResult(chalk6.cyan(`
-Address Book${options.chain ? ` (${options.chain})` : ""}:
-`));
-    const table = allEntries.map((entry) => ({
-      Name: entry.name,
-      Chain: entry.chain,
-      Address: entry.address,
-      Source: entry.source
+  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
     }));
-    printTable(table);
-    info(chalk6.gray("\nUse --add to add or --remove <address> to remove an address"));
+    return [
+      { type: "bytes32" },
+      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
+    ];
   }
-  return allEntries;
+  return [{ type }, value];
 }
 
-// src/commands/rujira.ts
-import {
-  getRoutesSummary,
-  listEasyRoutes,
-  RujiraClient,
-  VultisigRujiraProvider
-} from "@vultisig/rujira";
-async function createRujiraClient(ctx2, options = {}) {
-  const vault = await ctx2.ensureActiveVault();
-  const provider = new VultisigRujiraProvider(vault);
-  const client = new RujiraClient({
-    signer: provider,
-    rpcEndpoint: options.rpcEndpoint,
-    config: {
-      // Allow overriding rest endpoint via config (used for thornode calls)
-      ...options.restEndpoint ? { restEndpoint: options.restEndpoint } : {}
+// ../../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}`;
     }
-  });
-  const spinner = createSpinner("Connecting to Rujira/THORChain...");
-  await client.connect();
-  spinner.succeed("Connected");
-  return client;
+    fraction = fraction.slice(0, decimals);
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
 }
-async function executeRujiraBalance(ctx2, options = {}) {
-  const vault = await ctx2.ensureActiveVault();
-  const thorAddress = await vault.address("THORChain");
-  const client = await createRujiraClient(ctx2, options);
-  const spinner = createSpinner("Loading THORChain balances...");
-  const balances = await client.deposit.getBalances(thorAddress);
-  spinner.succeed("Balances loaded");
-  const filtered = options.securedOnly ? balances.filter((b) => b.denom.includes("-") || b.denom.includes("/")) : balances;
-  if (isJsonOutput()) {
-    outputJson({ thorAddress, balances: filtered });
-    return;
+
+// ../../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);
   }
-  info(`THORChain address: ${thorAddress}`);
-  if (!filtered.length) {
-    printResult("No balances found");
-    return;
+};
+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;
   }
-  printTable(
-    filtered.map((b) => ({
-      asset: b.asset,
-      denom: b.denom,
-      amount: b.formatted,
-      raw: b.amount
-    }))
-  );
-}
-async function executeRujiraRoutes() {
-  const routes = listEasyRoutes();
-  const summary = getRoutesSummary();
+  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({ routes, summary });
-    return;
+    outputJson({ swapChains: [...chains] });
+    return chains;
   }
-  printResult(summary);
-  printResult("");
-  printTable(
-    routes.map((r) => ({
-      name: r.name,
-      from: r.from,
-      to: r.to,
-      liquidity: r.liquidity,
-      description: r.description
-    }))
-  );
+  displaySwapChains(chains);
+  return chains;
 }
-async function executeRujiraDeposit(ctx2, options = {}) {
+async function executeSwapQuote(ctx2, options) {
+  const isMax = options.amount === "max";
+  const amount = normalizeSwapAmount(options.amount);
   const vault = await ctx2.ensureActiveVault();
-  const thorAddress = await vault.address("THORChain");
-  const client = await createRujiraClient(ctx2, options);
-  if (!options.asset) {
-    const spinner2 = createSpinner("Loading THORChain inbound addresses...");
-    const inbound = await client.deposit.getInboundAddresses();
-    spinner2.succeed("Inbound addresses loaded");
-    if (isJsonOutput()) {
-      outputJson({ thorAddress, inboundAddresses: inbound });
-      return;
-    }
-    info(`THORChain address: ${thorAddress}`);
-    printResult("Provide an L1 asset to get a chain-specific inbound address + memo.");
-    printResult("Example: vultisig rujira deposit --asset BTC.BTC --amount 100000");
-    printResult("");
-    printTable(
-      inbound.map((a) => ({
-        chain: a.chain,
-        address: a.address,
-        halted: a.halted,
-        globalTradingPaused: a.global_trading_paused,
-        chainTradingPaused: a.chain_trading_paused
-      }))
-    );
-    return;
-  }
-  const amount = options.amount ?? "1";
-  const spinner = createSpinner("Preparing deposit instructions...");
-  const prepared = await client.deposit.prepare({
-    fromAsset: options.asset,
+  const spinner = createSpinner("Getting swap quote...");
+  const result = await vault.swap({
+    fromChain: options.fromChain,
+    fromSymbol: options.fromToken || "",
+    toChain: options.toChain,
+    toSymbol: options.toToken || "",
     amount,
-    thorAddress,
-    affiliate: options.affiliate,
-    affiliateBps: options.affiliateBps
+    dryRun: true
   });
-  spinner.succeed("Deposit prepared");
+  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({ thorAddress, deposit: prepared });
-    return;
+    outputJson({
+      fromChain: options.fromChain,
+      toChain: options.toChain,
+      amount: semanticAmount,
+      isMax,
+      quote
+    });
+    return quote;
   }
-  info(`THORChain address: ${thorAddress}`);
-  printResult("Deposit instructions (send from L1):");
-  printResult(`  Chain:          ${prepared.chain}`);
-  printResult(`  Asset:          ${prepared.asset}`);
-  printResult(`  Inbound address:${prepared.inboundAddress}`);
-  printResult(`  Memo:           ${prepared.memo}`);
-  printResult(`  Min amount:     ${prepared.minimumAmount}`);
-  if (prepared.warning) {
-    warn(prepared.warning);
+  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");
   }
 }
-async function executeRujiraSwap(ctx2, options) {
+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()) {
-    throw new ConfirmationRequiredError(
-      "Swap requires confirmation.",
-      "Pass --yes to confirm, or --dry-run to preview."
-    );
+    refuseSwapWhenNonInteractive();
   }
-  const client = await createRujiraClient(ctx2, options);
-  const destination = options.destination ?? await vault.address("THORChain");
-  const quoteSpinner = createSpinner("Getting FIN swap quote...");
-  const quote = await client.swap.getQuote({
-    fromAsset: options.fromAsset,
-    toAsset: options.toAsset,
-    amount: options.amount,
-    destination,
-    slippageBps: options.slippageBps
-  });
+  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({ dryRun: true, quote });
+      outputJson(result);
     } else {
-      printResult("FIN Swap Preview (dry-run)");
-      printResult(`  From:        ${options.fromAsset}`);
-      printResult(`  To:          ${options.toAsset}`);
-      printResult(`  Amount (in): ${options.amount}`);
-      printResult(`  Expected out:${quote.expectedOutput}`);
-      printResult(`  Min out:     ${quote.minimumOutput}`);
-      printResult(`  Contract:    ${quote.contractAddress}`);
+      displayDryRunResult(result);
     }
-    return;
+    return result;
   }
+  const feeBalance = await vault.balance(options.fromChain);
+  const discountTier = await vault.getDiscountTier();
   if (!isJsonOutput()) {
-    printResult("FIN Swap Preview");
-    printResult(`  From:        ${options.fromAsset}`);
-    printResult(`  To:          ${options.toAsset}`);
-    printResult(`  Amount (in): ${options.amount}`);
-    printResult(`  Expected out:${quote.expectedOutput}`);
-    printResult(`  Min out:     ${quote.minimumOutput}`);
-    printResult(`  Contract:    ${quote.contractAddress}`);
-    if (quote.warning) {
-      warn(quote.warning);
-    }
-  }
-  if (!options.yes) {
-    warn("This command will execute a swap. Re-run with -y/--yes to skip this warning.");
-    throw new ConfirmationRequiredError(
-      "Swap requires confirmation.",
-      "Pass --yes to confirm, or --dry-run to preview."
-    );
+    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 execSpinner = createSpinner("Executing FIN swap...");
-  const result = await client.swap.execute(quote, { slippageBps: options.slippageBps });
-  execSpinner.succeed("Swap submitted");
-  if (isJsonOutput()) {
-    outputJson({ quote, result });
-  } else {
-    printResult(`Tx Hash: ${result.txHash}`);
-  }
-}
-async function executeRujiraWithdraw(ctx2, options) {
-  const vault = await ctx2.ensureActiveVault();
-  if (!options.dryRun && !options.yes && isNonInteractive()) {
-    throw new ConfirmationRequiredError(
-      "Withdrawal requires confirmation.",
-      "Pass --yes to confirm, or --dry-run to preview."
-    );
-  }
-  const client = await createRujiraClient(ctx2, options);
-  const prepSpinner = createSpinner("Preparing withdrawal (MsgDeposit)...");
-  const prepared = await client.withdraw.prepare({
-    asset: options.asset,
-    amount: options.amount,
-    l1Address: options.l1Address,
-    maxFeeBps: options.maxFeeBps
+  const intent = buildSwapBroadcastIntent(vault, {
+    fromChain: options.fromChain,
+    toChain: options.toChain,
+    fromToken: options.fromToken,
+    toToken: options.toToken,
+    amount: fromAmountRaw,
+    isMax: options.amount === "max"
   });
-  prepSpinner.succeed("Withdrawal prepared");
-  if (options.dryRun) {
+  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({ dryRun: true, prepared });
+      outputJson({
+        txHash: broadcast.txHash,
+        fromChain: options.fromChain,
+        toChain: options.toChain,
+        quote
+      });
     } else {
-      printResult("Withdraw Preview (dry-run)");
-      printResult(`  Asset:       ${prepared.asset}`);
-      printResult(`  Amount:      ${prepared.amount}`);
-      printResult(`  Destination: ${prepared.destination}`);
-      printResult(`  Memo:        ${prepared.memo}`);
-      printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+      displaySwapResult(options.fromChain, options.toChain, broadcast.txHash, quote, quote.toCoin.decimals);
     }
-    return;
+    return { txHash: broadcast.txHash, quote };
+  } catch (err) {
+    signSpinner?.stop();
+    throw err;
+  } finally {
+    vault.removeAllListeners("signingProgress");
   }
-  if (!isJsonOutput()) {
-    printResult("Withdraw Preview");
-    printResult(`  Asset:       ${prepared.asset}`);
-    printResult(`  Amount:      ${prepared.amount}`);
-    printResult(`  Destination: ${prepared.destination}`);
-    printResult(`  Memo:        ${prepared.memo}`);
-    printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+}
+
+// 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;
   }
-  if (!options.yes) {
-    warn("This command will broadcast a THORChain MsgDeposit withdrawal. Re-run with -y/--yes to proceed.");
-    throw new ConfirmationRequiredError(
-      "Withdrawal requires confirmation.",
-      "Pass --yes to confirm, or --dry-run to preview."
-    );
+  const currency = newCurrency.toLowerCase();
+  if (!fiatCurrencies2.includes(currency)) {
+    error(`x Invalid currency: ${newCurrency}`);
+    warn(`Supported currencies: ${fiatCurrencies2.join(", ")}`);
+    throw new Error("Invalid currency");
   }
-  await ensureVaultUnlocked(vault, options.password);
-  const execSpinner = createSpinner("Broadcasting withdrawal...");
-  const result = await client.withdraw.execute(prepared);
-  execSpinner.succeed("Withdrawal submitted");
+  const spinner = createSpinner("Updating currency preference...");
+  await vault.setCurrency(currency);
+  spinner.succeed("Currency updated");
+  const currencyName = fiatCurrencyNameRecord3[currency];
   if (isJsonOutput()) {
-    outputJson({ prepared, result });
-  } else {
-    printResult(`Tx Hash: ${result.txHash}`);
+    outputJson({ currency, name: currencyName, updated: true });
+    return currency;
   }
+  success(`
++ Currency preference set to ${currency.toUpperCase()} (${currencyName})`);
+  return currency;
 }
-
-// src/commands/discount.ts
-import {
-  baseAffiliateBps,
-  vultDiscountTierBps,
-  vultDiscountTierMinBalances
-} from "@vultisig/sdk";
-import chalk7 from "chalk";
-var TIER_CONFIG = {
-  none: { bps: baseAffiliateBps, discount: 0 },
-  ...Object.fromEntries(
-    Object.entries(vultDiscountTierMinBalances).map(([tier, minVult]) => [
-      tier,
-      {
-        bps: baseAffiliateBps - vultDiscountTierBps[tier],
-        discount: vultDiscountTierBps[tier],
-        minVult
-      }
-    ])
-  )
-};
-function getTierColor(tier) {
-  const colors = {
-    none: chalk7.gray,
-    bronze: chalk7.hex("#CD7F32"),
-    silver: chalk7.hex("#C0C0C0"),
-    gold: chalk7.hex("#FFD700"),
-    platinum: chalk7.hex("#E5E4E2"),
-    diamond: chalk7.hex("#B9F2FF"),
-    ultimate: chalk7.hex("#FF00FF")
-  };
-  return colors[tier] || chalk7.white;
+async function executeServer(ctx2) {
+  const spinner = createSpinner("Checking server status...");
+  try {
+    const status = await ctx2.sdk.getServerStatus();
+    spinner.succeed("Server status retrieved");
+    if (isJsonOutput()) {
+      outputJson({ server: status });
+      return status;
+    }
+    printResult(chalk6.cyan("\nServer Status:\n"));
+    printResult(chalk6.bold("Fast Vault Server:"));
+    printResult(`  Online:   ${status.fastVault.online ? chalk6.green("Yes") : chalk6.red("No")}`);
+    if (status.fastVault.latency) {
+      printResult(`  Latency:  ${status.fastVault.latency}ms`);
+    }
+    printResult(chalk6.bold("\nMessage Relay:"));
+    printResult(`  Online:   ${status.messageRelay.online ? chalk6.green("Yes") : chalk6.red("No")}`);
+    if (status.messageRelay.latency) {
+      printResult(`  Latency:  ${status.messageRelay.latency}ms`);
+    }
+    return status;
+  } catch (err) {
+    spinner.fail("Failed to check server status");
+    error(`
+x ${err.message}`);
+    throw err;
+  }
 }
-function getNextTier(currentTier) {
-  const tierOrder = ["none", "bronze", "silver", "gold", "platinum", "diamond", "ultimate"];
-  const currentIndex = tierOrder.indexOf(currentTier);
-  if (currentIndex === -1 || currentIndex >= tierOrder.length - 1) {
-    return null;
+async function executeAddressBook(ctx2, options = {}) {
+  if (options.add) {
+    let chain = options.chain;
+    let address = options.address;
+    let name = options.name;
+    const prompts = [];
+    if (!chain) {
+      prompts.push({
+        type: "select",
+        name: "chain",
+        message: "Select chain:",
+        choices: Object.values(Chain9)
+      });
+    }
+    if (!address) {
+      prompts.push({
+        type: "input",
+        name: "address",
+        message: "Enter address:",
+        validate: (input) => input.trim() !== "" || "Address is required"
+      });
+    }
+    if (!name) {
+      prompts.push({
+        type: "input",
+        name: "name",
+        message: "Enter name/label:",
+        validate: (input) => input.trim() !== "" || "Name is required"
+      });
+    }
+    if (prompts.length > 0) {
+      const answers = await prompt(prompts);
+      chain = chain || answers.chain;
+      address = address || answers.address?.trim();
+      name = name || answers.name?.trim();
+    }
+    const spinner2 = createSpinner("Adding address to address book...");
+    const entry = {
+      chain,
+      address,
+      name,
+      source: "saved",
+      dateAdded: Date.now()
+    };
+    await ctx2.sdk.addAddressBookEntry([entry]);
+    spinner2.succeed("Address added");
+    if (isJsonOutput()) {
+      outputJson({ added: entry });
+      return [];
+    }
+    success(`
++ Added ${name} (${chain}: ${address})`);
+    return [];
   }
-  const nextTierName = tierOrder[currentIndex + 1];
-  const config = TIER_CONFIG[nextTierName];
-  if ("minVult" in config) {
-    return { name: nextTierName, vultRequired: config.minVult };
+  if (options.remove) {
+    const spinner2 = createSpinner("Removing address from address book...");
+    await ctx2.sdk.removeAddressBookEntry([{ address: options.remove, chain: options.chain }]);
+    spinner2.succeed("Address removed");
+    if (isJsonOutput()) {
+      outputJson({ removed: { address: options.remove, chain: options.chain } });
+      return [];
+    }
+    success(`
++ Removed ${options.remove}`);
+    return [];
   }
-  return null;
-}
-async function executeDiscount(ctx2, options = {}) {
-  const vault = await ctx2.ensureActiveVault();
-  const spinner = createSpinner(options.refresh ? "Refreshing discount tier..." : "Loading discount tier...");
-  const tierResult = options.refresh ? await vault.updateDiscountTier() : await vault.getDiscountTier();
-  const tier = tierResult || "none";
-  const config = TIER_CONFIG[tier];
-  const nextTier = getNextTier(tier);
-  const tierInfo = {
-    tier,
-    feeBps: config.bps,
-    discountBps: config.discount,
-    nextTier
-  };
-  spinner.succeed("Discount tier loaded");
+  const spinner = createSpinner("Loading address book...");
+  const addressBook = await ctx2.sdk.getAddressBook(options.chain);
+  spinner.succeed("Address book loaded");
+  const allEntries = [...addressBook.saved, ...addressBook.vaults];
   if (isJsonOutput()) {
-    outputJson({
-      tier: tierInfo.tier,
-      feeBps: tierInfo.feeBps,
-      discountBps: tierInfo.discountBps,
-      nextTier: tierInfo.nextTier
-    });
-    return tierInfo;
+    outputJson({ addressBook: allEntries, chain: options.chain });
+    return allEntries;
   }
-  displayDiscountTier(tierInfo);
-  return tierInfo;
-}
-function displayDiscountTier(tierInfo) {
-  const tierColor = getTierColor(tierInfo.tier);
-  printResult(chalk7.cyan("\n+----------------------------------------+"));
-  printResult(chalk7.cyan("|          VULT Discount Tier            |"));
-  printResult(chalk7.cyan("+----------------------------------------+\n"));
-  const tierDisplay = tierInfo.tier === "none" ? chalk7.gray("No Tier") : tierColor(tierInfo.tier.charAt(0).toUpperCase() + tierInfo.tier.slice(1));
-  printResult(`  Current Tier:   ${tierDisplay}`);
-  if (tierInfo.tier === "none") {
-    printResult(`  Swap Fee:       ${chalk7.gray("50 bps (0.50%)")}`);
-    printResult(`  Discount:       ${chalk7.gray("None")}`);
+  if (allEntries.length === 0) {
+    warn(`
+No addresses in address book${options.chain ? ` for ${options.chain}` : ""}`);
+    info(chalk6.gray("\nUse --add to add an address to the address book"));
   } else {
-    printResult(`  Swap Fee:       ${chalk7.green(`${tierInfo.feeBps} bps (${(tierInfo.feeBps / 100).toFixed(2)}%)`)}`);
-    printResult(`  Discount:       ${chalk7.green(`${tierInfo.discountBps} bps saved`)}`);
-  }
-  if (tierInfo.nextTier) {
-    const nextTierColor = getTierColor(tierInfo.nextTier.name);
-    printResult(chalk7.bold("\n  Next Tier:"));
-    printResult(
-      `    ${nextTierColor(tierInfo.nextTier.name.charAt(0).toUpperCase() + tierInfo.nextTier.name.slice(1))} - requires ${tierInfo.nextTier.vultRequired.toLocaleString()} VULT`
-    );
-  } else if (tierInfo.tier === "ultimate") {
-    printResult(chalk7.bold("\n  ") + chalk7.magenta("You have the highest tier! 0% swap fees."));
+    printResult(chalk6.cyan(`
+Address Book${options.chain ? ` (${options.chain})` : ""}:
+`));
+    const table = allEntries.map((entry) => ({
+      Name: entry.name,
+      Chain: entry.chain,
+      Address: entry.address,
+      Source: entry.source
+    }));
+    printTable(table);
+    info(chalk6.gray("\nUse --add to add or --remove <address> to remove an address"));
   }
-  info(chalk7.gray("\n  Tip: Thorguard NFT holders get +1 tier upgrade (up to gold)"));
-  printResult("");
+  return allEntries;
 }
 
-// src/commands/auth.ts
-import { executeAuthLogout, executeAuthSetup, executeAuthStatus } from "@vultisig/client-shared";
-
-// src/commands/agent.ts
-import chalk10 from "chalk";
-import Table from "cli-table3";
-
-// src/agent/ask.ts
-var AskInterface = class {
-  session;
-  verbose;
-  autoApprove;
-  responseParts = [];
-  toolCalls = [];
-  transactions = [];
-  cards = [];
-  warnings = [];
-  outcome;
-  error;
-  // Tracks whether the currently-latched `error` is a terminal one (e.g. the
-  // depth cap). A terminal error may overwrite a prior non-terminal one; once a
-  // terminal error is recorded, later frames cannot replace it. See onError.
-  errorIsTerminal = false;
-  constructor(session, verbose = false, autoApprove = false) {
-    this.session = session;
-    this.verbose = verbose;
-    this.autoApprove = autoApprove;
-  }
-  /**
-   * Whether the turn threw with a still-unacknowledged broadcast (the F1
-   * ack-failure case). The command's catch uses this to gate the ACK_FAILED
-   * re-tag so a later, unrelated retryable error after an already-acked
-   * broadcast keeps its own (retryable) classification instead of exit 8.
-   */
-  hasUnacknowledgedBroadcast() {
-    return this.session.hasUnacknowledgedBroadcast();
-  }
-  /**
-   * Get UI callbacks that silently collect results.
-   * Tool progress is logged to stderr in verbose mode.
-   */
-  getCallbacks() {
-    return {
-      onTextDelta: (_delta) => {
-      },
-      onToolCall: (_id, action, params) => {
-        if (this.verbose) {
-          const paramStr = params ? ` ${JSON.stringify(params)}` : "";
-          process.stderr.write(`[tool] ${action}${paramStr} ...
-`);
-        }
-      },
-      onToolResult: (id, action, success2, data, error2, code) => {
-        this.toolCalls.push({ id, action, success: success2, data, error: error2, code });
-        if (this.verbose) {
-          const status = success2 ? "ok" : `error: ${error2}${code ? ` [${code}]` : ""}`;
-          process.stderr.write(`[tool] ${action}: ${status}
-`);
-        }
-      },
-      onAssistantMessage: (content) => {
-        if (content) {
-          this.responseParts.push(content);
-        }
-      },
-      onBalanceSummary: (card) => {
-        this.cards.push(card);
-      },
-      onTurnOutcome: (outcome) => {
-        this.outcome = outcome;
-      },
-      onSuggestions: (_suggestions) => {
-      },
-      onTxStatus: (txHash, chain, status, explorerUrl) => {
-        const existing = this.transactions.find((t) => t.hash === txHash);
-        if (existing) {
-          existing.status = status;
-          if (explorerUrl) existing.explorerUrl = explorerUrl;
-        } else {
-          this.transactions.push({ hash: txHash, chain, explorerUrl, status });
-        }
-        if (this.verbose) {
-          process.stderr.write(`[tx] ${chain}: ${txHash} (${status})
-`);
-        }
-      },
-      onError: (message, code) => {
-        const isTerminal2 = isTerminalAgentErrorCode(code);
-        if (!this.error || isTerminal2 && !this.errorIsTerminal) {
-          this.error = { message, code };
-          this.errorIsTerminal = isTerminal2;
-        }
-        process.stderr.write(`[error] ${message} [${code}]
-`);
-      },
-      onProtocolWarning: (warning) => {
-        this.warnings.push(warning);
-        process.stderr.write(`[warning] ${warning.message} [${warning.code}]
-`);
-      },
-      onDone: () => {
-      },
-      requestPassword: async () => {
-        throw new Error("Password required but not provided. Use --password flag.");
-      },
-      requestConfirmation: async (message) => {
-        if (!this.autoApprove) {
-          process.stderr.write(`[confirm] signing requires --yes \u2014 NOT broadcasting: ${message}
-`);
-        } 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;
+// src/commands/rujira.ts
+import {
+  getRoutesSummary,
+  listEasyRoutes,
+  RujiraClient,
+  VultisigRujiraProvider
+} from "@vultisig/rujira";
+async function createRujiraClient(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const provider = new VultisigRujiraProvider(vault);
+  const client = new RujiraClient({
+    signer: provider,
+    rpcEndpoint: options.rpcEndpoint,
+    config: {
+      // Allow overriding rest endpoint via config (used for thornode calls)
+      ...options.restEndpoint ? { restEndpoint: options.restEndpoint } : {}
     }
-  }
-  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 } : {}
-  };
+  });
+  const spinner = createSpinner("Connecting to Rujira/THORChain...");
+  await client.connect();
+  spinner.succeed("Connected");
+  return client;
 }
-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;
+async function executeRujiraBalance(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const thorAddress = await vault.address("THORChain");
+  const client = await createRujiraClient(ctx2, options);
+  const spinner = createSpinner("Loading THORChain balances...");
+  const balances = await client.deposit.getBalances(thorAddress);
+  spinner.succeed("Balances loaded");
+  const filtered = options.securedOnly ? balances.filter((b) => b.denom.includes("-") || b.denom.includes("/")) : balances;
+  if (isJsonOutput()) {
+    outputJson({ thorAddress, balances: filtered });
+    return;
   }
-  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 };
+  info(`THORChain address: ${thorAddress}`);
+  if (!filtered.length) {
+    printResult("No balances found");
+    return;
+  }
+  printTable(
+    filtered.map((b) => ({
+      asset: b.asset,
+      denom: b.denom,
+      amount: b.formatted,
+      raw: b.amount
+    }))
+  );
 }
-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;
+async function executeRujiraRoutes() {
+  const routes = listEasyRoutes();
+  const summary = getRoutesSummary();
+  if (isJsonOutput()) {
+    outputJson({ routes, summary });
+    return;
   }
-  return card;
+  printResult(summary);
+  printResult("");
+  printTable(
+    routes.map((r) => ({
+      name: r.name,
+      from: r.from,
+      to: r.to,
+      liquidity: r.liquidity,
+      description: r.description
+    }))
+  );
 }
-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;
+async function executeRujiraDeposit(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const thorAddress = await vault.address("THORChain");
+  const client = await createRujiraClient(ctx2, options);
+  if (!options.asset) {
+    const spinner2 = createSpinner("Loading THORChain inbound addresses...");
+    const inbound = await client.deposit.getInboundAddresses();
+    spinner2.succeed("Inbound addresses loaded");
+    if (isJsonOutput()) {
+      outputJson({ thorAddress, inboundAddresses: inbound });
+      return;
     }
+    info(`THORChain address: ${thorAddress}`);
+    printResult("Provide an L1 asset to get a chain-specific inbound address + memo.");
+    printResult("Example: vultisig rujira deposit --asset BTC.BTC --amount 100000");
+    printResult("");
+    printTable(
+      inbound.map((a) => ({
+        chain: a.chain,
+        address: a.address,
+        halted: a.halted,
+        globalTradingPaused: a.global_trading_paused,
+        chainTradingPaused: a.chain_trading_paused
+      }))
+    );
+    return;
+  }
+  const amount = options.amount ?? "1";
+  const spinner = createSpinner("Preparing deposit instructions...");
+  const prepared = await client.deposit.prepare({
+    fromAsset: options.asset,
+    amount,
+    thorAddress,
+    affiliate: options.affiliate,
+    affiliateBps: options.affiliateBps
+  });
+  spinner.succeed("Deposit prepared");
+  if (isJsonOutput()) {
+    outputJson({ thorAddress, deposit: prepared });
+    return;
+  }
+  info(`THORChain address: ${thorAddress}`);
+  printResult("Deposit instructions (send from L1):");
+  printResult(`  Chain:          ${prepared.chain}`);
+  printResult(`  Asset:          ${prepared.asset}`);
+  printResult(`  Inbound address:${prepared.inboundAddress}`);
+  printResult(`  Memo:           ${prepared.memo}`);
+  printResult(`  Min amount:     ${prepared.minimumAmount}`);
+  if (prepared.warning) {
+    warn(prepared.warning);
   }
-  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;
+async function executeRujiraSwap(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Swap requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
+  const client = await createRujiraClient(ctx2, options);
+  const destination = options.destination ?? await vault.address("THORChain");
+  const quoteSpinner = createSpinner("Getting FIN swap quote...");
+  const quote = await client.swap.getQuote({
+    fromAsset: options.fromAsset,
+    toAsset: options.toAsset,
+    amount: options.amount,
+    destination,
+    slippageBps: options.slippageBps
+  });
+  quoteSpinner.succeed("Quote received");
+  if (options.dryRun) {
+    if (isJsonOutput()) {
+      outputJson({ dryRun: true, quote });
+    } else {
+      printResult("FIN Swap Preview (dry-run)");
+      printResult(`  From:        ${options.fromAsset}`);
+      printResult(`  To:          ${options.toAsset}`);
+      printResult(`  Amount (in): ${options.amount}`);
+      printResult(`  Expected out:${quote.expectedOutput}`);
+      printResult(`  Min out:     ${quote.minimumOutput}`);
+      printResult(`  Contract:    ${quote.contractAddress}`);
     }
-    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;
   }
-  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;
+  if (!isJsonOutput()) {
+    printResult("FIN Swap Preview");
+    printResult(`  From:        ${options.fromAsset}`);
+    printResult(`  To:          ${options.toAsset}`);
+    printResult(`  Amount (in): ${options.amount}`);
+    printResult(`  Expected out:${quote.expectedOutput}`);
+    printResult(`  Min out:     ${quote.minimumOutput}`);
+    printResult(`  Contract:    ${quote.contractAddress}`);
+    if (quote.warning) {
+      warn(quote.warning);
     }
-    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 (!options.yes) {
+    warn("This command will execute a swap. Re-run with -y/--yes to skip this warning.");
+    throw new ConfirmationRequiredError(
+      "Swap requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
+  await ensureVaultUnlocked(vault, options.password);
+  const execSpinner = createSpinner("Executing FIN swap...");
+  const result = await client.swap.execute(quote, { slippageBps: options.slippageBps });
+  execSpinner.succeed("Swap submitted");
+  if (isJsonOutput()) {
+    outputJson({ quote, result });
+  } else {
+    printResult(`Tx Hash: ${result.txHash}`);
+  }
+}
+async function executeRujiraWithdraw(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  if (!options.dryRun && !options.yes && isNonInteractive()) {
+    throw new ConfirmationRequiredError(
+      "Withdrawal requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
+  const client = await createRujiraClient(ctx2, options);
+  const prepSpinner = createSpinner("Preparing withdrawal (MsgDeposit)...");
+  const prepared = await client.withdraw.prepare({
+    asset: options.asset,
+    amount: options.amount,
+    l1Address: options.l1Address,
+    maxFeeBps: options.maxFeeBps
+  });
+  prepSpinner.succeed("Withdrawal prepared");
+  if (options.dryRun) {
+    if (isJsonOutput()) {
+      outputJson({ dryRun: true, prepared });
+    } else {
+      printResult("Withdraw Preview (dry-run)");
+      printResult(`  Asset:       ${prepared.asset}`);
+      printResult(`  Amount:      ${prepared.amount}`);
+      printResult(`  Destination: ${prepared.destination}`);
+      printResult(`  Memo:        ${prepared.memo}`);
+      printResult(`  Est. fee:    ${prepared.estimatedFee}`);
     }
+    return;
   }
-  if (sawUsd) {
-    lines.push(chalk8.gray("  " + "\u2500".repeat(36)));
-    lines.push(`  ${chalk8.bold("Total")}  ${chalk8.green(formatUsd(total))}`);
+  if (!isJsonOutput()) {
+    printResult("Withdraw Preview");
+    printResult(`  Asset:       ${prepared.asset}`);
+    printResult(`  Amount:      ${prepared.amount}`);
+    printResult(`  Destination: ${prepared.destination}`);
+    printResult(`  Memo:        ${prepared.memo}`);
+    printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+  }
+  if (!options.yes) {
+    warn("This command will broadcast a THORChain MsgDeposit withdrawal. Re-run with -y/--yes to proceed.");
+    throw new ConfirmationRequiredError(
+      "Withdrawal requires confirmation.",
+      "Pass --yes to confirm, or --dry-run to preview."
+    );
+  }
+  await ensureVaultUnlocked(vault, options.password);
+  const execSpinner = createSpinner("Broadcasting withdrawal...");
+  const result = await client.withdraw.execute(prepared);
+  execSpinner.succeed("Withdrawal submitted");
+  if (isJsonOutput()) {
+    outputJson({ prepared, result });
+  } else {
+    printResult(`Tx Hash: ${result.txHash}`);
   }
-  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
+// src/commands/discount.ts
 import {
-  Chain as Chain11,
-  chainFeeCoin,
-  getChainKind as getChainKind3,
-  resolveChainReference,
-  VaultError as VaultError3,
-  VaultErrorCode as VaultErrorCode3,
-  Vultisig as VultisigSdk
+  baseAffiliateBps,
+  vultDiscountTierBps,
+  vultDiscountTierMinBalances
 } 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}`);
+import chalk7 from "chalk";
+var TIER_CONFIG = {
+  none: { bps: baseAffiliateBps, discount: 0 },
+  ...Object.fromEntries(
+    Object.entries(vultDiscountTierMinBalances).map(([tier, minVult]) => [
+      tier,
+      {
+        bps: baseAffiliateBps - vultDiscountTierBps[tier],
+        discount: vultDiscountTierBps[tier],
+        minVult
+      }
+    ])
+  )
+};
+function getTierColor(tier) {
+  const colors = {
+    none: chalk7.gray,
+    bronze: chalk7.hex("#CD7F32"),
+    silver: chalk7.hex("#C0C0C0"),
+    gold: chalk7.hex("#FFD700"),
+    platinum: chalk7.hex("#E5E4E2"),
+    diamond: chalk7.hex("#B9F2FF"),
+    ultimate: chalk7.hex("#FF00FF")
+  };
+  return colors[tier] || chalk7.white;
 }
-
-// ../../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 getNextTier(currentTier) {
+  const tierOrder = ["none", "bronze", "silver", "gold", "platinum", "diamond", "ultimate"];
+  const currentIndex = tierOrder.indexOf(currentTier);
+  if (currentIndex === -1 || currentIndex >= tierOrder.length - 1) {
+    return null;
+  }
+  const nextTierName = tierOrder[currentIndex + 1];
+  const config = TIER_CONFIG[nextTierName];
+  if ("minVult" in config) {
+    return { name: nextTierName, vultRequired: config.minVult };
+  }
+  return null;
 }
-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 executeDiscount(ctx2, options = {}) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner(options.refresh ? "Refreshing discount tier..." : "Loading discount tier...");
+  const tierResult = options.refresh ? await vault.updateDiscountTier() : await vault.getDiscountTier();
+  const tier = tierResult || "none";
+  const config = TIER_CONFIG[tier];
+  const nextTier = getNextTier(tier);
+  const tierInfo = {
+    tier,
+    feeBps: config.bps,
+    discountBps: config.discount,
+    nextTier
+  };
+  spinner.succeed("Discount tier loaded");
+  if (isJsonOutput()) {
+    outputJson({
+      tier: tierInfo.tier,
+      feeBps: tierInfo.feeBps,
+      discountBps: tierInfo.discountBps,
+      nextTier: tierInfo.nextTier
+    });
+    return tierInfo;
+  }
+  displayDiscountTier(tierInfo);
+  return tierInfo;
 }
-
-// ../../node_modules/viem/_esm/utils/signature/recoverAddress.js
-async function recoverAddress({ hash, signature }) {
-  return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
+function displayDiscountTier(tierInfo) {
+  const tierColor = getTierColor(tierInfo.tier);
+  printResult(chalk7.cyan("\n+----------------------------------------+"));
+  printResult(chalk7.cyan("|          VULT Discount Tier            |"));
+  printResult(chalk7.cyan("+----------------------------------------+\n"));
+  const tierDisplay = tierInfo.tier === "none" ? chalk7.gray("No Tier") : tierColor(tierInfo.tier.charAt(0).toUpperCase() + tierInfo.tier.slice(1));
+  printResult(`  Current Tier:   ${tierDisplay}`);
+  if (tierInfo.tier === "none") {
+    printResult(`  Swap Fee:       ${chalk7.gray("50 bps (0.50%)")}`);
+    printResult(`  Discount:       ${chalk7.gray("None")}`);
+  } else {
+    printResult(`  Swap Fee:       ${chalk7.green(`${tierInfo.feeBps} bps (${(tierInfo.feeBps / 100).toFixed(2)}%)`)}`);
+    printResult(`  Discount:       ${chalk7.green(`${tierInfo.discountBps} bps saved`)}`);
+  }
+  if (tierInfo.nextTier) {
+    const nextTierColor = getTierColor(tierInfo.nextTier.name);
+    printResult(chalk7.bold("\n  Next Tier:"));
+    printResult(
+      `    ${nextTierColor(tierInfo.nextTier.name.charAt(0).toUpperCase() + tierInfo.nextTier.name.slice(1))} - requires ${tierInfo.nextTier.vultRequired.toLocaleString()} VULT`
+    );
+  } else if (tierInfo.tier === "ultimate") {
+    printResult(chalk7.bold("\n  ") + chalk7.magenta("You have the highest tier! 0% swap fees."));
+  }
+  info(chalk7.gray("\n  Tip: Thorguard NFT holders get +1 tier upgrade (up to gold)"));
+  printResult("");
 }
 
-// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
-init_encodeAbiParameters();
-init_concat();
-init_toHex();
-init_keccak256();
+// src/commands/auth.ts
+import { executeAuthLogout, executeAuthSetup, executeAuthStatus } from "@vultisig/client-shared";
 
-// ../../node_modules/viem/_esm/utils/typedData.js
-init_abi();
-init_address();
+// src/commands/agent.ts
+import chalk10 from "chalk";
+import Table from "cli-table3";
 
-// ../../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."]
-    });
+// src/agent/ask.ts
+var AskInterface = class {
+  session;
+  verbose;
+  autoApprove;
+  responseParts = [];
+  toolCalls = [];
+  transactions = [];
+  cards = [];
+  warnings = [];
+  outcome;
+  error;
+  // Tracks whether the currently-latched `error` is a terminal one (e.g. the
+  // depth cap). A terminal error may overwrite a prior non-terminal one; once a
+  // terminal error is recorded, later frames cannot replace it. See onError.
+  errorIsTerminal = false;
+  constructor(session, verbose = false, autoApprove = false) {
+    this.session = session;
+    this.verbose = verbose;
+    this.autoApprove = autoApprove;
+  }
+  /**
+   * Whether the turn threw with a still-unacknowledged broadcast (the F1
+   * ack-failure case). The command's catch uses this to gate the ACK_FAILED
+   * re-tag so a later, unrelated retryable error after an already-acked
+   * broadcast keeps its own (retryable) classification instead of exit 8.
+   */
+  hasUnacknowledgedBroadcast() {
+    return this.session.hasUnacknowledgedBroadcast();
   }
-};
-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`."]
-    });
+  /**
+   * Get UI callbacks that silently collect results.
+   * Tool progress is logged to stderr in verbose mode.
+   */
+  getCallbacks() {
+    return {
+      onTextDelta: (_delta) => {
+      },
+      onToolCall: (_id, action, params) => {
+        if (this.verbose) {
+          const paramStr = params ? ` ${JSON.stringify(params)}` : "";
+          process.stderr.write(`[tool] ${action}${paramStr} ...
+`);
+        }
+      },
+      onToolResult: (id, action, success2, data, error2, code) => {
+        this.toolCalls.push({ id, action, success: success2, data, error: error2, code });
+        if (this.verbose) {
+          const status = success2 ? "ok" : `error: ${error2}${code ? ` [${code}]` : ""}`;
+          process.stderr.write(`[tool] ${action}: ${status}
+`);
+        }
+      },
+      onAssistantMessage: (content) => {
+        if (content) {
+          this.responseParts.push(content);
+        }
+      },
+      onBalanceSummary: (card) => {
+        this.cards.push(card);
+      },
+      onTurnOutcome: (outcome) => {
+        this.outcome = outcome;
+      },
+      onSuggestions: (_suggestions) => {
+      },
+      onTxStatus: (txHash, chain, status, explorerUrl) => {
+        const existing = this.transactions.find((t) => t.hash === txHash);
+        if (existing) {
+          existing.status = status;
+          if (explorerUrl) existing.explorerUrl = explorerUrl;
+        } else {
+          this.transactions.push({ hash: txHash, chain, explorerUrl, status });
+        }
+        if (this.verbose) {
+          process.stderr.write(`[tx] ${chain}: ${txHash} (${status})
+`);
+        }
+      },
+      onError: (message, code) => {
+        const isTerminal2 = isTerminalAgentErrorCode(code);
+        if (!this.error || isTerminal2 && !this.errorIsTerminal) {
+          this.error = { message, code };
+          this.errorIsTerminal = isTerminal2;
+        }
+        process.stderr.write(`[error] ${message} [${code}]
+`);
+      },
+      onProtocolWarning: (warning) => {
+        this.warnings.push(warning);
+        process.stderr.write(`[warning] ${warning.message} [${warning.code}]
+`);
+      },
+      onDone: () => {
+      },
+      requestPassword: async () => {
+        throw new Error("Password required but not provided. Use --password flag.");
+      },
+      requestConfirmation: async (message) => {
+        if (!this.autoApprove) {
+          process.stderr.write(`[confirm] signing requires --yes \u2014 NOT broadcasting: ${message}
+`);
+        } else {
+          process.stderr.write(`[confirm] auto-approved (--yes): ${message}
+`);
+        }
+        return this.autoApprove;
+      }
+    };
   }
-};
-var InvalidStructTypeError = class extends BaseError {
-  constructor({ type }) {
-    super(`Struct type "${type}" is invalid.`, {
-      metaMessages: ["Struct type must not be a Solidity type."],
-      name: "InvalidStructTypeError"
-    });
+  /**
+   * 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 } : {}
+    };
   }
 };
 
-// ../../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
-        });
+// 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}...
+`);
       }
-      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 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 struct2 = types[type];
-      if (struct2) {
-        validateReference(type);
-        validateData(struct2, value);
+      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;
     }
-  };
-  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 });
+  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,
+  parseThorSwapMemo,
+  resolveChainReference,
+  VaultError as VaultError3,
+  VaultErrorCode as VaultErrorCode3,
+  Vultisig as VultisigSdk
+} from "@vultisig/sdk";
 
 // src/core/VaultStateStore.ts
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
-import { getVultisigConfigDir } from "@vultisig/client-shared";
+import { getVultisigConfigDir as getVultisigConfigDir2 } from "@vultisig/client-shared";
 var LOCK_STALE_MS = 6e4;
 var LOCK_RETRY_INIT_MS = 100;
 var LOCK_MAX_WAIT_MS = 3e4;
@@ -10232,7 +10441,7 @@ var VaultStateStore = class {
     if (!safeId) {
       throw new Error("Invalid vaultId: must contain alphanumeric characters");
     }
-    this.baseDir = path3.join(getVultisigConfigDir(), "vault-state", safeId);
+    this.baseDir = path3.join(getVultisigConfigDir2(), "vault-state", safeId);
     fs3.mkdirSync(this.baseDir, { recursive: true });
   }
   // -------------------------------------------------------------------------
@@ -10373,45 +10582,6 @@ function sleep2(ms) {
 }
 
 // src/agent/executor.ts
-var THOR_MEMO_CHAIN_TO_ENUM = {
-  BTC: Chain11.Bitcoin,
-  ETH: Chain11.Ethereum,
-  BSC: Chain11.BSC,
-  AVAX: Chain11.Avalanche,
-  BASE: Chain11.Base,
-  // L2 — THORChain routinely quotes Base destinations (PR #439 review finding 1)
-  ARB: Chain11.Arbitrum,
-  // L1-via-bridge path (PR #439 review finding 1)
-  BCH: Chain11.BitcoinCash,
-  LTC: Chain11.Litecoin,
-  DOGE: Chain11.Dogecoin,
-  GAIA: Chain11.Cosmos,
-  THOR: Chain11.THORChain,
-  RUNE: Chain11.THORChain,
-  XRP: Chain11.Ripple,
-  DASH: Chain11.Dash,
-  ZEC: Chain11.Zcash,
-  MAYA: Chain11.MayaChain,
-  CACAO: Chain11.MayaChain
-};
-var THOR_MEMO_ASSET_SHORTCUTS = {
-  b: "BTC.BTC",
-  e: "ETH.ETH",
-  s: "BSC.BNB",
-  a: "AVAX.AVAX",
-  c: "BCH.BCH",
-  l: "LTC.LTC",
-  d: "DOGE.DOGE",
-  g: "GAIA.ATOM",
-  r: "THOR.RUNE",
-  x: "XRP.XRP",
-  cacao: "MAYA.CACAO",
-  dash: "DASH.DASH",
-  zec: "ZEC.ZEC"
-  // BASE / ARB don't have documented single-letter shortcuts; THORChain
-  // emits these as the full CHAIN.ASSET form in memos. Listed in
-  // THOR_MEMO_CHAIN_TO_ENUM only.
-};
 var EVM_CHAINS = /* @__PURE__ */ new Set([
   "Ethereum",
   "BSC",
@@ -11072,13 +11242,7 @@ var AgentExecutor = class {
     const txArgs = serverTxData?.txArgs ?? {};
     const memo = typeof txArgs.memo === "string" ? txArgs.memo : "";
     const parsed = parseThorSwapMemo(memo);
-    const toChain = THOR_MEMO_CHAIN_TO_ENUM[parsed.destChainCode];
-    if (!toChain) {
-      throw new VaultError3(
-        VaultErrorCode3.UnsupportedChain,
-        `signThorMsgDepositSwap: unsupported destination chain code '${parsed.destChainCode}' in memo '${memo}'.`
-      );
-    }
+    const toChain = parsed.toChain;
     const vaultDestAddress = await this.vault.address(toChain);
     const normalizeForCompare = (addr) => EVM_CHAINS.has(toChain) ? addr.toLowerCase() : addr;
     if (parsed.destAddress && normalizeForCompare(parsed.destAddress) !== normalizeForCompare(vaultDestAddress)) {
@@ -11887,31 +12051,6 @@ function parseNonEvmEnvelope(serverTxData, chain) {
   const memo = typeof txArgs.memo === "string" && txArgs.memo.length > 0 ? txArgs.memo : void 0;
   return { chain, to, amount: amountDecimal, symbol, memo };
 }
-function parseThorSwapMemo(memo) {
-  if (!memo.startsWith("=:")) {
-    throw new VaultError3(
-      VaultErrorCode3.NotImplemented,
-      `parseThorSwapMemo: only swap memos (=:CHAIN.ASSET:DEST...) supported on this path; got memo='${memo}'. LP memos (+:/-:) route through signThorMsgDepositLp; loan / validator ops out of scope.`
-    );
-  }
-  const memoBody = memo.slice(2);
-  const parts = memoBody.split(":");
-  let chainAsset = parts[0];
-  if (chainAsset && !chainAsset.includes(".")) {
-    const expanded = THOR_MEMO_ASSET_SHORTCUTS[chainAsset.toLowerCase()];
-    if (expanded) chainAsset = expanded;
-  }
-  if (!chainAsset || !chainAsset.includes(".")) {
-    throw new VaultError3(
-      VaultErrorCode3.InvalidConfig,
-      `parseThorSwapMemo: malformed swap memo '${memo}': missing CHAIN.ASSET in first segment.`
-    );
-  }
-  const [destChainCode, destAssetRaw] = chainAsset.split(".");
-  const destAsset = destAssetRaw?.split("-")[0] ?? "";
-  const destAddress = typeof parts[1] === "string" ? parts[1] : "";
-  return { destChainCode, destAsset, destAddress };
-}
 function resolveChainId(chainId) {
   return resolveChainReference(chainId) ?? null;
 }
@@ -13348,13 +13487,13 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir } from "node:os";
 import { dirname as dirname2, join as join3 } from "node:path";
 var LOCK_RETRY_MS = 25;
 var LOCK_MAX_WAIT_MS2 = 5e3;
 var LOCK_STALE_MS2 = 3e4;
 function getTokenCachePath() {
-  const dir = process.env.VULTISIG_CONFIG_DIR ?? join3(homedir2(), ".vultisig");
+  const dir = process.env.VULTISIG_CONFIG_DIR ?? join3(homedir(), ".vultisig");
   return join3(dir, "agent-tokens.json");
 }
 function tokenCacheKey(scope) {
@@ -15124,7 +15263,7 @@ function formatDate(iso) {
 }
 
 // src/lib/version.ts
-import { getVultisigConfigDir as getVultisigConfigDir2 } from "@vultisig/client-shared";
+import { getVultisigConfigDir as getVultisigConfigDir3 } from "@vultisig/client-shared";
 import chalk11 from "chalk";
 import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
@@ -15132,7 +15271,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.22.0";
+    cachedVersion = "3.0.0";
     return cachedVersion;
   }
   try {
@@ -15145,7 +15284,7 @@ function getVersion() {
     return cachedVersion;
   }
 }
-var CACHE_DIR = join4(getVultisigConfigDir2(), "cache");
+var CACHE_DIR = join4(getVultisigConfigDir3(), "cache");
 var VERSION_CACHE_FILE = join4(CACHE_DIR, "version-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function readVersionCache() {
@@ -15229,7 +15368,7 @@ function formatVersionShort() {
 }
 function formatVersionDetailed() {
   const lines = [];
-  const configDir = getVultisigConfigDir2();
+  const configDir = getVultisigConfigDir3();
   lines.push(chalk11.bold(`Vultisig CLI v${getVersion()}`));
   lines.push("");
   lines.push(`  Node.js:   ${process.version}`);
@@ -16529,7 +16668,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 +16694,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;
@@ -16669,10 +16808,10 @@ Error: ${error2.message}`));
 };
 
 // src/lib/completion.ts
+import { getVultisigConfigDir as getVultisigConfigDir4 } from "@vultisig/client-shared";
 import { SUPPORTED_CHAINS as SUPPORTED_CHAINS2 } from "@vultisig/sdk";
 import { program } from "commander";
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir3 } from "os";
 import { join as join5 } from "path";
 var tabtab = null;
 async function getTabtab() {
@@ -16696,7 +16835,7 @@ function getChains() {
 }
 function getVaultNames() {
   try {
-    const vaultDir = join5(homedir3(), ".vultisig", "vaults");
+    const vaultDir = getVultisigConfigDir4();
     if (!existsSync3(vaultDir)) return [];
     const files = readdirSync(vaultDir);
     const names = [];
@@ -16704,9 +16843,10 @@ function getVaultNames() {
       if (file.startsWith("vault:") && file.endsWith(".json")) {
         try {
           const content = readFileSync5(join5(vaultDir, file), "utf-8");
-          const vault = JSON.parse(content);
-          if (vault.name) names.push(vault.name);
-          if (vault.id) names.push(vault.id);
+          const parsed = JSON.parse(content);
+          const vault = parsed?.value ?? parsed;
+          if (vault?.name) names.push(vault.name);
+          if (vault?.id) names.push(vault.id);
         } catch {
         }
       }
@@ -16948,12 +17088,10 @@ complete -c vsig -n "__fish_seen_subcommand_from import export" -a "(__fish_comp
 }
 
 // src/lib/config.ts
+import { getVultisigConfigDir as getVultisigConfigDir5 } from "@vultisig/client-shared";
 import { FileStorage } from "@vultisig/sdk/node";
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
 function getConfigDir() {
-  const override = process.env.VULTISIG_CONFIG_DIR?.trim();
-  return override ? override : join6(homedir4(), ".vultisig");
+  return getVultisigConfigDir5();
 }
 function createVaultStorage() {
   return new FileStorage({ basePath: getConfigDir() });
@@ -17511,9 +17649,13 @@ program2.command("delete [vault]").description("Delete a vault from local storag
     });
   })
 );
-program2.command("tokens <chain>").description("List and manage tokens for a chain").option("--add <contractAddress>", "Add a token by contract address").option("--remove <tokenId>", "Remove a token by ID").option("--discover", "Auto-discover tokens with balances on the chain").addHelpText(
+program2.command("tokens <chain>").description("List and manage tokens for a chain").option("--add <contractAddress>", "Add a token by contract address").option("--remove <tokenId>", "Remove a token by ID").option("--discover", "Find tokens with balances on the chain and save them to this vault").addHelpText(
   "after",
   `
+--discover writes to the vault: every token it finds is saved to the tracked
+list, so it also changes what portfolio and balance --tokens report. Use
+--remove <tokenId> to stop tracking one.
+
 Examples:
   vultisig tokens Ethereum
   vultisig tokens Ethereum --discover --output json
@@ -17558,7 +17700,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 +17725,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,