@vultisig/cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -1042,14 +1042,14 @@ var require_main = __commonJS({
           cb = opts;
           opts = {};
         }
-        var qrcode4 = new QRCode(-1, this.error);
-        qrcode4.addData(input);
-        qrcode4.make();
+        var qrcode5 = new QRCode(-1, this.error);
+        qrcode5.addData(input);
+        qrcode5.make();
         var output = "";
         if (opts && opts.small) {
           var BLACK = true, WHITE = false;
-          var moduleCount = qrcode4.getModuleCount();
-          var moduleData = qrcode4.modules.slice();
+          var moduleCount = qrcode5.getModuleCount();
+          var moduleData = qrcode5.modules.slice();
           var oddRow = moduleCount % 2 === 1;
           if (oddRow) {
             moduleData.push(fill(moduleCount, WHITE));
@@ -1082,9 +1082,9 @@ var require_main = __commonJS({
             output += borderBottom;
           }
         } else {
-          var border = repeat(white).times(qrcode4.getModuleCount() + 3);
+          var border = repeat(white).times(qrcode5.getModuleCount() + 3);
           output += border + "\n";
-          qrcode4.modules.forEach(function(row2) {
+          qrcode5.modules.forEach(function(row2) {
             output += white;
             output += row2.map(toCell).join("");
             output += white + "\n";
@@ -1103,10 +1103,10 @@ var require_main = __commonJS({
 
 // src/index.ts
 import "dotenv/config";
-import { parseKeygenQR, Vultisig as Vultisig4 } from "@vultisig/sdk";
-import chalk12 from "chalk";
+import { promises as fs3 } from "node:fs";
+import { parseKeygenQR, Vultisig as Vultisig5 } from "@vultisig/sdk";
+import chalk13 from "chalk";
 import { program } from "commander";
-import { promises as fs3 } from "fs";
 import inquirer8 from "inquirer";
 
 // src/core/command-context.ts
@@ -1446,25 +1446,25 @@ import { fiatCurrencies, fiatCurrencyNameRecord as fiatCurrencyNameRecord2 } fro
 import { fiatCurrencyNameRecord, Vultisig } from "@vultisig/sdk";
 import chalk2 from "chalk";
 import inquirer2 from "inquirer";
-function displayBalance(chain, balance) {
+function displayBalance(chain, balance, _raw = false) {
   printResult(chalk2.cyan(`
 ${chain} Balance:`));
-  printResult(`  Amount: ${balance.amount} ${balance.symbol}`);
+  printResult(`  Amount: ${balance.formattedAmount} ${balance.symbol}`);
   if (balance.fiatValue && balance.fiatCurrency) {
     printResult(`  Value:  ${balance.fiatValue.toFixed(2)} ${balance.fiatCurrency}`);
   }
 }
-function displayBalancesTable(balances) {
+function displayBalancesTable(balances, _raw = false) {
   printResult(chalk2.cyan("\nPortfolio Balances:\n"));
   const tableData = Object.entries(balances).map(([chain, balance]) => ({
     Chain: chain,
-    Amount: balance.amount,
+    Amount: balance.formattedAmount,
     Symbol: balance.symbol,
     Value: balance.fiatValue && balance.fiatCurrency ? `${balance.fiatValue.toFixed(2)} ${balance.fiatCurrency}` : "N/A"
   }));
   printTable(tableData);
 }
-function displayPortfolio(portfolio, currency) {
+function displayPortfolio(portfolio, currency, _raw = false) {
   const currencyName = fiatCurrencyNameRecord[currency];
   printResult(chalk2.cyan("\n+----------------------------------------+"));
   printResult(chalk2.cyan(`|       Portfolio Total Value (${currencyName})       |`));
@@ -1475,7 +1475,7 @@ function displayPortfolio(portfolio, currency) {
   printResult(chalk2.bold("Chain Breakdown:\n"));
   const table = portfolio.chainBalances.map(({ chain, balance, value }) => ({
     Chain: chain,
-    Amount: balance.amount,
+    Amount: balance.formattedAmount,
     Symbol: balance.symbol,
     Value: value ? `${value.amount} ${value.currency.toUpperCase()}` : "N/A"
   }));
@@ -1571,7 +1571,7 @@ async function confirmTransaction() {
 function setupVaultEvents(vault) {
   vault.on("balanceUpdated", ({ chain, balance, tokenId }) => {
     const asset = tokenId ? `${balance.symbol} token` : balance.symbol;
-    info(chalk2.blue(`i Balance updated for ${chain} (${asset}): ${balance.amount}`));
+    info(chalk2.blue(`i Balance updated for ${chain} (${asset}): ${balance.formattedAmount}`));
   });
   vault.on("transactionBroadcast", ({ chain, txHash }) => {
     info(chalk2.green(`+ Transaction broadcast on ${chain}`));
@@ -1634,6 +1634,10 @@ function displaySwapPreview(quote, fromAmount, fromSymbol, toSymbol, options) {
       if (quote.feesFiat?.affiliate) {
         printResult(`               (~$${quote.feesFiat.affiliate.toFixed(2)})`);
       }
+      if (options.discountTier) {
+        const tierDisplay = options.discountTier.charAt(0).toUpperCase() + options.discountTier.slice(1);
+        printResult(chalk2.green(`               (${tierDisplay} tier discount applied)`));
+      }
     }
     printResult(`    Total:    ${totalFeeFormatted} ${options.feeSymbol}`);
     if (quote.feesFiat) {
@@ -1688,6 +1692,7 @@ async function confirmSwap() {
 async function executeBalance(ctx2, options = {}) {
   const vault = await ctx2.ensureActiveVault();
   const spinner = createSpinner("Loading balances...");
+  const raw = options.raw ?? false;
   if (options.chain) {
     const balance = await vault.balance(options.chain);
     spinner.succeed("Balance loaded");
@@ -1695,7 +1700,7 @@ async function executeBalance(ctx2, options = {}) {
       outputJson({ chain: options.chain, balance });
       return;
     }
-    displayBalance(options.chain, balance);
+    displayBalance(options.chain, balance, raw);
   } else {
     const balances = await vault.balances(void 0, options.includeTokens);
     spinner.succeed("Balances loaded");
@@ -1703,7 +1708,7 @@ async function executeBalance(ctx2, options = {}) {
       outputJson({ balances });
       return;
     }
-    displayBalancesTable(balances);
+    displayBalancesTable(balances, raw);
   }
 }
 async function executePortfolio(ctx2, options = {}) {
@@ -1738,13 +1743,27 @@ async function executePortfolio(ctx2, options = {}) {
     outputJson({ portfolio, currency });
     return;
   }
-  displayPortfolio(portfolio, currency);
+  displayPortfolio(portfolio, currency, options.raw ?? false);
 }
 
 // src/commands/chains.ts
+import { SUPPORTED_CHAINS } from "@vultisig/sdk";
 import chalk3 from "chalk";
 async function executeChains(ctx2, options = {}) {
   const vault = await ctx2.ensureActiveVault();
+  if (options.addAll) {
+    const currentCount = vault.chains.length;
+    const spinner = createSpinner(`Adding all ${SUPPORTED_CHAINS.length} supported chains...`);
+    await vault.setChains([...SUPPORTED_CHAINS]);
+    const addedCount = SUPPORTED_CHAINS.length - currentCount;
+    spinner.succeed(`Added ${addedCount} chains (${SUPPORTED_CHAINS.length} total)`);
+    if (isJsonOutput()) {
+      outputJson({ chains: [...vault.chains], added: addedCount, total: SUPPORTED_CHAINS.length });
+      return;
+    }
+    info(chalk3.gray("\nAll supported chains are now enabled."));
+    return;
+  }
   if (options.add) {
     await vault.addChain(options.add);
     success(`
@@ -1765,7 +1784,9 @@ async function executeChains(ctx2, options = {}) {
     chains.forEach((chain) => {
       printResult(`  - ${chain}`);
     });
-    info(chalk3.gray("\nUse --add <chain> to add a chain or --remove <chain> to remove one"));
+    info(chalk3.gray(`
+${chains.length} of ${SUPPORTED_CHAINS.length} chains enabled`));
+    info(chalk3.gray("Use --add <chain>, --add-all, or --remove <chain>"));
   }
 }
 async function executeAddresses(ctx2) {
@@ -1893,7 +1914,8 @@ async function executeSend(ctx2, params) {
   if (!Object.values(Chain).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
-  if (isNaN(parseFloat(params.amount)) || parseFloat(params.amount) <= 0) {
+  const isMax = params.amount === "max";
+  if (!isMax && (isNaN(parseFloat(params.amount)) || parseFloat(params.amount) <= 0)) {
     throw new Error("Invalid amount");
   }
   return sendTransaction(vault, params);
@@ -1909,7 +1931,25 @@ async function sendTransaction(vault, params) {
     ticker: balance.symbol,
     id: params.tokenId
   };
-  const amount = BigInt(Math.floor(parseFloat(params.amount) * Math.pow(10, balance.decimals)));
+  const isMax = params.amount === "max";
+  let amount;
+  let displayAmount;
+  if (isMax) {
+    const maxInfo = await vault.getMaxSendAmount({ coin, receiver: params.to, memo: params.memo });
+    amount = maxInfo.maxSendable;
+    if (amount === 0n) {
+      throw new Error("Insufficient balance to cover network fees");
+    }
+    displayAmount = formatBigintAmount(amount, balance.decimals);
+  } else {
+    const [whole, frac = ""] = params.amount.split(".");
+    if (frac.length > balance.decimals) {
+      throw new Error(`Amount has more than ${balance.decimals} decimal places`);
+    }
+    const paddedFrac = frac.padEnd(balance.decimals, "0");
+    amount = BigInt(whole || "0") * 10n ** BigInt(balance.decimals) + BigInt(paddedFrac || "0");
+    displayAmount = params.amount;
+  }
   const payload = await vault.prepareSendTx({
     coin,
     receiver: params.to,
@@ -1927,7 +1967,7 @@ async function sendTransaction(vault, params) {
     displayTransactionPreview(
       payload.coin.address,
       params.to,
-      params.amount,
+      displayAmount,
       payload.coin.ticker,
       params.chain,
       params.memo,
@@ -2012,12 +2052,175 @@ Or use this URL: ${qrPayload}
   }
 }
 
-// src/commands/sign.ts
+// src/commands/execute.ts
 var import_qrcode_terminal2 = __toESM(require_main(), 1);
-import { Chain as Chain2 } from "@vultisig/sdk";
+import { Vultisig as Vultisig3 } from "@vultisig/sdk";
+var COSMOS_CHAIN_CONFIG = {
+  THORChain: {
+    chainId: "thorchain-1",
+    prefix: "thor",
+    denom: "rune",
+    gasLimit: "500000"
+  },
+  MayaChain: {
+    chainId: "mayachain-mainnet-v1",
+    prefix: "maya",
+    denom: "cacao",
+    gasLimit: "500000"
+  }
+};
+function parseFunds(fundsStr) {
+  if (!fundsStr) return [];
+  return fundsStr.split(",").map((fund) => {
+    const [denom, amount] = fund.trim().split(":");
+    if (!denom || !amount) {
+      throw new Error(`Invalid funds format: "${fund}". Expected "denom:amount"`);
+    }
+    return { denom: denom.toLowerCase(), amount };
+  });
+}
+async function executeExecute(ctx2, params) {
+  const vault = await ctx2.ensureActiveVault();
+  const chainConfig = COSMOS_CHAIN_CONFIG[params.chain];
+  if (!chainConfig) {
+    throw new Error(`Chain ${params.chain} does not support CosmWasm execute. Supported chains: ${Object.keys(COSMOS_CHAIN_CONFIG).join(", ")}`);
+  }
+  let msg;
+  try {
+    msg = JSON.parse(params.msg);
+  } catch {
+    throw new Error(`Invalid JSON message: ${params.msg}`);
+  }
+  const funds = parseFunds(params.funds);
+  return executeContractTransaction(vault, params, chainConfig, msg, funds);
+}
+async function executeContractTransaction(vault, params, chainConfig, msg, funds) {
+  const prepareSpinner = createSpinner("Preparing contract execution...");
+  const address = await vault.address(params.chain);
+  prepareSpinner.succeed("Transaction prepared");
+  if (!isJsonOutput()) {
+    info("\n\u{1F4DD} Contract Execution Preview");
+    info("\u2501".repeat(50));
+    info(`Chain:      ${params.chain}`);
+    info(`From:       ${address}`);
+    info(`Contract:   ${params.contract}`);
+    info(`Message:    ${JSON.stringify(msg, null, 2).substring(0, 200)}${JSON.stringify(msg).length > 200 ? "..." : ""}`);
+    if (funds.length > 0) {
+      info(`Funds:      ${funds.map((f) => `${f.amount} ${f.denom}`).join(", ")}`);
+    }
+    if (params.memo) {
+      info(`Memo:       ${params.memo}`);
+    }
+    info("\u2501".repeat(50));
+  }
+  if (!params.yes && !isJsonOutput()) {
+    const confirmed = await confirmTransaction();
+    if (!confirmed) {
+      warn("Transaction cancelled");
+      throw new Error("Transaction cancelled by user");
+    }
+  }
+  await ensureVaultUnlocked(vault, params.password);
+  const isSecureVault = vault.type === "secure";
+  const signSpinner = createSpinner(isSecureVault ? "Preparing secure signing session..." : "Signing transaction...");
+  vault.on("signingProgress", ({ step }) => {
+    signSpinner.text = `${step.message} (${step.progress}%)`;
+  });
+  if (isSecureVault) {
+    vault.on("qrCodeReady", ({ qrPayload }) => {
+      if (isJsonOutput()) {
+        printResult(qrPayload);
+      } else if (isSilent()) {
+        printResult(`QR Payload: ${qrPayload}`);
+      } else {
+        signSpinner.stop();
+        info("\nScan this QR code with your Vultisig mobile app to sign:");
+        import_qrcode_terminal2.default.generate(qrPayload, { small: true });
+        info(`
+Or use this URL: ${qrPayload}
+`);
+        signSpinner.start("Waiting for devices to join signing session...");
+      }
+    });
+    vault.on("deviceJoined", ({ deviceId, totalJoined, required }) => {
+      if (!isSilent()) {
+        signSpinner.text = `Device joined: ${totalJoined}/${required} (${deviceId})`;
+      } else if (!isJsonOutput()) {
+        printResult(`Device joined: ${totalJoined}/${required}`);
+      }
+    });
+  }
+  try {
+    const coin = {
+      chain: params.chain,
+      address,
+      decimals: 8,
+      // THORChain uses 8 decimals
+      ticker: chainConfig.denom.toUpperCase()
+    };
+    const executeContractMsg = {
+      type: "wasm/MsgExecuteContract",
+      value: JSON.stringify({
+        sender: address,
+        contract: params.contract,
+        msg,
+        funds: funds.map((f) => ({ denom: f.denom, amount: f.amount }))
+      })
+    };
+    const fee = {
+      amount: [{ denom: chainConfig.denom, amount: "0" }],
+      gas: chainConfig.gasLimit
+    };
+    const keysignPayload = await vault.prepareSignAminoTx({
+      chain: params.chain,
+      coin,
+      msgs: [executeContractMsg],
+      fee,
+      memo: params.memo
+    });
+    const messageHashes = await vault.extractMessageHashes(keysignPayload);
+    const signature = await vault.sign(
+      {
+        transaction: keysignPayload,
+        chain: params.chain,
+        messageHashes
+      },
+      { signal: params.signal }
+    );
+    signSpinner.succeed("Transaction signed");
+    const broadcastSpinner = createSpinner("Broadcasting transaction...");
+    const txHash = await vault.broadcastTx({
+      chain: params.chain,
+      keysignPayload,
+      signature
+    });
+    broadcastSpinner.succeed(`Transaction broadcast: ${txHash}`);
+    const result = {
+      txHash,
+      chain: params.chain,
+      explorerUrl: Vultisig3.getTxExplorerUrl(params.chain, txHash)
+    };
+    if (isJsonOutput()) {
+      outputJson(result);
+    } else {
+      displayTransactionResult(params.chain, txHash);
+    }
+    return result;
+  } finally {
+    vault.removeAllListeners("signingProgress");
+    if (isSecureVault) {
+      vault.removeAllListeners("qrCodeReady");
+      vault.removeAllListeners("deviceJoined");
+    }
+  }
+}
+
+// src/commands/sign.ts
+var import_qrcode_terminal3 = __toESM(require_main(), 1);
+import { Chain as Chain3 } from "@vultisig/sdk";
 async function executeSignBytes(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain2).includes(params.chain)) {
+  if (!Object.values(Chain3).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   return signBytes(vault, params);
@@ -2039,7 +2242,7 @@ async function signBytes(vault, params) {
       } else {
         signSpinner.stop();
         info("\nScan this QR code with your Vultisig mobile app to sign:");
-        import_qrcode_terminal2.default.generate(qrPayload, { small: true });
+        import_qrcode_terminal3.default.generate(qrPayload, { small: true });
         info(`
 Or use this URL: ${qrPayload}
 `);
@@ -2093,10 +2296,10 @@ Or use this URL: ${qrPayload}
 }
 
 // src/commands/broadcast.ts
-import { Chain as Chain3, Vultisig as Vultisig3 } from "@vultisig/sdk";
+import { Chain as Chain4, Vultisig as Vultisig4 } from "@vultisig/sdk";
 async function executeBroadcast(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain3).includes(params.chain)) {
+  if (!Object.values(Chain4).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   const broadcastSpinner = createSpinner("Broadcasting transaction...");
@@ -2109,7 +2312,7 @@ async function executeBroadcast(ctx2, params) {
     const result = {
       txHash,
       chain: params.chain,
-      explorerUrl: Vultisig3.getTxExplorerUrl(params.chain, txHash)
+      explorerUrl: Vultisig4.getTxExplorerUrl(params.chain, txHash)
     };
     if (isJsonOutput()) {
       outputJson(result);
@@ -2125,7 +2328,7 @@ async function executeBroadcast(ctx2, params) {
 }
 
 // src/commands/vault-management.ts
-var import_qrcode_terminal3 = __toESM(require_main(), 1);
+var import_qrcode_terminal4 = __toESM(require_main(), 1);
 import chalk5 from "chalk";
 import { promises as fs } from "fs";
 import inquirer4 from "inquirer";
@@ -2246,7 +2449,7 @@ async function executeCreateSecure(ctx2, options) {
           } else {
             spinner.stop();
             info("\nScan this QR code with your Vultisig mobile app:");
-            import_qrcode_terminal3.default.generate(qrPayload, { small: true });
+            import_qrcode_terminal4.default.generate(qrPayload, { small: true });
             info(`
 Or use this URL: ${qrPayload}
 `);
@@ -2508,7 +2711,7 @@ async function executeInfo(ctx2) {
   displayVaultInfo(vault);
 }
 async function executeCreateFromSeedphraseFast(ctx2, options) {
-  const { mnemonic, name, password, email, discoverChains, chains, signal } = options;
+  const { mnemonic, name, password, email, discoverChains, chains, signal, usePhantomSolanaPath } = options;
   const validateSpinner = createSpinner("Validating seedphrase...");
   const validation = await ctx2.sdk.validateSeedphrase(mnemonic);
   if (!validation.valid) {
@@ -2519,19 +2722,26 @@ async function executeCreateFromSeedphraseFast(ctx2, options) {
     throw new Error(validation.error || "Invalid mnemonic phrase");
   }
   validateSpinner.succeed(`Valid ${validation.wordCount}-word seedphrase`);
+  let detectedUsePhantomSolanaPath = usePhantomSolanaPath;
   if (discoverChains) {
     const discoverSpinner = createSpinner("Discovering chains with balances...");
     try {
-      const discovered = await ctx2.sdk.discoverChainsFromSeedphrase(mnemonic, chains, (p) => {
+      const { results: discovered, usePhantomSolanaPath: detectedPhantomPath } = await ctx2.sdk.discoverChainsFromSeedphrase(mnemonic, chains, (p) => {
         discoverSpinner.text = `Discovering: ${p.chain || "scanning"} (${p.chainsProcessed}/${p.chainsTotal})`;
       });
       const chainsWithBalance = discovered.filter((c) => c.hasBalance);
       discoverSpinner.succeed(`Found ${chainsWithBalance.length} chains with balances`);
+      if (usePhantomSolanaPath === void 0) {
+        detectedUsePhantomSolanaPath = detectedPhantomPath;
+      }
       if (chainsWithBalance.length > 0 && !isSilent()) {
         info("\nChains with balances:");
         for (const result of chainsWithBalance) {
           info(`  ${result.chain}: ${result.balance} ${result.symbol}`);
         }
+        if (detectedUsePhantomSolanaPath) {
+          info("  (Using Phantom wallet derivation path for Solana)");
+        }
         info("");
       }
     } catch {
@@ -2547,6 +2757,7 @@ async function executeCreateFromSeedphraseFast(ctx2, options) {
       email,
       // Don't pass discoverChains - CLI handles discovery above
       chains,
+      usePhantomSolanaPath: detectedUsePhantomSolanaPath,
       onProgress: (step) => {
         importSpinner.text = `${step.message} (${step.progress}%)`;
       }
@@ -2625,7 +2836,17 @@ async function executeCreateFromSeedphraseFast(ctx2, options) {
   throw new Error("Verification loop exited unexpectedly");
 }
 async function executeCreateFromSeedphraseSecure(ctx2, options) {
-  const { mnemonic, name, password, threshold, shares: totalShares, discoverChains, chains, signal } = options;
+  const {
+    mnemonic,
+    name,
+    password,
+    threshold,
+    shares: totalShares,
+    discoverChains,
+    chains,
+    signal,
+    usePhantomSolanaPath
+  } = options;
   const validateSpinner = createSpinner("Validating seedphrase...");
   const validation = await ctx2.sdk.validateSeedphrase(mnemonic);
   if (!validation.valid) {
@@ -2636,19 +2857,26 @@ async function executeCreateFromSeedphraseSecure(ctx2, options) {
     throw new Error(validation.error || "Invalid mnemonic phrase");
   }
   validateSpinner.succeed(`Valid ${validation.wordCount}-word seedphrase`);
+  let detectedUsePhantomSolanaPath = usePhantomSolanaPath;
   if (discoverChains) {
     const discoverSpinner = createSpinner("Discovering chains with balances...");
     try {
-      const discovered = await ctx2.sdk.discoverChainsFromSeedphrase(mnemonic, chains, (p) => {
+      const { results: discovered, usePhantomSolanaPath: detectedPhantomPath } = await ctx2.sdk.discoverChainsFromSeedphrase(mnemonic, chains, (p) => {
         discoverSpinner.text = `Discovering: ${p.chain || "scanning"} (${p.chainsProcessed}/${p.chainsTotal})`;
       });
       const chainsWithBalance = discovered.filter((c) => c.hasBalance);
       discoverSpinner.succeed(`Found ${chainsWithBalance.length} chains with balances`);
+      if (usePhantomSolanaPath === void 0) {
+        detectedUsePhantomSolanaPath = detectedPhantomPath;
+      }
       if (chainsWithBalance.length > 0 && !isSilent()) {
         info("\nChains with balances:");
         for (const result of chainsWithBalance) {
           info(`  ${result.chain}: ${result.balance} ${result.symbol}`);
         }
+        if (detectedUsePhantomSolanaPath) {
+          info("  (Using Phantom wallet derivation path for Solana)");
+        }
         info("");
       }
     } catch {
@@ -2666,6 +2894,7 @@ async function executeCreateFromSeedphraseSecure(ctx2, options) {
         threshold,
         // Don't pass discoverChains - CLI handles discovery above
         chains,
+        usePhantomSolanaPath: detectedUsePhantomSolanaPath,
         onProgress: (step) => {
           importSpinner.text = `${step.message} (${step.progress}%)`;
         },
@@ -2677,7 +2906,7 @@ async function executeCreateFromSeedphraseSecure(ctx2, options) {
           } else {
             importSpinner.stop();
             info("\nScan this QR code with your Vultisig mobile app:");
-            import_qrcode_terminal3.default.generate(qrPayload, { small: true });
+            import_qrcode_terminal4.default.generate(qrPayload, { small: true });
             info(`
 Or use this URL: ${qrPayload}
 `);
@@ -2770,6 +2999,82 @@ async function executeJoinSecure(ctx2, options) {
     throw err;
   }
 }
+async function executeDelete(ctx2, options = {}) {
+  let vault;
+  if (options.vaultId) {
+    const vaults = await ctx2.sdk.listVaults();
+    vault = findVaultByIdOrName({ vaults, idOrName: options.vaultId });
+  } else {
+    vault = await ctx2.ensureActiveVault();
+  }
+  if (isJsonOutput()) {
+    const spinner2 = createSpinner("Deleting vault...");
+    await ctx2.sdk.deleteVault(vault);
+    spinner2.succeed("Vault deleted");
+    outputJson({
+      deleted: true,
+      vault: {
+        id: vault.id,
+        name: vault.name,
+        type: vault.type
+      }
+    });
+    return;
+  }
+  info("\n" + chalk5.bold("Vault to delete:"));
+  info(`  Name:   ${chalk5.cyan(vault.name)}`);
+  info(`  Type:   ${chalk5.yellow(vault.type)}`);
+  info(`  ID:     ${vault.id.slice(0, 16)}...`);
+  info(`  Chains: ${vault.chains.length}`);
+  info("");
+  if (!options.skipConfirmation) {
+    warn(chalk5.red.bold("WARNING: This action cannot be undone!"));
+    warn("Make sure you have a backup of your vault (.vult file) before proceeding.");
+    info("");
+    const { confirmed } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `Are you sure you want to delete vault "${vault.name}"?`,
+        default: false
+      }
+    ]);
+    if (!confirmed) {
+      info("Deletion cancelled.");
+      return;
+    }
+  }
+  const spinner = createSpinner("Deleting vault...");
+  await ctx2.sdk.deleteVault(vault);
+  spinner.succeed(`Vault deleted: ${vault.name}`);
+  success("\n+ Vault deleted successfully");
+  info(chalk5.gray('\nTip: Run "vultisig vaults" to see remaining vaults'));
+}
+function findVaultByIdOrName({ vaults, idOrName }) {
+  const byId = vaults.find((v) => v.id === idOrName);
+  if (byId) return byId;
+  const byName = vaults.filter((v) => v.name.toLowerCase() === idOrName.toLowerCase());
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    const matches = byName.map((v) => `  - ${v.name} (${v.id.slice(0, 8)}...)`).join("\n");
+    throw new Error(
+      `Multiple vaults match "${idOrName}":
+${matches}
+Please specify the full vault ID to be more specific.`
+    );
+  }
+  const byPartialId = vaults.filter((v) => v.id.startsWith(idOrName));
+  if (byPartialId.length === 1) return byPartialId[0];
+  if (byPartialId.length > 1) {
+    const matches = byPartialId.map((v) => `  - ${v.name} (${v.id.slice(0, 8)}...)`).join("\n");
+    throw new Error(
+      `Multiple vaults match prefix "${idOrName}":
+${matches}
+Please specify more characters of the vault ID.`
+    );
+  }
+  throw new Error(`Vault not found: "${idOrName}"`);
+}
 
 // src/commands/swap.ts
 async function executeSwapChains(ctx2) {
@@ -2786,66 +3091,95 @@ async function executeSwapChains(ctx2) {
 }
 async function executeSwapQuote(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
-  if (isNaN(options.amount) || options.amount <= 0) {
+  const isMax = options.amount === "max";
+  if (!isMax && (isNaN(options.amount) || options.amount <= 0)) {
     throw new Error("Invalid amount");
   }
   const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
   if (!isSupported) {
     throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
   }
+  let resolvedAmount;
+  if (isMax) {
+    const bal = await vault.balance(options.fromChain, options.fromToken);
+    resolvedAmount = parseFloat(bal.formattedAmount);
+    if (resolvedAmount <= 0) {
+      throw new Error("Zero balance \u2014 nothing to swap");
+    }
+  } else {
+    resolvedAmount = options.amount;
+  }
   const spinner = createSpinner("Getting swap quote...");
   const quote = await vault.getSwapQuote({
     fromCoin: { chain: options.fromChain, token: options.fromToken },
     toCoin: { chain: options.toChain, token: options.toToken },
-    amount: options.amount,
+    amount: resolvedAmount,
     fiatCurrency: "usd"
     // Request fiat conversion
   });
   spinner.succeed("Quote received");
+  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(resolvedAmount);
   if (isJsonOutput()) {
     outputJson({
       fromChain: options.fromChain,
       toChain: options.toChain,
-      amount: options.amount,
+      amount: resolvedAmount,
+      isMax,
       quote
     });
     return quote;
   }
   const feeBalance = await vault.balance(options.fromChain);
-  displaySwapPreview(quote, String(options.amount), quote.fromCoin.ticker, quote.toCoin.ticker, {
+  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
+    feeSymbol: feeBalance.symbol,
+    discountTier
   });
   info('\nTo execute this swap, use the "swap" command');
   return quote;
 }
 async function executeSwap(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
-  if (isNaN(options.amount) || options.amount <= 0) {
+  const isMax = options.amount === "max";
+  if (!isMax && (isNaN(options.amount) || options.amount <= 0)) {
     throw new Error("Invalid amount");
   }
   const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
   if (!isSupported) {
     throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
   }
+  let resolvedAmount;
+  if (isMax) {
+    const bal = await vault.balance(options.fromChain, options.fromToken);
+    resolvedAmount = parseFloat(bal.formattedAmount);
+    if (resolvedAmount <= 0) {
+      throw new Error("Zero balance \u2014 nothing to swap");
+    }
+  } else {
+    resolvedAmount = options.amount;
+  }
   const quoteSpinner = createSpinner("Getting swap quote...");
   const quote = await vault.getSwapQuote({
     fromCoin: { chain: options.fromChain, token: options.fromToken },
     toCoin: { chain: options.toChain, token: options.toToken },
-    amount: options.amount,
+    amount: resolvedAmount,
     fiatCurrency: "usd"
     // Request fiat conversion
   });
   quoteSpinner.succeed("Quote received");
+  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(resolvedAmount);
   const feeBalance = await vault.balance(options.fromChain);
+  const discountTier = await vault.getDiscountTier();
   if (!isJsonOutput()) {
-    displaySwapPreview(quote, String(options.amount), quote.fromCoin.ticker, quote.toCoin.ticker, {
+    displaySwapPreview(quote, fromAmountDisplay, quote.fromCoin.ticker, quote.toCoin.ticker, {
       fromDecimals: quote.fromCoin.decimals,
       toDecimals: quote.toCoin.decimals,
       feeDecimals: feeBalance.decimals,
-      feeSymbol: feeBalance.symbol
+      feeSymbol: feeBalance.symbol,
+      discountTier
     });
   }
   if (!options.yes && !isJsonOutput()) {
@@ -2859,7 +3193,7 @@ async function executeSwap(ctx2, options) {
   const { keysignPayload, approvalPayload } = await vault.prepareSwapTx({
     fromCoin: { chain: options.fromChain, token: options.fromToken },
     toCoin: { chain: options.toChain, token: options.toToken },
-    amount: options.amount,
+    amount: resolvedAmount,
     swapQuote: quote,
     autoApprove: false
   });
@@ -2934,7 +3268,7 @@ async function executeSwap(ctx2, options) {
 }
 
 // src/commands/settings.ts
-import { Chain as Chain4, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
+import { Chain as Chain5, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
 import chalk6 from "chalk";
 import inquirer5 from "inquirer";
 async function executeCurrency(ctx2, newCurrency) {
@@ -3002,7 +3336,7 @@ async function executeAddressBook(ctx2, options = {}) {
         type: "list",
         name: "chain",
         message: "Select chain:",
-        choices: Object.values(Chain4)
+        choices: Object.values(Chain5)
       });
     }
     if (!address) {
@@ -3078,8 +3412,292 @@ Address Book${options.chain ? ` (${options.chain})` : ""}:
   return allEntries;
 }
 
+// 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 } : {}
+    }
+  });
+  const spinner = createSpinner("Connecting to Rujira/THORChain...");
+  await client.connect();
+  spinner.succeed("Connected");
+  return client;
+}
+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;
+  }
+  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
+    }))
+  );
+}
+async function executeRujiraRoutes() {
+  const routes = listEasyRoutes();
+  const summary = getRoutesSummary();
+  if (isJsonOutput()) {
+    outputJson({ routes, summary });
+    return;
+  }
+  printResult(summary);
+  printResult("");
+  printTable(
+    routes.map((r) => ({
+      name: r.name,
+      from: r.from,
+      to: r.to,
+      liquidity: r.liquidity,
+      description: r.description
+    }))
+  );
+}
+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);
+  }
+}
+async function executeRujiraSwap(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  await ensureVaultUnlocked(vault, options.password);
+  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 (isJsonOutput()) {
+    const result2 = await client.swap.execute(quote, { slippageBps: options.slippageBps });
+    outputJson({ quote, result: result2 });
+    return;
+  }
+  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 Error("Confirmation required (use --yes)");
+  }
+  const execSpinner = createSpinner("Executing FIN swap...");
+  const result = await client.swap.execute(quote, { slippageBps: options.slippageBps });
+  execSpinner.succeed("Swap submitted");
+  printResult(`Tx Hash: ${result.txHash}`);
+}
+async function executeRujiraWithdraw(ctx2, options) {
+  const vault = await ctx2.ensureActiveVault();
+  await ensureVaultUnlocked(vault, options.password);
+  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 (isJsonOutput()) {
+    const result2 = await client.withdraw.execute(prepared);
+    outputJson({ prepared, result: result2 });
+    return;
+  }
+  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 Error("Confirmation required (use --yes)");
+  }
+  const execSpinner = createSpinner("Broadcasting withdrawal...");
+  const result = await client.withdraw.execute(prepared);
+  execSpinner.succeed("Withdrawal submitted");
+  printResult(`Tx Hash: ${result.txHash}`);
+}
+
+// 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;
+}
+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;
+}
+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;
+}
+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("");
+}
+
 // src/interactive/completer.ts
-import { Chain as Chain5 } from "@vultisig/sdk";
+import { Chain as Chain6 } from "@vultisig/sdk";
 import fs2 from "fs";
 import path2 from "path";
 var COMMANDS = [
@@ -3087,6 +3705,7 @@ var COMMANDS = [
   "vaults",
   "vault",
   "import",
+  "delete",
   "create-from-seedphrase",
   "create",
   "join",
@@ -3134,13 +3753,16 @@ function createCompleter(ctx2) {
         return completeVaultName(ctx2, partial);
       }
       if (command === "chains" && parts.length >= 2) {
+        const lastPart = parts[parts.length - 1] || "";
+        const lastPartLower = lastPart.toLowerCase();
+        if (lastPartLower.startsWith("-")) {
+          const flags = ["--add", "--add-all", "--remove"];
+          const matches = flags.filter((f) => f.startsWith(lastPartLower));
+          return [matches.length ? matches : flags, lastPart];
+        }
         const flag = parts[parts.length - 2]?.toLowerCase();
         if (flag === "--add" || flag === "--remove") {
-          const partial = parts[parts.length - 1] || "";
-          return completeChainName(partial);
-        }
-        if (parts[parts.length - 1]?.toLowerCase() === "--add" || parts[parts.length - 1]?.toLowerCase() === "--remove") {
-          return completeChainName("");
+          return completeChainName(lastPart);
         }
       }
       if (["balance", "bal", "tokens", "send", "swap", "swap-quote"].includes(command) && parts.length === 2) {
@@ -3218,7 +3840,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain5);
+  const allChains = Object.values(Chain6);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -3226,14 +3848,14 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain5);
+  const allChains = Object.values(Chain6);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;
 }
 
 // src/interactive/event-buffer.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 var EventBuffer = class {
   eventBuffer = [];
   isCommandRunning = false;
@@ -3273,17 +3895,17 @@ var EventBuffer = class {
   displayEvent(message, type) {
     switch (type) {
       case "success":
-        console.log(chalk7.green(message));
+        console.log(chalk8.green(message));
         break;
       case "warning":
-        console.log(chalk7.yellow(message));
+        console.log(chalk8.yellow(message));
         break;
       case "error":
-        console.error(chalk7.red(message));
+        console.error(chalk8.red(message));
         break;
       case "info":
       default:
-        console.log(chalk7.blue(message));
+        console.log(chalk8.blue(message));
         break;
     }
   }
@@ -3294,13 +3916,13 @@ var EventBuffer = class {
     if (this.eventBuffer.length === 0) {
       return;
     }
-    console.log(chalk7.gray("\n--- Background Events ---"));
+    console.log(chalk8.gray("\n--- Background Events ---"));
     this.eventBuffer.forEach((event) => {
       const timeStr = event.timestamp.toLocaleTimeString();
       const message = `[${timeStr}] ${event.message}`;
       this.displayEvent(message, event.type);
     });
-    console.log(chalk7.gray("--- End Events ---\n"));
+    console.log(chalk8.gray("--- End Events ---\n"));
   }
   /**
    * Setup all vault event listeners
@@ -3402,12 +4024,12 @@ var EventBuffer = class {
 
 // src/interactive/session.ts
 import { fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import ora3 from "ora";
 import * as readline from "readline";
 
 // src/interactive/shell-commands.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import Table from "cli-table3";
 import inquirer6 from "inquirer";
 import ora2 from "ora";
@@ -3424,25 +4046,25 @@ function formatTimeRemaining(ms) {
 async function executeLock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk8.red("No active vault."));
-    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk9.red("No active vault."));
+    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   ctx2.lockVault(vault.id);
-  console.log(chalk8.green("\n+ Vault locked"));
-  console.log(chalk8.gray("Password cache cleared. You will need to enter the password again."));
+  console.log(chalk9.green("\n+ Vault locked"));
+  console.log(chalk9.gray("Password cache cleared. You will need to enter the password again."));
 }
 async function executeUnlock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk8.red("No active vault."));
-    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk9.red("No active vault."));
+    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   if (ctx2.isVaultUnlocked(vault.id)) {
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
-    console.log(chalk8.yellow("\nVault is already unlocked."));
-    console.log(chalk8.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
+    console.log(chalk9.yellow("\nVault is already unlocked."));
+    console.log(chalk9.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
     return;
   }
   const { password } = await inquirer6.prompt([
@@ -3459,19 +4081,19 @@ async function executeUnlock(ctx2) {
     ctx2.cachePassword(vault.id, password);
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
     spinner.succeed("Vault unlocked");
-    console.log(chalk8.green(`
+    console.log(chalk9.green(`
 + Vault unlocked for ${formatTimeRemaining(timeRemaining)}`));
   } catch (err) {
     spinner.fail("Failed to unlock vault");
-    console.error(chalk8.red(`
+    console.error(chalk9.red(`
 x ${err.message}`));
   }
 }
 async function executeStatus(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk8.red("No active vault."));
-    console.log(chalk8.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk9.red("No active vault."));
+    console.log(chalk9.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   const isUnlocked = ctx2.isVaultUnlocked(vault.id);
@@ -3502,30 +4124,30 @@ async function executeStatus(ctx2) {
   displayStatus(status);
 }
 function displayStatus(status) {
-  console.log(chalk8.cyan("\n+----------------------------------------+"));
-  console.log(chalk8.cyan("|            Vault Status                |"));
-  console.log(chalk8.cyan("+----------------------------------------+\n"));
-  console.log(chalk8.bold("Vault:"));
-  console.log(`  Name:     ${chalk8.green(status.name)}`);
+  console.log(chalk9.cyan("\n+----------------------------------------+"));
+  console.log(chalk9.cyan("|            Vault Status                |"));
+  console.log(chalk9.cyan("+----------------------------------------+\n"));
+  console.log(chalk9.bold("Vault:"));
+  console.log(`  Name:     ${chalk9.green(status.name)}`);
   console.log(`  ID:       ${status.id}`);
-  console.log(`  Type:     ${chalk8.yellow(status.type)}`);
-  console.log(chalk8.bold("\nSecurity:"));
+  console.log(`  Type:     ${chalk9.yellow(status.type)}`);
+  console.log(chalk9.bold("\nSecurity:"));
   if (status.isUnlocked) {
-    console.log(`  Status:   ${chalk8.green("Unlocked")} ${chalk8.green("\u{1F513}")}`);
+    console.log(`  Status:   ${chalk9.green("Unlocked")} ${chalk9.green("\u{1F513}")}`);
     console.log(`  Expires:  ${status.timeRemainingFormatted}`);
   } else {
-    console.log(`  Status:   ${chalk8.yellow("Locked")} ${chalk8.yellow("\u{1F512}")}`);
+    console.log(`  Status:   ${chalk9.yellow("Locked")} ${chalk9.yellow("\u{1F512}")}`);
   }
-  console.log(`  Encrypted: ${status.isEncrypted ? chalk8.green("Yes") : chalk8.gray("No")}`);
-  console.log(`  Backed Up: ${status.isBackedUp ? chalk8.green("Yes") : chalk8.yellow("No")}`);
-  console.log(chalk8.bold("\nMPC Configuration:"));
+  console.log(`  Encrypted: ${status.isEncrypted ? chalk9.green("Yes") : chalk9.gray("No")}`);
+  console.log(`  Backed Up: ${status.isBackedUp ? chalk9.green("Yes") : chalk9.yellow("No")}`);
+  console.log(chalk9.bold("\nMPC Configuration:"));
   console.log(`  Library:   ${status.libType}`);
-  console.log(`  Threshold: ${chalk8.cyan(status.threshold)} of ${chalk8.cyan(status.totalSigners)}`);
-  console.log(chalk8.bold("\nSigning Modes:"));
+  console.log(`  Threshold: ${chalk9.cyan(status.threshold)} of ${chalk9.cyan(status.totalSigners)}`);
+  console.log(chalk9.bold("\nSigning Modes:"));
   status.availableSigningModes.forEach((mode) => {
     console.log(`  - ${mode}`);
   });
-  console.log(chalk8.bold("\nDetails:"));
+  console.log(chalk9.bold("\nDetails:"));
   console.log(`  Chains:   ${status.chains}`);
   console.log(`  Currency: ${status.currency.toUpperCase()}`);
   console.log(`  Created:  ${new Date(status.createdAt).toLocaleString()}`);
@@ -3534,7 +4156,7 @@ function displayStatus(status) {
 }
 function showHelp() {
   const table = new Table({
-    head: [chalk8.bold("Available Commands")],
+    head: [chalk9.bold("Available Commands")],
     colWidths: [50],
     chars: {
       mid: "",
@@ -3548,38 +4170,39 @@ function showHelp() {
     }
   });
   table.push(
-    [chalk8.bold("Vault Management:")],
+    [chalk9.bold("Vault Management:")],
     ["  vaults              - List all vaults"],
     ["  vault <name>        - Switch to vault"],
     ["  import <file>       - Import vault from file"],
+    ["  delete [name]       - Delete vault"],
     ["  create              - Create new vault"],
     ["  info                - Show vault details"],
     ["  export [path]       - Export vault to file"],
     [""],
-    [chalk8.bold("Wallet Operations:")],
+    [chalk9.bold("Wallet Operations:")],
     ["  balance [chain]     - Show balances"],
     ["  send <chain> <to> <amount> - Send transaction"],
     ["  portfolio [-c usd]  - Show portfolio value"],
     ["  addresses           - Show all addresses"],
-    ["  chains [--add/--remove] - Manage chains"],
+    ["  chains [--add/--remove/--add-all] - Manage chains"],
     ["  tokens <chain>      - Manage tokens"],
     [""],
-    [chalk8.bold("Swap Operations:")],
+    [chalk9.bold("Swap Operations:")],
     ["  swap-chains         - List swap-enabled chains"],
     ["  swap-quote <from> <to> <amount> - Get quote"],
     ["  swap <from> <to> <amount> - Execute swap"],
     [""],
-    [chalk8.bold("Session Commands (shell only):")],
+    [chalk9.bold("Session Commands (shell only):")],
     ["  lock                - Lock vault"],
     ["  unlock              - Unlock vault"],
     ["  status              - Show vault status"],
     [""],
-    [chalk8.bold("Settings:")],
+    [chalk9.bold("Settings:")],
     ["  currency [code]     - View/set currency"],
     ["  server              - Check server status"],
     ["  address-book        - Manage saved addresses"],
     [""],
-    [chalk8.bold("Help & Navigation:")],
+    [chalk9.bold("Help & Navigation:")],
     ["  help, ?             - Show this help"],
     ["  .clear              - Clear screen"],
     ["  .exit               - Exit shell"]
@@ -3717,12 +4340,12 @@ var ShellSession = class {
    */
   async start() {
     console.clear();
-    console.log(chalk9.cyan.bold("\n=============================================="));
-    console.log(chalk9.cyan.bold("         Vultisig Interactive Shell"));
-    console.log(chalk9.cyan.bold("==============================================\n"));
+    console.log(chalk10.cyan.bold("\n=============================================="));
+    console.log(chalk10.cyan.bold("         Vultisig Interactive Shell"));
+    console.log(chalk10.cyan.bold("==============================================\n"));
     await this.loadAllVaults();
     this.displayVaultList();
-    console.log(chalk9.gray('Type "help" for available commands, "exit" to quit\n'));
+    console.log(chalk10.gray('Type "help" for available commands, "exit" to quit\n'));
     this.promptLoop().catch(() => {
     });
   }
@@ -3756,12 +4379,12 @@ var ShellSession = class {
         const now = Date.now();
         if (now - this.lastSigintTime < this.DOUBLE_CTRL_C_TIMEOUT) {
           rl.close();
-          console.log(chalk9.yellow("\nGoodbye!"));
+          console.log(chalk10.yellow("\nGoodbye!"));
           this.ctx.dispose();
           process.exit(0);
         }
         this.lastSigintTime = now;
-        console.log(chalk9.yellow("\n(Press Ctrl+C again to exit)"));
+        console.log(chalk10.yellow("\n(Press Ctrl+C again to exit)"));
         rl.close();
         resolve("");
       });
@@ -3856,7 +4479,7 @@ var ShellSession = class {
       stopAllSpinners();
       process.stdout.write("\x1B[?25h");
       process.stdout.write("\r\x1B[K");
-      console.log(chalk9.yellow("\nCancelling operation..."));
+      console.log(chalk10.yellow("\nCancelling operation..."));
     };
     const cleanup = () => {
       process.removeListener("SIGINT", onSigint);
@@ -3893,10 +4516,10 @@ var ShellSession = class {
         stopAllSpinners();
         process.stdout.write("\x1B[?25h");
         process.stdout.write("\r\x1B[K");
-        console.log(chalk9.yellow("Operation cancelled"));
+        console.log(chalk10.yellow("Operation cancelled"));
         return;
       }
-      console.error(chalk9.red(`
+      console.error(chalk10.red(`
 Error: ${error2.message}`));
     }
   }
@@ -3929,11 +4552,14 @@ Error: ${error2.message}`));
         break;
       case "rename":
         if (args.length === 0) {
-          console.log(chalk9.yellow("Usage: rename <newName>"));
+          console.log(chalk10.yellow("Usage: rename <newName>"));
           return;
         }
         await executeRename(this.ctx, args.join(" "));
         break;
+      case "delete":
+        await this.deleteVault(args);
+        break;
       // Balance commands
       case "balance":
       case "bal":
@@ -3999,41 +4625,41 @@ Error: ${error2.message}`));
       // Exit
       case "exit":
       case "quit":
-        console.log(chalk9.yellow("\nGoodbye!"));
+        console.log(chalk10.yellow("\nGoodbye!"));
         this.ctx.dispose();
         process.exit(0);
         break;
       // eslint requires break even after process.exit
       default:
-        console.log(chalk9.yellow(`Unknown command: ${command}`));
-        console.log(chalk9.gray('Type "help" for available commands'));
+        console.log(chalk10.yellow(`Unknown command: ${command}`));
+        console.log(chalk10.gray('Type "help" for available commands'));
         break;
     }
   }
   // ===== Command Helpers =====
   async switchVault(args) {
     if (args.length === 0) {
-      console.log(chalk9.yellow("Usage: vault <name>"));
-      console.log(chalk9.gray('Run "vaults" to see available vaults'));
+      console.log(chalk10.yellow("Usage: vault <name>"));
+      console.log(chalk10.gray('Run "vaults" to see available vaults'));
       return;
     }
     const vaultName = args.join(" ");
     const vault = this.ctx.findVaultByName(vaultName);
     if (!vault) {
-      console.log(chalk9.red(`Vault not found: ${vaultName}`));
-      console.log(chalk9.gray('Run "vaults" to see available vaults'));
+      console.log(chalk10.red(`Vault not found: ${vaultName}`));
+      console.log(chalk10.gray('Run "vaults" to see available vaults'));
       return;
     }
     await this.ctx.setActiveVault(vault);
-    console.log(chalk9.green(`
+    console.log(chalk10.green(`
 + Switched to: ${vault.name}`));
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk9.green("Unlocked") : chalk9.yellow("Locked");
+    const status = isUnlocked ? chalk10.green("Unlocked") : chalk10.yellow("Locked");
     console.log(`Status: ${status}`);
   }
   async importVault(args) {
     if (args.length === 0) {
-      console.log(chalk9.yellow("Usage: import <file>"));
+      console.log(chalk10.yellow("Usage: import <file>"));
       return;
     }
     const filePath = args.join(" ");
@@ -4041,48 +4667,52 @@ Error: ${error2.message}`));
     this.ctx.addVault(vault);
     this.eventBuffer.setupVaultListeners(vault);
   }
+  async deleteVault(args) {
+    const vaultIdOrName = args.join(" ") || void 0;
+    await executeDelete(this.ctx, { vaultId: vaultIdOrName });
+  }
   async createVault(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk9.yellow("Usage: create <fast|secure>"));
-      console.log(chalk9.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
-      console.log(chalk9.gray("  create secure - Create a secure vault (multi-device MPC)"));
+      console.log(chalk10.yellow("Usage: create <fast|secure>"));
+      console.log(chalk10.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
+      console.log(chalk10.gray("  create secure - Create a secure vault (multi-device MPC)"));
       return;
     }
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk9.red("Name is required"));
+        console.log(chalk10.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk9.red("Password is required"));
+        console.log(chalk10.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk9.red("Valid email is required"));
+        console.log(chalk10.red("Valid email is required"));
         return;
       }
       vault = await this.withCancellation((signal) => executeCreateFast(this.ctx, { name, password, email, signal }));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk9.red("Name is required"));
+        console.log(chalk10.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk9.red("Must have at least 2 shares"));
+        console.log(chalk10.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk9.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk10.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, press Enter to skip)");
@@ -4104,37 +4734,37 @@ Error: ${error2.message}`));
   async importSeedphrase(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk9.cyan("Usage: create-from-seedphrase <fast|secure>"));
-      console.log(chalk9.gray("  fast   - Import with VultiServer (2-of-2)"));
-      console.log(chalk9.gray("  secure - Import with device coordination (N-of-M)"));
+      console.log(chalk10.cyan("Usage: create-from-seedphrase <fast|secure>"));
+      console.log(chalk10.gray("  fast   - Import with VultiServer (2-of-2)"));
+      console.log(chalk10.gray("  secure - Import with device coordination (N-of-M)"));
       return;
     }
-    console.log(chalk9.cyan("\nEnter your recovery phrase (words separated by spaces):"));
+    console.log(chalk10.cyan("\nEnter your recovery phrase (words separated by spaces):"));
     const mnemonic = await this.promptPassword("Seedphrase");
     const validation = await this.ctx.sdk.validateSeedphrase(mnemonic);
     if (!validation.valid) {
-      console.log(chalk9.red(`Invalid seedphrase: ${validation.error}`));
+      console.log(chalk10.red(`Invalid seedphrase: ${validation.error}`));
       if (validation.invalidWords?.length) {
-        console.log(chalk9.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
+        console.log(chalk10.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
       }
       return;
     }
-    console.log(chalk9.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
+    console.log(chalk10.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk9.red("Name is required"));
+        console.log(chalk10.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk9.red("Password is required"));
+        console.log(chalk10.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk9.red("Valid email is required"));
+        console.log(chalk10.red("Valid email is required"));
         return;
       }
       const discoverStr = await this.prompt("Discover chains with balances? (y/n)", "y");
@@ -4152,19 +4782,19 @@ Error: ${error2.message}`));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk9.red("Name is required"));
+        console.log(chalk10.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk9.red("Must have at least 2 shares"));
+        console.log(chalk10.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk9.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk10.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, Enter to skip)");
@@ -4188,12 +4818,14 @@ Error: ${error2.message}`));
     }
   }
   async runBalance(args) {
-    const chainStr = args[0];
+    const chainStr = args.find((arg) => !arg.startsWith("-"));
     const includeTokens = args.includes("-t") || args.includes("--tokens");
+    const raw = args.includes("--raw");
     await this.withCancellation(
       () => executeBalance(this.ctx, {
         chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
-        includeTokens
+        includeTokens,
+        raw
       })
     );
   }
@@ -4206,15 +4838,16 @@ Error: ${error2.message}`));
       }
     }
     if (!fiatCurrencies3.includes(currency)) {
-      console.log(chalk9.red(`Invalid currency: ${currency}`));
-      console.log(chalk9.yellow(`Supported currencies: ${fiatCurrencies3.join(", ")}`));
+      console.log(chalk10.red(`Invalid currency: ${currency}`));
+      console.log(chalk10.yellow(`Supported currencies: ${fiatCurrencies3.join(", ")}`));
       return;
     }
-    await this.withCancellation(() => executePortfolio(this.ctx, { currency }));
+    const raw = args.includes("--raw");
+    await this.withCancellation(() => executePortfolio(this.ctx, { currency, raw }));
   }
   async runSend(args) {
     if (args.length < 3) {
-      console.log(chalk9.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
+      console.log(chalk10.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
       return;
     }
     const [chainStr, to, amount, ...rest] = args;
@@ -4234,7 +4867,7 @@ Error: ${error2.message}`));
       await this.withAbortHandler((signal) => executeSend(this.ctx, { chain, to, amount, tokenId, memo, signal }));
     } catch (err) {
       if (err.message === "Transaction cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk9.yellow("\nTransaction cancelled"));
+        console.log(chalk10.yellow("\nTransaction cancelled"));
         return;
       }
       throw err;
@@ -4243,12 +4876,15 @@ Error: ${error2.message}`));
   async runChains(args) {
     let addChain;
     let removeChain;
+    let addAll = false;
     for (let i = 0; i < args.length; i++) {
-      if (args[i] === "--add" && i + 1 < args.length) {
+      if (args[i] === "--add-all") {
+        addAll = true;
+      } else if (args[i] === "--add" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk9.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk9.gray("Use tab completion to see available chains"));
+          console.log(chalk10.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk10.gray("Use tab completion to see available chains"));
           return;
         }
         addChain = chain;
@@ -4256,19 +4892,19 @@ Error: ${error2.message}`));
       } else if (args[i] === "--remove" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk9.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk9.gray("Use tab completion to see available chains"));
+          console.log(chalk10.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk10.gray("Use tab completion to see available chains"));
           return;
         }
         removeChain = chain;
         i++;
       }
     }
-    await executeChains(this.ctx, { add: addChain, remove: removeChain });
+    await executeChains(this.ctx, { add: addChain, remove: removeChain, addAll });
   }
   async runTokens(args) {
     if (args.length === 0) {
-      console.log(chalk9.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
+      console.log(chalk10.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
       return;
     }
     const chainStr = args[0];
@@ -4289,7 +4925,7 @@ Error: ${error2.message}`));
   async runSwapQuote(args) {
     if (args.length < 3) {
       console.log(
-        chalk9.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
+        chalk10.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
       );
       return;
     }
@@ -4313,7 +4949,7 @@ Error: ${error2.message}`));
   async runSwap(args) {
     if (args.length < 3) {
       console.log(
-        chalk9.yellow(
+        chalk10.yellow(
           "Usage: swap <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>] [--slippage <pct>]"
         )
       );
@@ -4344,7 +4980,7 @@ Error: ${error2.message}`));
       );
     } catch (err) {
       if (err.message === "Swap cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk9.yellow("\nSwap cancelled"));
+        console.log(chalk10.yellow("\nSwap cancelled"));
         return;
       }
       throw err;
@@ -4406,24 +5042,24 @@ Error: ${error2.message}`));
   }
   getPrompt() {
     const vault = this.ctx.getActiveVault();
-    if (!vault) return chalk9.cyan("wallet> ");
+    if (!vault) return chalk10.cyan("wallet> ");
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk9.green("\u{1F513}") : chalk9.yellow("\u{1F512}");
-    return chalk9.cyan(`wallet[${vault.name}]${status}> `);
+    const status = isUnlocked ? chalk10.green("\u{1F513}") : chalk10.yellow("\u{1F512}");
+    return chalk10.cyan(`wallet[${vault.name}]${status}> `);
   }
   displayVaultList() {
     const vaults = Array.from(this.ctx.getVaults().values());
     const activeVault = this.ctx.getActiveVault();
     if (vaults.length === 0) {
-      console.log(chalk9.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
+      console.log(chalk10.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
       return;
     }
-    console.log(chalk9.cyan("Loaded Vaults:\n"));
+    console.log(chalk10.cyan("Loaded Vaults:\n"));
     vaults.forEach((vault) => {
       const isActive = vault.id === activeVault?.id;
       const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-      const activeMarker = isActive ? chalk9.green(" (active)") : "";
-      const lockIcon = isUnlocked ? chalk9.green("\u{1F513}") : chalk9.yellow("\u{1F512}");
+      const activeMarker = isActive ? chalk10.green(" (active)") : "";
+      const lockIcon = isUnlocked ? chalk10.green("\u{1F513}") : chalk10.yellow("\u{1F512}");
       console.log(`  ${lockIcon} ${vault.name}${activeMarker} - ${vault.type}`);
     });
     console.log();
@@ -4431,10 +5067,10 @@ Error: ${error2.message}`));
 };
 
 // src/lib/errors.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 
 // src/lib/version.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -4442,7 +5078,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "0.3.0";
+    cachedVersion = "0.5.0";
     return cachedVersion;
   }
   try {
@@ -4539,7 +5175,7 @@ function formatVersionShort() {
 }
 function formatVersionDetailed() {
   const lines = [];
-  lines.push(chalk11.bold(`Vultisig CLI v${getVersion()}`));
+  lines.push(chalk12.bold(`Vultisig CLI v${getVersion()}`));
   lines.push("");
   lines.push(`  Node.js:   ${process.version}`);
   lines.push(`  Platform:  ${process.platform}-${process.arch}`);
@@ -4916,7 +5552,7 @@ async function init(vaultOverride, unlockPassword) {
     if (unlockPassword && vaultSelector) {
       cachePassword(vaultSelector, unlockPassword);
     }
-    const sdk = new Vultisig4({
+    const sdk = new Vultisig5({
       onPasswordRequired: createPasswordCallback()
     });
     await sdk.initialize();
@@ -5001,7 +5637,7 @@ async function promptQrPayload() {
   ]);
   return answer.qrPayload.trim();
 }
-createFromSeedphraseCmd.command("fast").description("Create FastVault from seedphrase (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").option("--mnemonic <words>", "Seedphrase (12 or 24 words, space-separated)").option("--discover-chains", "Scan chains for existing balances").option("--chains <chains>", "Specific chains to enable (comma-separated)").action(
+createFromSeedphraseCmd.command("fast").description("Create FastVault from seedphrase (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").option("--mnemonic <words>", "Seedphrase (12 or 24 words, space-separated)").option("--discover-chains", "Scan chains for existing balances").option("--chains <chains>", "Specific chains to enable (comma-separated)").option("--use-phantom-solana-path", "Use Phantom wallet derivation path for Solana").action(
   withExit(
     async (options) => {
       const context = await init(program.opts().vault);
@@ -5028,12 +5664,13 @@ createFromSeedphraseCmd.command("fast").description("Create FastVault from seedp
         password: options.password,
         email: options.email,
         discoverChains: options.discoverChains,
-        chains
+        chains,
+        usePhantomSolanaPath: options.usePhantomSolanaPath
       });
     }
   )
 );
-createFromSeedphraseCmd.command("secure").description("Create SecureVault from seedphrase (multi-device MPC)").requiredOption("--name <name>", "Vault name").option("--password <password>", "Vault password (optional)").option("--threshold <m>", "Signing threshold", "2").option("--shares <n>", "Total shares", "3").option("--mnemonic <words>", "Seedphrase (12 or 24 words)").option("--discover-chains", "Scan chains for existing balances").option("--chains <chains>", "Specific chains to enable (comma-separated)").action(
+createFromSeedphraseCmd.command("secure").description("Create SecureVault from seedphrase (multi-device MPC)").requiredOption("--name <name>", "Vault name").option("--password <password>", "Vault password (optional)").option("--threshold <m>", "Signing threshold", "2").option("--shares <n>", "Total shares", "3").option("--mnemonic <words>", "Seedphrase (12 or 24 words)").option("--discover-chains", "Scan chains for existing balances").option("--chains <chains>", "Specific chains to enable (comma-separated)").option("--use-phantom-solana-path", "Use Phantom wallet derivation path for Solana").action(
   withExit(
     async (options) => {
       const context = await init(program.opts().vault);
@@ -5061,7 +5698,8 @@ createFromSeedphraseCmd.command("secure").description("Create SecureVault from s
         threshold: parseInt(options.threshold, 10),
         shares: parseInt(options.shares, 10),
         discoverChains: options.discoverChains,
-        chains
+        chains,
+        usePhantomSolanaPath: options.usePhantomSolanaPath
       });
     }
   )
@@ -5106,24 +5744,27 @@ program.command("verify <vaultId>").description("Verify vault with email verific
     }
   )
 );
-program.command("balance [chain]").description("Show balance for a chain or all chains").option("-t, --tokens", "Include token balances").action(
+program.command("balance [chain]").description("Show balance for a chain or all chains").option("-t, --tokens", "Include token balances").option("--raw", "Show raw values (wei/satoshis) for programmatic use").action(
   withExit(async (chainStr, options) => {
     const context = await init(program.opts().vault);
     await executeBalance(context, {
       chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
-      includeTokens: options.tokens
+      includeTokens: options.tokens,
+      raw: options.raw
     });
   })
 );
-program.command("send <chain> <to> <amount>").description("Send tokens to an address").option("--token <tokenId>", "Token to send (default: native)").option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+program.command("send <chain> <to> [amount]").description("Send tokens to an address").option("--max", "Send maximum amount (balance minus fees)").option("--token <tokenId>", "Token to send (default: native)").option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
   withExit(
     async (chainStr, to, amount, options) => {
+      if (!amount && !options.max) throw new Error("Provide an amount or use --max");
+      if (amount && options.max) throw new Error("Cannot specify both amount and --max");
       const context = await init(program.opts().vault);
       try {
         await executeSend(context, {
           chain: findChainByName(chainStr) || chainStr,
           to,
-          amount,
+          amount: amount ?? "max",
           tokenId: options.token,
           memo: options.memo,
           yes: options.yes,
@@ -5139,6 +5780,30 @@ program.command("send <chain> <to> <amount>").description("Send tokens to an add
     }
   )
 );
+program.command("execute <chain> <contract> <msg>").description("Execute a CosmWasm smart contract (THORChain, MayaChain)").option("--funds <funds>", 'Funds to send with execution (format: "denom:amount" or "denom:amount,denom2:amount2")').option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+  withExit(
+    async (chainStr, contract, msg, options) => {
+      const context = await init(program.opts().vault, options.password);
+      try {
+        await executeExecute(context, {
+          chain: findChainByName(chainStr) || chainStr,
+          contract,
+          msg,
+          funds: options.funds,
+          memo: options.memo,
+          yes: options.yes,
+          password: options.password
+        });
+      } catch (err) {
+        if (err.message === "Transaction cancelled by user") {
+          warn("\nx Transaction cancelled");
+          return;
+        }
+        throw err;
+      }
+    }
+  )
+);
 program.command("sign").description("Sign pre-hashed bytes (for externally constructed transactions)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--bytes <base64>", "Base64-encoded pre-hashed data to sign").option("--password <password>", "Vault password for signing").action(
   withExit(async (options) => {
     const context = await init(program.opts().vault, options.password);
@@ -5158,10 +5823,13 @@ program.command("broadcast").description("Broadcast a pre-signed raw transaction
     });
   })
 );
-program.command("portfolio").description("Show total portfolio value").option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").action(
+program.command("portfolio").description("Show total portfolio value").option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").option("--raw", "Show raw values (wei/satoshis) for programmatic use").action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
-    await executePortfolio(context, { currency: options.currency.toLowerCase() });
+    await executePortfolio(context, {
+      currency: options.currency.toLowerCase(),
+      raw: options.raw
+    });
   })
 );
 program.command("currency [newCurrency]").description("View or set the vault currency preference").action(
@@ -5176,6 +5844,12 @@ program.command("server").description("Check server connectivity and status").ac
     await executeServer(context);
   })
 );
+program.command("discount").description("Show your VULT discount tier for swap fees").option("--refresh", "Force refresh tier from blockchain").action(
+  withExit(async (options) => {
+    const context = await init(program.opts().vault);
+    await executeDiscount(context, { refresh: options.refresh });
+  })
+);
 program.command("export [path]").description("Export vault to file").option("--password <password>", "Password to unlock the vault (for encrypted vaults)").option("--exportPassword <password>", "Password to encrypt the exported file (defaults to --password)").action(
   withExit(async (path3, options) => {
     const context = await init(program.opts().vault, options.password);
@@ -5204,11 +5878,12 @@ program.command("address-book").description("Manage address book entries").optio
     });
   })
 );
-program.command("chains").description("List and manage chains").option("--add <chain>", "Add a chain").option("--remove <chain>", "Remove a chain").action(
+program.command("chains").description("List and manage chains").option("--add <chain>", "Add a chain").option("--add-all", "Add all supported chains").option("--remove <chain>", "Remove a chain").action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeChains(context, {
       add: options.add ? findChainByName(options.add) || options.add : void 0,
+      addAll: options.addAll,
       remove: options.remove ? findChainByName(options.remove) || options.remove : void 0
     });
   })
@@ -5237,6 +5912,15 @@ program.command("info").description("Show detailed vault information").action(
     await executeInfo(context);
   })
 );
+program.command("delete [vault]").description("Delete a vault from local storage").option("-y, --yes", "Skip confirmation prompt").action(
+  withExit(async (vaultIdOrName, options) => {
+    const context = await init(program.opts().vault);
+    await executeDelete(context, {
+      vaultId: vaultIdOrName,
+      skipConfirmation: options.yes
+    });
+  })
+);
 program.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("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (for --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
   withExit(
     async (chainStr, options) => {
@@ -5258,29 +5942,33 @@ program.command("swap-chains").description("List chains that support swaps").act
     await executeSwapChains(context);
   })
 );
-program.command("swap-quote <fromChain> <toChain> <amount>").description("Get a swap quote without executing").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").action(
+program.command("swap-quote <fromChain> <toChain> [amount]").description("Get a swap quote without executing").option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").action(
   withExit(
     async (fromChainStr, toChainStr, amountStr, options) => {
+      if (!amountStr && !options.max) throw new Error("Provide an amount or use --max");
+      if (amountStr && options.max) throw new Error("Cannot specify both amount and --max");
       const context = await init(program.opts().vault);
       await executeSwapQuote(context, {
         fromChain: findChainByName(fromChainStr) || fromChainStr,
         toChain: findChainByName(toChainStr) || toChainStr,
-        amount: parseFloat(amountStr),
+        amount: options.max ? "max" : parseFloat(amountStr),
         fromToken: options.fromToken,
         toToken: options.toToken
       });
     }
   )
 );
-program.command("swap <fromChain> <toChain> <amount>").description("Swap tokens between chains").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").option("--slippage <percent>", "Slippage tolerance in percent", "1").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+program.command("swap <fromChain> <toChain> [amount]").description("Swap tokens between chains").option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").option("--slippage <percent>", "Slippage tolerance in percent", "1").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
   withExit(
     async (fromChainStr, toChainStr, amountStr, options) => {
+      if (!amountStr && !options.max) throw new Error("Provide an amount or use --max");
+      if (amountStr && options.max) throw new Error("Cannot specify both amount and --max");
       const context = await init(program.opts().vault);
       try {
         await executeSwap(context, {
           fromChain: findChainByName(fromChainStr) || fromChainStr,
           toChain: findChainByName(toChainStr) || toChainStr,
-          amount: parseFloat(amountStr),
+          amount: options.max ? "max" : parseFloat(amountStr),
           fromToken: options.fromToken,
           toToken: options.toToken,
           slippage: options.slippage ? parseFloat(options.slippage) : void 0,
@@ -5297,14 +5985,80 @@ program.command("swap <fromChain> <toChain> <amount>").description("Swap tokens
     }
   )
 );
+var rujiraCmd = program.command("rujira").description("Rujira FIN swaps + secured asset tools on THORChain");
+rujiraCmd.command("balance").description("Show secured asset balances on THORChain").option("--secured-only", "Filter to secured/FIN-like denoms only").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+  withExit(async (options) => {
+    const context = await init(program.opts().vault);
+    await executeRujiraBalance(context, {
+      securedOnly: options.securedOnly,
+      rpcEndpoint: options.rpc,
+      restEndpoint: options.rest
+    });
+  })
+);
+rujiraCmd.command("routes").description("List available FIN swap routes").action(
+  withExit(async () => {
+    await executeRujiraRoutes();
+  })
+);
+rujiraCmd.command("deposit").description("Show deposit instructions (inbound address + memo)").option("--asset <asset>", "L1 asset to deposit (e.g., BTC.BTC, ETH.ETH)").option("--amount <amount>", "Amount in base units (optional; used for validation)", "1").option("--affiliate <thorAddress>", "Affiliate THOR address (optional)").option("--affiliate-bps <bps>", "Affiliate fee in basis points (optional)", "0").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+  withExit(
+    async (options) => {
+      const context = await init(program.opts().vault);
+      await executeRujiraDeposit(context, {
+        asset: options.asset,
+        amount: options.amount,
+        affiliate: options.affiliate,
+        affiliateBps: options.affiliateBps ? parseInt(options.affiliateBps, 10) : void 0,
+        rpcEndpoint: options.rpc,
+        restEndpoint: options.rest
+      });
+    }
+  )
+);
+rujiraCmd.command("swap <fromAsset> <toAsset> <amount>").description("Execute a FIN swap (amount in base units)").option("--slippage-bps <bps>", "Slippage tolerance in basis points (default: 100 = 1%)", "100").option("--destination <thorAddress>", "Destination THOR address (default: vault THORChain address)").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+  withExit(
+    async (fromAsset, toAsset, amount, options) => {
+      const context = await init(program.opts().vault, options.password);
+      await executeRujiraSwap(context, {
+        fromAsset,
+        toAsset,
+        amount,
+        slippageBps: options.slippageBps ? parseInt(options.slippageBps, 10) : void 0,
+        destination: options.destination,
+        yes: options.yes,
+        password: options.password,
+        rpcEndpoint: options.rpc,
+        restEndpoint: options.rest
+      });
+    }
+  )
+);
+rujiraCmd.command("withdraw <asset> <amount> <l1Address>").description("Withdraw secured assets to L1 (amount in base units)").option("--max-fee-bps <bps>", "Max outbound fee as bps of amount (optional)").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+  withExit(
+    async (asset, amount, l1Address, options) => {
+      const context = await init(program.opts().vault, options.password);
+      await executeRujiraWithdraw(context, {
+        asset,
+        amount,
+        l1Address,
+        maxFeeBps: options.maxFeeBps ? parseInt(options.maxFeeBps, 10) : void 0,
+        yes: options.yes,
+        password: options.password,
+        rpcEndpoint: options.rpc,
+        restEndpoint: options.rest
+      });
+    }
+  )
+);
 program.command("version").description("Show detailed version information").action(
   withExit(async () => {
     printResult(formatVersionDetailed());
     const result = await checkForUpdates();
     if (result?.updateAvailable && result.latestVersion) {
       info("");
-      info(chalk12.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
-      info(chalk12.gray(`Run "${getUpdateCommand()}" to update`));
+      info(chalk13.yellow(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      info(chalk13.gray(`Run "${getUpdateCommand()}" to update`));
     }
   })
 );
@@ -5313,28 +6067,28 @@ program.command("update").description("Check for updates and show update command
     info("Checking for updates...");
     const result = await checkForUpdates();
     if (!result) {
-      printResult(chalk12.gray("Update checking is disabled"));
+      printResult(chalk13.gray("Update checking is disabled"));
       return;
     }
     if (result.updateAvailable && result.latestVersion) {
       printResult("");
-      printResult(chalk12.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
+      printResult(chalk13.green(`Update available: ${result.currentVersion} -> ${result.latestVersion}`));
       printResult("");
       if (options.check) {
         printResult(`Run "${getUpdateCommand()}" to update`);
       } else {
         const updateCmd = getUpdateCommand();
         printResult(`To update, run:`);
-        printResult(chalk12.cyan(`  ${updateCmd}`));
+        printResult(chalk13.cyan(`  ${updateCmd}`));
       }
     } else {
-      printResult(chalk12.green(`You're on the latest version (${result.currentVersion})`));
+      printResult(chalk13.green(`You're on the latest version (${result.currentVersion})`));
     }
   })
 );
 setupCompletionCommand(program);
 async function startInteractiveMode() {
-  const sdk = new Vultisig4({
+  const sdk = new Vultisig5({
     onPasswordRequired: createPasswordCallback()
   });
   await sdk.initialize();