@vultisig/cli 5.1.0 → 5.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @vultisig/cli
 
+## 5.2.0
+
+### Minor Changes
+
+- [#1719](https://github.com/vultisig/vultisig-sdk/pull/1719) [`ac213ac`](https://github.com/vultisig/vultisig-sdk/commit/ac213ac23f49e0d3ea3ad1cb10a055f28c921469) Thanks [@rcoderdev](https://github.com/rcoderdev)! - Add direct unsigned CLI preparation commands for contract calls, IBC, SPL, TRC-20, Jetton, Sui tokens, Polkadot assets, Cosmos staking, and CW-20 transfers.
+
+### Patch Changes
+
+- Updated dependencies [[`397c2b6`](https://github.com/vultisig/vultisig-sdk/commit/397c2b6629fdc7002d55bd95bb8585dce78de416), [`df144e9`](https://github.com/vultisig/vultisig-sdk/commit/df144e9e21c2fb64e73efcf12ac35c958dbf1c7b), [`7d6a014`](https://github.com/vultisig/vultisig-sdk/commit/7d6a01440fd0b855356cce81469b5b5a91665862)]:
+  - @vultisig/sdk@5.2.0
+  - @vultisig/core-chain@3.0.0
+  - @vultisig/rujira@69.0.0
+
 ## 5.1.0
 
 ### Patch Changes

package/README.md

@@ -367,6 +367,28 @@ Swap quotes and previews show your VULT discount tier when affiliate fees are ap
 | `sign`                       | Sign pre-hashed bytes for custom transactions |
 | `broadcast`                  | Broadcast a pre-signed raw transaction        |
 | `tx-status <chain> <txHash>` | Check transaction confirmation status         |
+| `prep <helper>`              | Build an unsigned SDK transaction payload     |
+
+#### Unsigned transaction preparation
+
+`vultisig prep` exposes the SDK's specialized transaction builders directly. These commands only build unsigned
+payloads: they never sign or broadcast. Identity-dependent helpers use the active vault's public identity by default;
+isolated tooling can pass the same non-secret fields with `--identity <json>`.
+
+```bash
+vultisig prep contract-call Ethereum <contractAddress> approve --sender <senderAddress> --abi '[{"type":"function","name":"approve","inputs":[{"type":"address","name":"spender"},{"type":"uint256","name":"amount"}]}]' --args '["<spenderAddress>","1000000"]'
+vultisig prep ibc-transfer Osmosis <sourceAddress> <receiverAddress> uosmo 1000000 --to-chain Cosmos
+vultisig prep spl-transfer <mint> <from> <to> 1000000 6
+vultisig prep trc20-transfer <contract> <from> <to> 1000000
+vultisig prep jetton-transfer <recipient> <senderJettonWallet> 1000000 5
+vultisig prep sui-token-transfer <coinType> <from> <to> 1000000 --decimals 6 --ticker USDC
+vultisig prep polkadot-asset-send 1984 <from> <to> 1000000
+vultisig prep cosmos-staking delegate <delegator> <validator> 5000000 uosmo
+vultisig prep cw20-transfer osmo <contract> <recipient> 1000000 <sender>
+```
+
+Run `vultisig prep <helper> --help` for the complete optional parameter set. JSON mode returns
+`{ helper, unsigned: true, result }` inside the standard versioned success envelope.
 
 #### Transaction Status
 

package/dist/index.js

@@ -3852,10 +3852,10 @@ var init_decodeAbiParameters = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/stringify.js
-var stringify;
+var stringify2;
 var init_stringify = __esm({
   "../../node_modules/viem/_esm/utils/stringify.js"() {
-    stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
+    stringify2 = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
       const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
       return typeof replacer === "function" ? replacer(key, value2) : value2;
     }, space);
@@ -10836,6 +10836,307 @@ async function sendTransaction(vault, params) {
   }
 }
 
+// src/commands/prep.ts
+import {
+  assertSafeDestination,
+  buildCw20TransferMsg,
+  buildDelegateMsg,
+  buildRedelegateMsg,
+  buildSplTransfer,
+  buildUndelegateMsg,
+  buildWithdrawRewardsMsg,
+  prepareContractCallTxFromKeys,
+  prepareIbcTransfer,
+  prepareJettonTransferTxFromKeys,
+  preparePolkadotAssetSend,
+  prepareSuiTokenTransferFromKeys,
+  prepareTrc20TransferFromKeys
+} from "@vultisig/sdk";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseJson = (raw, label) => {
+  try {
+    return JSON.parse(raw);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new InvalidInputError(`Invalid ${label} JSON: ${message}`);
+  }
+};
+var parseJsonArray = (raw, label) => {
+  const value = parseJson(raw, label);
+  if (!Array.isArray(value)) {
+    throw new InvalidInputError(`${label} must be a JSON array`);
+  }
+  return value;
+};
+var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+var assertLosslessJsonNumberLexemes = (raw, label) => {
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < raw.length; index += 1) {
+    const character = raw[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      continue;
+    }
+    if (character !== "-" && (character < "0" || character > "9")) continue;
+    const match = raw.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+    if (match === null) continue;
+    const lexeme = match[0];
+    if (/[.eE]/.test(lexeme) || BigInt(lexeme) > MAX_SAFE_INTEGER || BigInt(lexeme) < -MAX_SAFE_INTEGER) {
+      throw new InvalidInputError(
+        `${label} numeric values must be safe base-10 integer literals; pass ABI integers as decimal strings`
+      );
+    }
+    index += lexeme.length - 1;
+  }
+};
+var parseLosslessJsonArray = (raw, label) => {
+  assertLosslessJsonNumberLexemes(raw, label);
+  const value = parseJsonArray(raw, label);
+  return value;
+};
+var parseDecimalBigInt = (raw, label) => {
+  if (!/^-?\d+$/.test(raw)) {
+    throw new InvalidInputError(`${label} must be a base-10 integer string`);
+  }
+  return BigInt(raw);
+};
+var parseInteger = (raw, label) => {
+  if (!/^-?\d+$/.test(raw)) {
+    throw new InvalidInputError(`${label} must be an integer`);
+  }
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value)) {
+    throw new InvalidInputError(`${label} must be a safe integer`);
+  }
+  return value;
+};
+var parseOptionalInteger = (raw, label) => raw === void 0 ? void 0 : parseInteger(raw, label);
+var parseIdentity = (raw) => {
+  const value = parseJson(raw, "identity");
+  if (!isRecord(value)) {
+    throw new InvalidInputError("identity must be a JSON object");
+  }
+  const requiredStrings = ["ecdsaPublicKey", "eddsaPublicKey", "hexChainCode", "localPartyId", "libType"];
+  for (const field of requiredStrings) {
+    if (typeof value[field] !== "string" || value[field].length === 0) {
+      throw new InvalidInputError(`identity.${field} must be a non-empty string`);
+    }
+  }
+  if (!["GG20", "DKLS", "KeyImport"].includes(value.libType)) {
+    throw new InvalidInputError("identity.libType must be GG20, DKLS, or KeyImport");
+  }
+  if (value.chainPublicKeys !== void 0 && !isRecord(value.chainPublicKeys)) {
+    throw new InvalidInputError("identity.chainPublicKeys must be a JSON object when provided");
+  }
+  return value;
+};
+var identityFromVault = (vault) => ({
+  ecdsaPublicKey: vault.publicKeys.ecdsa,
+  eddsaPublicKey: vault.publicKeys.eddsa,
+  hexChainCode: vault.hexChainCode,
+  localPartyId: vault.localPartyId,
+  libType: vault.libType,
+  publicKeyMldsa: vault.publicKeyMldsa,
+  chainPublicKeys: vault.data.chainPublicKeys
+});
+var resolveIdentity = (vault, rawIdentity) => {
+  if (rawIdentity !== void 0) return parseIdentity(rawIdentity);
+  if (vault !== void 0) return identityFromVault(vault);
+  throw new InvalidInputError("An active vault or --identity JSON is required");
+};
+var stringify = (value) => JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, 2);
+var emitPrepResult = (helper, result) => {
+  const output = { helper, unsigned: true, result };
+  if (isJsonOutput()) {
+    outputJson(output);
+  } else {
+    printResult(stringify(output));
+  }
+};
+async function executePrepContractCall(vault, chain, contractAddress, functionName, options) {
+  const value = options.value === void 0 ? void 0 : parseDecimalBigInt(options.value, "value");
+  if (value !== void 0 && value > 0n) {
+    assertSafeDestination(chain, contractAddress);
+  }
+  const feeSettings = options.gasLimit !== void 0 || options.maxPriorityFeePerGas !== void 0 ? {
+    gasLimit: parseDecimalBigInt(options.gasLimit ?? "", "gas-limit"),
+    maxPriorityFeePerGas: parseDecimalBigInt(options.maxPriorityFeePerGas ?? "", "max-priority-fee-per-gas")
+  } : void 0;
+  const result = await prepareContractCallTxFromKeys(resolveIdentity(vault, options.identity), {
+    chain,
+    contractAddress,
+    abi: parseJsonArray(options.abi, "abi"),
+    functionName,
+    args: options.args === void 0 ? void 0 : parseLosslessJsonArray(options.args, "args"),
+    value,
+    senderAddress: options.sender,
+    feeSettings
+  });
+  emitPrepResult("contract-call", result);
+}
+function executePrepIbcTransfer(fromChain, fromAddress, toAddress, denom, amount, options) {
+  const result = prepareIbcTransfer({
+    fromChain,
+    fromAddress,
+    toAddress,
+    denom,
+    amount,
+    toChainId: options.toChain,
+    sourceChannel: options.sourceChannel,
+    timeoutHeight: options.timeoutHeight,
+    timeoutTimestamp: options.timeoutTimestamp,
+    accountNumber: options.accountNumber,
+    sequence: options.sequence,
+    memo: options.memo,
+    nowMs: parseOptionalInteger(options.nowMs, "now-ms")
+  });
+  emitPrepResult("ibc-transfer", result);
+}
+function executePrepSplTransfer(mint, from, to, amount, decimals, options) {
+  assertSafeDestination("Solana", to);
+  const result = buildSplTransfer({
+    mint,
+    from,
+    to,
+    amount: parseDecimalBigInt(amount, "amount"),
+    decimals: parseInteger(decimals, "decimals"),
+    isToken2022: options.token2022
+  });
+  emitPrepResult("spl-transfer", result);
+}
+function executePrepTrc20Transfer(contractAddress, from, to, amount, options) {
+  const result = prepareTrc20TransferFromKeys({
+    contractAddress,
+    from,
+    to,
+    amount,
+    memo: options.memo,
+    feeLimitSun: options.feeLimitSun
+  });
+  emitPrepResult("trc20-transfer", result);
+}
+function executePrepJettonTransfer(vault, receiver, jettonWalletAddress, amount, seqno, options) {
+  const built = prepareJettonTransferTxFromKeys(resolveIdentity(vault, options.identity), {
+    receiver,
+    jettonWalletAddress,
+    amount: parseDecimalBigInt(amount, "amount"),
+    seqno: parseInteger(seqno, "seqno"),
+    memo: options.memo,
+    validUntil: parseOptionalInteger(options.validUntil, "valid-until"),
+    workchain: parseOptionalInteger(options.workchain, "workchain")
+  });
+  const result = {
+    signingHashHex: built.signingHashHex,
+    unsignedBocHex: built.unsignedBocHex,
+    fromAddress: built.fromAddress
+  };
+  emitPrepResult("jetton-transfer", result);
+}
+async function executePrepSuiTokenTransfer(vault, coinType, from, to, amount, options) {
+  const result = await prepareSuiTokenTransferFromKeys(resolveIdentity(vault, options.identity), {
+    coinType,
+    from,
+    to,
+    amount: parseDecimalBigInt(amount, "amount"),
+    decimals: parseOptionalInteger(options.decimals, "decimals"),
+    ticker: options.ticker
+  });
+  emitPrepResult("sui-token-transfer", result);
+}
+function executePrepPolkadotAssetSend(assetId, from, to, amount, options) {
+  const result = preparePolkadotAssetSend({
+    assetId: parseInteger(assetId, "asset-id"),
+    from,
+    to,
+    amount: parseDecimalBigInt(amount, "amount"),
+    decimals: parseOptionalInteger(options.decimals, "decimals"),
+    ticker: options.ticker
+  });
+  emitPrepResult("polkadot-asset-send", result);
+}
+function executePrepCosmosStaking(action, delegatorAddress, validatorAddress, amount, denom, options) {
+  const prefixes = {
+    accountPrefix: options.accountPrefix,
+    validatorPrefix: options.validatorPrefix
+  };
+  let result;
+  switch (action) {
+    case "delegate":
+      if (amount === void 0 || denom === void 0) {
+        throw new InvalidInputError("delegate requires amount and denom");
+      }
+      result = buildDelegateMsg({
+        delegatorAddress,
+        validatorAddress,
+        amount,
+        denom,
+        ...prefixes
+      });
+      break;
+    case "undelegate":
+      if (amount === void 0 || denom === void 0) {
+        throw new InvalidInputError("undelegate requires amount and denom");
+      }
+      result = buildUndelegateMsg({
+        delegatorAddress,
+        validatorAddress,
+        amount,
+        denom,
+        ...prefixes
+      });
+      break;
+    case "redelegate":
+      if (amount === void 0 || denom === void 0 || options.validatorDst === void 0) {
+        throw new InvalidInputError("redelegate requires amount, denom, and --validator-dst");
+      }
+      result = buildRedelegateMsg({
+        delegatorAddress,
+        validatorSrcAddress: validatorAddress,
+        validatorDstAddress: options.validatorDst,
+        amount,
+        denom,
+        ...prefixes
+      });
+      break;
+    case "withdraw":
+      if (amount !== void 0 || denom !== void 0) {
+        throw new InvalidInputError("withdraw does not accept amount or denom");
+      }
+      result = buildWithdrawRewardsMsg({
+        delegatorAddress,
+        validatorAddress,
+        ...prefixes
+      });
+      break;
+    default:
+      throw new InvalidInputError("staking action must be delegate, undelegate, redelegate, or withdraw");
+  }
+  emitPrepResult("cosmos-staking", result);
+}
+function executePrepCw20Transfer(bech32Prefix, contract, recipient, amount, sender, options) {
+  const nativeDenoms = options.nativeDenoms?.split(",").map((value) => value.trim()).filter(Boolean);
+  const result = buildCw20TransferMsg({
+    bech32Prefix,
+    contract,
+    recipient,
+    amount,
+    sender,
+    nativeDenoms
+  });
+  emitPrepResult("cw20-transfer", result);
+}
+
 // src/commands/execute.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
 import {
@@ -12293,7 +12594,7 @@ init_stringify();
 init_base();
 var InvalidDomainError = class extends BaseError2 {
   constructor({ domain }) {
-    super(`Invalid domain "${stringify(domain)}".`, {
+    super(`Invalid domain "${stringify2(domain)}".`, {
       metaMessages: ["Must be a valid EIP-712 domain."]
     });
   }
@@ -19190,7 +19491,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "5.1.0";
+    cachedVersion = "5.2.0";
     return cachedVersion;
   }
   try {
@@ -19347,6 +19648,35 @@ var COMMAND_EXAMPLES = {
   execute: {
     examples: [`vultisig execute THORChain <contract> '{"swap":{}}'`]
   },
+  "prep.contract-call": {
+    examples: [
+      `vultisig prep contract-call Ethereum <contractAddress> approve --sender <senderAddress> --abi '[{"type":"function","name":"approve","inputs":[{"type":"address","name":"spender"},{"type":"uint256","name":"amount"}]}]' --args '["<spenderAddress>","1000000"]'`
+    ]
+  },
+  "prep.ibc-transfer": {
+    examples: ["vultisig prep ibc-transfer Osmosis osmo1... cosmos1... uosmo 1000000 --to-chain Cosmos"]
+  },
+  "prep.spl-transfer": {
+    examples: ["vultisig prep spl-transfer <mint> <from> <to> 1000000 6"]
+  },
+  "prep.trc20-transfer": {
+    examples: ["vultisig prep trc20-transfer <contract> <from> <to> 1000000"]
+  },
+  "prep.jetton-transfer": {
+    examples: ["vultisig prep jetton-transfer <recipient> <senderJettonWallet> 1000000 5"]
+  },
+  "prep.sui-token-transfer": {
+    examples: ["vultisig prep sui-token-transfer <coinType> <from> <to> 1000000 --decimals 6"]
+  },
+  "prep.polkadot-asset-send": {
+    examples: ["vultisig prep polkadot-asset-send 1984 <from> <to> 1000000"]
+  },
+  "prep.cosmos-staking": {
+    examples: ["vultisig prep cosmos-staking delegate <delegator> <validator> 5000000 uosmo"]
+  },
+  "prep.cw20-transfer": {
+    examples: ["vultisig prep cw20-transfer osmo <contract> <recipient> 1000000 <sender>"]
+  },
   "swap-quote": {
     examples: ["vultisig swap-quote Ethereum Bitcoin 0.1 --output json"]
   },
@@ -21372,6 +21702,66 @@ See also: balance, tx-status`
     }
   )
 );
+var prepCmd = program2.command("prep").description("Build unsigned transaction payloads with SDK preparation helpers (never signs or broadcasts)");
+var loadPrepVault = async (identity) => {
+  if (identity !== void 0) return void 0;
+  const context = await init(program2.opts().vault);
+  return context.ensureActiveVault();
+};
+prepCmd.command("contract-call <chain> <contractAddress> <functionName>").description("Build an unsigned EVM contract-call KeysignPayload").requiredOption("--abi <json>", "Solidity ABI JSON array").requiredOption("--sender <address>", "Sender EVM address").option("--args <json>", "Function arguments as a JSON array").option("--value <baseUnits>", "Native value in base units", "0").option("--gas-limit <baseUnits>", "Custom EVM gas limit (requires --max-priority-fee-per-gas)").option("--max-priority-fee-per-gas <baseUnits>", "Custom EVM priority fee (requires --gas-limit)").option("--identity <json>", "Public VaultIdentity JSON; otherwise use the active vault").action(
+  withExit(async (chain, contractAddress, functionName, options) => {
+    const vault = await loadPrepVault(options.identity);
+    await executePrepContractCall(vault, resolveChainOrThrow(chain), contractAddress, functionName, options);
+  })
+);
+prepCmd.command("ibc-transfer <fromChain> <fromAddress> <toAddress> <denom> <amount>").description("Build an unsigned ICS-20 IBC MsgTransfer envelope").option("--to-chain <chainId>", "Destination chain ID or Vultisig chain name").option("--source-channel <channel>", "IBC source channel (channel-N)").option("--timeout-height <revision/height>", "IBC timeout height (default: 0/0)").option("--timeout-timestamp <nanoseconds>", "Future Unix timeout in nanoseconds").option("--account-number <number>", "Source-chain account number").option("--sequence <number>", "Source-chain account sequence").option("--memo <memo>", "IBC packet memo").option("--now-ms <milliseconds>", "Override current time for deterministic default timeout").action(
+  withExit(
+    async (fromChain, fromAddress, toAddress, denom, amount, options) => {
+      executePrepIbcTransfer(fromChain, fromAddress, toAddress, denom, amount, options);
+    }
+  )
+);
+prepCmd.command("spl-transfer <mint> <from> <to> <amount> <decimals>").description("Build an unsigned SPL transferChecked instruction with derived ATAs").option("--token-2022", "Use the Token-2022 program instead of the legacy SPL Token program").action(
+  withExit(async (mint, from, to, amount, decimals, options) => {
+    executePrepSplTransfer(mint, from, to, amount, decimals, options);
+  })
+);
+prepCmd.command("trc20-transfer <contractAddress> <from> <to> <amount>").description("Build an unsigned TRC-20 transfer descriptor").option("--memo <memo>", "Optional TRON transaction memo").option("--fee-limit-sun <amount>", "Energy/bandwidth ceiling in SUN").action(
+  withExit(async (contractAddress, from, to, amount, options) => {
+    executePrepTrc20Transfer(contractAddress, from, to, amount, options);
+  })
+);
+prepCmd.command("jetton-transfer <receiver> <jettonWalletAddress> <amount> <seqno>").description("Build an unsigned TON Jetton transfer signing payload").option("--memo <memo>", "Forward comment (up to 123 UTF-8 bytes)").option("--valid-until <seconds>", "Unix-seconds expiry").option("--workchain <number>", "Sender wallet workchain (default: 0)").option("--identity <json>", "Public VaultIdentity JSON; otherwise use the active vault").action(
+  withExit(async (receiver, jettonWalletAddress, amount, seqno, options) => {
+    const vault = await loadPrepVault(options.identity);
+    executePrepJettonTransfer(vault, receiver, jettonWalletAddress, amount, seqno, options);
+  })
+);
+prepCmd.command("sui-token-transfer <coinType> <from> <to> <amount>").description("Build an unsigned Sui coin-object token-transfer KeysignPayload").option("--decimals <number>", "Token decimals metadata").option("--ticker <symbol>", "Token ticker metadata").option("--identity <json>", "Public VaultIdentity JSON; otherwise use the active vault").action(
+  withExit(async (coinType, from, to, amount, options) => {
+    const vault = await loadPrepVault(options.identity);
+    await executePrepSuiTokenTransfer(vault, coinType, from, to, amount, options);
+  })
+);
+prepCmd.command("polkadot-asset-send <assetId> <from> <to> <amount>").description("Build an unsigned Polkadot Asset Hub transferKeepAlive call").option("--decimals <number>", "Asset decimals override").option("--ticker <symbol>", "Asset ticker override").action(
+  withExit(async (assetId, from, to, amount, options) => {
+    executePrepPolkadotAssetSend(assetId, from, to, amount, options);
+  })
+);
+prepCmd.command("cosmos-staking <action> <delegatorAddress> <validatorAddress> [amount] [denom]").description("Build an unsigned Cosmos delegate, undelegate, redelegate, or withdraw message").option("--validator-dst <address>", "Destination validator for redelegate").option("--account-prefix <prefix>", "Expected delegator bech32 prefix").option("--validator-prefix <prefix>", "Expected validator bech32 prefix").action(
+  withExit(
+    async (action, delegatorAddress, validatorAddress, amount, denom, options) => {
+      executePrepCosmosStaking(action, delegatorAddress, validatorAddress, amount, denom, options);
+    }
+  )
+);
+prepCmd.command("cw20-transfer <bech32Prefix> <contract> <recipient> <amount> <sender>").description("Build an unsigned CosmWasm CW-20 transfer message").option("--native-denoms <csv>", "Comma-separated native denoms to reject on this route").action(
+  withExit(
+    async (bech32Prefix, contract, recipient, amount, sender, options) => {
+      executePrepCw20Transfer(bech32Prefix, contract, recipient, amount, sender, options);
+    }
+  )
+);
 program2.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("--dry-run", "Preview execution without signing or broadcasting").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").addHelpText(
   "after",
   `
@@ -21922,7 +22312,12 @@ authCmd.command("status").description("List configured vaults and their keyring
     const vaults = await executeAuthStatus();
     if (isJsonOutput()) {
       outputJson({
-        vaults: vaults.map((v) => ({ id: v.id, name: v.name, filePath: v.filePath, hasCredentials: v.hasCredentials }))
+        vaults: vaults.map((v) => ({
+          id: v.id,
+          name: v.name,
+          filePath: v.filePath,
+          hasCredentials: v.hasCredentials
+        }))
       });
       return;
     }
@@ -21941,7 +22336,11 @@ authCmd.command("logout").description("Clear keyring credentials for a vault").o
   withExit(async (options) => {
     await executeAuthLogout({ vaultId: options.vaultId, all: options.all });
     if (isJsonOutput()) {
-      outputJson({ cleared: true, vaultId: options.vaultId ?? null, all: !!options.all });
+      outputJson({
+        cleared: true,
+        vaultId: options.vaultId ?? null,
+        all: !!options.all
+      });
     } else {
       printResult(chalk16.green("Credentials cleared."));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "The self-custody MPC wallet CLI for AI coding agents (Claude Code, Cursor, OpenCode). Natural-language agent mode, 36+ chains, DKLS23 threshold signatures. Seedless.",
   "type": "module",
   "bin": {
@@ -75,9 +75,9 @@
     "@napi-rs/keyring": "^1.3.0",
     "@noble/hashes": "^2.2.0",
     "@vultisig/client-shared": "^0.3.4",
-    "@vultisig/core-chain": "^2.39.0",
-    "@vultisig/rujira": "^68.0.0",
-    "@vultisig/sdk": "^5.1.0",
+    "@vultisig/core-chain": "^3.0.0",
+    "@vultisig/rujira": "^69.0.0",
+    "@vultisig/sdk": "^5.2.0",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
@@ -95,7 +95,7 @@
     "@types/node": "^26.1.1",
     "@types/tabtab": "^3.0.4",
     "@types/ws": "^8.18.1",
-    "@vultisig/core-mpc": "^1.20.3",
+    "@vultisig/core-mpc": "^1.20.5",
     "esbuild": "^0.28.1",
     "ethers": "^6.17.0",
     "node-pty": "^1.1.0",