@vultisig/cli 6.2.0 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @vultisig/cli
 
+## 7.0.0
+
+### Patch Changes
+
+- [#2295](https://github.com/vultisig/vultisig-sdk/pull/2295) [`27dfd44`](https://github.com/vultisig/vultisig-sdk/commit/27dfd44fe6002d84c6f1e57ed0729ec22303a749) Thanks [@neavra](https://github.com/neavra)! - Refresh EIP-1559 priority fees immediately before CLI signing so zero-tip transactions use the live RPC suggestion, respect canonical per-chain minimums, and never exceed `maxFeePerGas`. Broadcast rejection messages now retain the actionable RPC reason without exposing the signed raw transaction.
+
+- [#1996](https://github.com/vultisig/vultisig-sdk/pull/1996) [`a56c7cb`](https://github.com/vultisig/vultisig-sdk/commit/a56c7cb2b1bcfa74edcee0ae7e5552f830804734) Thanks [@gomesalexandre](https://github.com/gomesalexandre)! - Export the `ChainDiscoveryAggregate` type from the public SDK seedphrase and root entrypoints so consumers can import the aggregate result returned by seedphrase discovery without restating the contract locally.
+
+- [#2307](https://github.com/vultisig/vultisig-sdk/pull/2307) [`42fd134`](https://github.com/vultisig/vultisig-sdk/commit/42fd1349b52fec44a5a0f47a898ad1537ac6ff60) Thanks [@rcoderdev](https://github.com/rcoderdev)! - Refresh stale raw EVM server nonces from pending RPC state immediately before signing.
+
+- [#2294](https://github.com/vultisig/vultisig-sdk/pull/2294) [`a3e1415`](https://github.com/vultisig/vultisig-sdk/commit/a3e1415758077867343de920af5bec36f2f89b11) Thanks [@neavra](https://github.com/neavra)! - Route pipe-mode confirmation and password replies around the serialized message queue so signable agent turns can complete.
+
+- [#2318](https://github.com/vultisig/vultisig-sdk/pull/2318) [`26a83ed`](https://github.com/vultisig/vultisig-sdk/commit/26a83ed417c9543f9c92d28cbb1bd35f0f914817) Thanks [@rcoderdev](https://github.com/rcoderdev)! - Fix TRON transaction lifecycle safety across fee preparation, status polling, and broadcast. Native TRX bandwidth estimates now measure the WalletCore-serialized signed transaction including memo bytes, default transaction times use the fetched block timestamp, expired raw transactions terminate polling, and successful broadcasts must return the deterministic local transaction hash.
+
+- Updated dependencies [[`27dfd44`](https://github.com/vultisig/vultisig-sdk/commit/27dfd44fe6002d84c6f1e57ed0729ec22303a749), [`1b3fb49`](https://github.com/vultisig/vultisig-sdk/commit/1b3fb498ad3f78b84b92b9f09b41fe8956fc5e9a), [`a56c7cb`](https://github.com/vultisig/vultisig-sdk/commit/a56c7cb2b1bcfa74edcee0ae7e5552f830804734), [`bd15294`](https://github.com/vultisig/vultisig-sdk/commit/bd15294a739c7977b26704b7b6df38e83e6bda23), [`7d4c116`](https://github.com/vultisig/vultisig-sdk/commit/7d4c116cc7a940e96abf075790c4a387edd03987), [`7b65284`](https://github.com/vultisig/vultisig-sdk/commit/7b65284f7fe73f538283a201a416efdbbda0830c), [`1716a79`](https://github.com/vultisig/vultisig-sdk/commit/1716a7946bf617ff16f8bb15f33b279efbb4a87d), [`a711b6c`](https://github.com/vultisig/vultisig-sdk/commit/a711b6ca8a8a7ae39d0efbb1c919b23b6538a1b8), [`ef6a8bb`](https://github.com/vultisig/vultisig-sdk/commit/ef6a8bb0007c6576179e5a8cb10aa47820075b57), [`26a83ed`](https://github.com/vultisig/vultisig-sdk/commit/26a83ed417c9543f9c92d28cbb1bd35f0f914817), [`4978c02`](https://github.com/vultisig/vultisig-sdk/commit/4978c02f08521600fc70fa6b4753bae5a589371b), [`8a2c126`](https://github.com/vultisig/vultisig-sdk/commit/8a2c126333bb1010cf859eef6a4876e7a20da18f), [`b19c5d5`](https://github.com/vultisig/vultisig-sdk/commit/b19c5d56f4d00d92493f8da74ff80d92b1d87c68)]:
+  - @vultisig/sdk@7.0.0
+  - @vultisig/core-chain@5.0.0
+  - @vultisig/rujira@71.0.0
+  - @vultisig/client-shared@0.3.6
+
+## 6.3.0
+
+### Patch Changes
+
+- [#2202](https://github.com/vultisig/vultisig-sdk/pull/2202) [`2d90f80`](https://github.com/vultisig/vultisig-sdk/commit/2d90f803055e7c1325ab1dc1966e17431740cb1f) Thanks [@neavra](https://github.com/neavra)! - Derive swap sell-token contracts from signed approval payloads and mark unresolved contract disclosures explicitly.
+
+- Updated dependencies [[`c0eafeb`](https://github.com/vultisig/vultisig-sdk/commit/c0eafeb12df42cffa70ef6951c081a74383e5fa2), [`b2f63b7`](https://github.com/vultisig/vultisig-sdk/commit/b2f63b70c4dac0001f0f40521efa4412f1d9e1cb), [`536c320`](https://github.com/vultisig/vultisig-sdk/commit/536c32028bf1f66897bf018c19f36c298545841a), [`78be14e`](https://github.com/vultisig/vultisig-sdk/commit/78be14ea9f1f011ded932ce6a9be5c19cf5694d0), [`76be65f`](https://github.com/vultisig/vultisig-sdk/commit/76be65fc297a43de6313b9dce3b096e6f764831a), [`e23780f`](https://github.com/vultisig/vultisig-sdk/commit/e23780f0b292cd76e80c72c5ccdcdafebd73a735), [`30499f8`](https://github.com/vultisig/vultisig-sdk/commit/30499f83f9909d8eb9bc1d310b25fdadb5c240e7), [`534154b`](https://github.com/vultisig/vultisig-sdk/commit/534154b6e9daaffad5d2e4958af3ead5fa940f21), [`3d40017`](https://github.com/vultisig/vultisig-sdk/commit/3d400171facf1107472e827c4ef48d7dd99843f1), [`c0c08f0`](https://github.com/vultisig/vultisig-sdk/commit/c0c08f0bd2337147d6b92ca7f391115edd7db62b), [`2869ae6`](https://github.com/vultisig/vultisig-sdk/commit/2869ae60bc157e2020a541e31a50afabef4e9edc), [`ef252e4`](https://github.com/vultisig/vultisig-sdk/commit/ef252e40b590a6cad9f303f7aba743c617442f90), [`4e23e92`](https://github.com/vultisig/vultisig-sdk/commit/4e23e9205310e46564bc1782b57499b2a39d7a5f), [`4561c65`](https://github.com/vultisig/vultisig-sdk/commit/4561c6584f62fa78d17546bcc119e31b6ea665cb), [`fc876a7`](https://github.com/vultisig/vultisig-sdk/commit/fc876a7fb561041539cb257a814d078304de6857), [`d08babd`](https://github.com/vultisig/vultisig-sdk/commit/d08babd96c36b193f8788605ed59871da1483ff3), [`4292e31`](https://github.com/vultisig/vultisig-sdk/commit/4292e3127e56bc2c92f2ac7b0a2886fcb0445043), [`d267ff6`](https://github.com/vultisig/vultisig-sdk/commit/d267ff66b9cf6d0b5898d40ec1f37cda6decb707), [`5f7dd00`](https://github.com/vultisig/vultisig-sdk/commit/5f7dd007cb5026d7c3ebe414fa5952f3419df570), [`bfe0292`](https://github.com/vultisig/vultisig-sdk/commit/bfe0292e3876fb7acc7044bac1b544c27aba8919), [`acd0b2e`](https://github.com/vultisig/vultisig-sdk/commit/acd0b2eaa882669a399fb378e51244ed4199ee47), [`f86320b`](https://github.com/vultisig/vultisig-sdk/commit/f86320bcfbee02b2f27473ac41a042db307596f6)]:
+  - @vultisig/core-chain@4.1.1
+  - @vultisig/sdk@6.3.0
+
 ## 6.2.0
 
 ### Minor Changes

package/dist/index.js

@@ -8130,7 +8130,7 @@ var require_dist = __commonJS({
 import "dotenv/config";
 import { promises as fs4 } from "node:fs";
 import { descriptions } from "@vultisig/client-shared";
-import { Chain as Chain14, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
+import { Chain as Chain15, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk16 from "chalk";
 import { InvalidArgumentError, program as program2 } from "commander";
 
@@ -10610,32 +10610,6 @@ Use --add <contractAddress> to add or --remove <tokenId> to remove`));
   }
 }
 
-// ../../packages/core/chain/dist/chains/ripple/address.js
-import { classicAddressToXAddress, isValidXAddress, xAddressToClassicAddress } from "ripple-address-codec";
-var assertSupportedTag = (tag) => {
-  if (tag === false)
-    return void 0;
-  return tag;
-};
-var decodeRippleXAddress = (address) => {
-  const value = address.trim();
-  if (!isValidXAddress(value))
-    throw new Error("Invalid XRP X-address");
-  const decoded = xAddressToClassicAddress(value);
-  if (decoded.test)
-    throw new Error("XRP testnet X-addresses are not supported");
-  return {
-    address: decoded.classicAddress,
-    destinationTag: assertSupportedTag(decoded.tag)
-  };
-};
-var normalizeRippleDestination = (address) => {
-  const value = address.trim();
-  if (value.startsWith("X") || value.startsWith("T"))
-    return decodeRippleXAddress(value);
-  return { address: value };
-};
-
 // ../../packages/core/mpc/dist/keysign/error.js
 var BuildKeysignPayloadError = class extends Error {
   type;
@@ -10667,7 +10641,7 @@ var resolveDestinationTag = ({ destinationTag, memo }) => {
 };
 
 // src/commands/transaction.ts
-import { Chain as Chain3, Vultisig as Vultisig2 } from "@vultisig/sdk";
+import { Chain as Chain3, normalizeRippleDestination, Vultisig as Vultisig2 } from "@vultisig/sdk";
 var getSendPreviewDetails = (chain, keysignPayload) => {
   let memo = keysignPayload.memo || void 0;
   if (chain !== Chain3.Ripple) {
@@ -11513,7 +11487,7 @@ function resolveTxStatusParams(params) {
 }
 var POLL_INTERVAL_MS = 5e3;
 var DEFAULT_TIMEOUT_SEC = 120;
-var isTerminal = (status) => status === "success" || status === "error";
+var isTerminal = (status) => status === "success" || status === "error" || status === "expired";
 function resolveTimeoutMs(timeoutSec) {
   if (typeof timeoutSec !== "number" || !Number.isFinite(timeoutSec)) {
     return DEFAULT_TIMEOUT_SEC * 1e3;
@@ -11553,7 +11527,7 @@ async function executeTxStatus(ctx2, params, opts = {}) {
     }
     if (result.status === "success") {
       recordResolution(params.txHash, "confirmed");
-    } else if (result.status === "error") {
+    } else if (result.status === "error" || result.status === "expired") {
       recordResolution(params.txHash, "failed");
     }
     spinner.succeed(`Transaction status: ${toCliStatus(result.status)}`);
@@ -14072,9 +14046,104 @@ import { randomUUID } from "node:crypto";
 // src/agent/toolOutputSigning.ts
 import { getChainKind as getChainKind5 } from "@vultisig/sdk";
 
+// ../../packages/core/chain/dist/Chain.js
+var EthereumL2Chain = {
+  Arbitrum: "Arbitrum",
+  Base: "Base",
+  Blast: "Blast",
+  Optimism: "Optimism",
+  Zksync: "Zksync",
+  Mantle: "Mantle",
+  Robinhood: "Robinhood"
+};
+var EvmChain = {
+  ...EthereumL2Chain,
+  Avalanche: "Avalanche",
+  CronosChain: "CronosChain",
+  BSC: "BSC",
+  Ethereum: "Ethereum",
+  Polygon: "Polygon",
+  Hyperliquid: "Hyperliquid",
+  Sei: "Sei"
+};
+var UtxoChain;
+(function(UtxoChain2) {
+  UtxoChain2["Bitcoin"] = "Bitcoin";
+  UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
+  UtxoChain2["Litecoin"] = "Litecoin";
+  UtxoChain2["Dogecoin"] = "Dogecoin";
+  UtxoChain2["Dash"] = "Dash";
+  UtxoChain2["Zcash"] = "Zcash";
+})(UtxoChain || (UtxoChain = {}));
+var cosmosChainsByKind = {
+  ibcEnabled: {
+    Cosmos: "Cosmos",
+    Osmosis: "Osmosis",
+    Dydx: "Dydx",
+    Terra: "Terra",
+    TerraClassic: "TerraClassic",
+    Noble: "Noble",
+    Akash: "Akash"
+  },
+  vaultBased: {
+    THORChain: "THORChain",
+    MayaChain: "MayaChain"
+  }
+};
+var IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
+var VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
+var CosmosChain = {
+  ...IbcEnabledCosmosChain,
+  ...VaultBasedCosmosChain
+};
+var OtherChain;
+(function(OtherChain2) {
+  OtherChain2["Sui"] = "Sui";
+  OtherChain2["Solana"] = "Solana";
+  OtherChain2["Polkadot"] = "Polkadot";
+  OtherChain2["Bittensor"] = "Bittensor";
+  OtherChain2["Ton"] = "Ton";
+  OtherChain2["Ripple"] = "Ripple";
+  OtherChain2["Tron"] = "Tron";
+  OtherChain2["Cardano"] = "Cardano";
+  OtherChain2["QBTC"] = "QBTC";
+})(OtherChain || (OtherChain = {}));
+var Chain10 = {
+  ...EvmChain,
+  ...UtxoChain,
+  ...CosmosChain,
+  ...OtherChain
+};
+var UtxoBasedChain = [...Object.values(UtxoChain), OtherChain.Cardano];
+var defaultChains = [Chain10.Bitcoin, Chain10.Ethereum, Chain10.THORChain, Chain10.Solana, Chain10.BSC];
+
+// ../../packages/core/chain/dist/chains/evm/tx/fee/index.js
+var evmChainTxFeeFormat = {
+  [EvmChain.Arbitrum]: "enveloped",
+  [EvmChain.Base]: "enveloped",
+  [EvmChain.Blast]: "enveloped",
+  [EvmChain.Optimism]: "enveloped",
+  [EvmChain.Zksync]: "enveloped",
+  [EvmChain.Avalanche]: "enveloped",
+  [EvmChain.CronosChain]: "enveloped",
+  [EvmChain.BSC]: "legacy",
+  [EvmChain.Ethereum]: "enveloped",
+  [EvmChain.Polygon]: "enveloped",
+  [EvmChain.Mantle]: "enveloped",
+  [EvmChain.Hyperliquid]: "enveloped",
+  // Sei must stay 'enveloped': iOS (EVMHelper.setGasParameters) and Android
+  // (EthereumGasHelper.setGasParameters) sign every EVM chain except BSC as
+  // EIP-1559. A different tx mode changes the pre-signing hash and therefore
+  // the relay message_id, so extension<->mobile Sei co-signing deadlocks
+  // (vultisig-windows#4369).
+  [EvmChain.Sei]: "enveloped",
+  [EvmChain.Robinhood]: "enveloped"
+};
+
 // src/agent/executor.ts
 import {
-  Chain as Chain11,
+  Chain as Chain12,
+  clampEvmPriorityFee,
   computeEip712Hash,
   getChainKind as getChainKind4,
   getEvmRpcUrl,
@@ -14246,7 +14315,7 @@ function sleep2(ms) {
 
 // src/agent/hlOrder.ts
 var import_msgpack = __toESM(require_dist(), 1);
-import { Chain as Chain10 } from "@vultisig/sdk";
+import { Chain as Chain11 } from "@vultisig/sdk";
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var HL_AGENT_TYPES = {
   Agent: [
@@ -14397,7 +14466,7 @@ async function validateRequestBinding(payload, expected, vault, now) {
   if (typeof payload.owner_public_key !== "string") throw new Error("HL_INVALID_OWNER_PUBLIC_KEY");
   if (payload.owner_public_key.toLowerCase() !== expected.publicKey.toLowerCase()) throw new Error("HL_OWNER_MISMATCH");
   if (typeof payload.vault_address !== "string") throw new Error("HL_INVALID_VAULT_ADDRESS");
-  const localAddress = await vault.address(Chain10.Ethereum);
+  const localAddress = await vault.address(Chain11.Ethereum);
   if (payload.vault_address.toLowerCase() !== localAddress.toLowerCase()) throw new Error("HL_VAULT_ADDRESS_MISMATCH");
   if (typeof payload.expires_at !== "string") throw new Error("HL_INVALID_EXPIRY");
   const expiry = Date.parse(payload.expires_at);
@@ -14490,16 +14559,185 @@ var EVM_CHAINS = /* @__PURE__ */ new Set([
 ]);
 var ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
 var ERC20_TRANSFER_ABI = parseAbi(["function transfer(address to, uint256 value)"]);
+var changedByMoreThanHalf = (before, after) => {
+  if (before === after) return false;
+  const difference = before > after ? before - after : after - before;
+  return difference * 2n > before;
+};
 function decodeErc20Transfer(calldata) {
   if (calldata.slice(0, ERC20_TRANSFER_SELECTOR.length).toLowerCase() !== ERC20_TRANSFER_SELECTOR) return null;
   try {
-    const decoded = decodeFunctionData({ abi: ERC20_TRANSFER_ABI, data: calldata });
+    const decoded = decodeFunctionData({
+      abi: ERC20_TRANSFER_ABI,
+      data: calldata
+    });
     const [recipient, amount] = decoded.args;
     return { recipient, amount };
   } catch {
     throw new Error("Invalid ERC-20 transfer calldata \u2014 refusing to sign");
   }
 }
+var tokenLabel = (value) => typeof value === "string" ? value : "";
+var MAX_TOKEN_SYMBOL_LENGTH = 32;
+var MAX_TOKEN_LABEL_LENGTH = 512;
+function safeTokenSymbol(symbol) {
+  const defaultDisplaySymbol = symbol.match(/^[\p{L}\p{N}][\p{L}\p{N}._+-]{0,31}/u)?.[0] ?? "token";
+  if (symbol.length > MAX_TOKEN_SYMBOL_LENGTH) {
+    return { displaySymbol: defaultDisplaySymbol, suspicious: true };
+  }
+  const suspiciousAt = symbol.search(/0x[0-9a-f]{40}|\([^)]*\bon\b[^)]*\)/iu);
+  const candidate = (suspiciousAt < 0 ? symbol : symbol.slice(0, suspiciousAt)).trim();
+  const displaySymbol = candidate.match(/^[\p{L}\p{N}][\p{L}\p{N}._+-]*/u)?.[0] ?? "token";
+  if (suspiciousAt < 0 && candidate === displaySymbol) {
+    return { displaySymbol, suspicious: false };
+  }
+  return { displaySymbol, suspicious: true };
+}
+function unresolvedTokenIdentity(label) {
+  if (typeof label !== "string" || label.length > MAX_TOKEN_LABEL_LENGTH) {
+    return { rawSymbol: "", displaySymbol: "", kind: "unresolved" };
+  }
+  const suffixAt = label.lastIndexOf(" (");
+  const rawSymbol = (suffixAt > 0 ? label.slice(0, suffixAt) : label).trim();
+  return {
+    rawSymbol,
+    displaySymbol: safeTokenSymbol(rawSymbol).displaySymbol,
+    kind: "unresolved"
+  };
+}
+function untrustedSymbolIdentity(symbol) {
+  const rawSymbol = tokenLabel(symbol);
+  return {
+    rawSymbol,
+    displaySymbol: safeTokenSymbol(rawSymbol).displaySymbol,
+    kind: "unresolved"
+  };
+}
+function resolvedTokenIdentity(label, expectedChain) {
+  const unresolved = unresolvedTokenIdentity(label);
+  if (typeof label !== "string" || label.length > MAX_TOKEN_LABEL_LENGTH) return unresolved;
+  const match = label.match(/^([\s\S]*) \(([\s\S]*?) on ([^,]+), \d+ dec, source: [^)]+\)$/u);
+  if (!match) return unresolved;
+  const [, rawSymbol, rawAssetId, descriptorChain] = match;
+  const { displaySymbol, suspicious } = safeTokenSymbol(rawSymbol);
+  const parsedChain = resolveChainReference(descriptorChain);
+  const routedChain = typeof expectedChain === "string" || typeof expectedChain === "number" ? resolveChainReference(expectedChain) : void 0;
+  if (suspicious || !parsedChain || !routedChain || parsedChain !== routedChain) {
+    return { rawSymbol, displaySymbol, kind: "unresolved" };
+  }
+  const assetId = rawAssetId.trim();
+  if (!assetId) return { rawSymbol, displaySymbol, kind: "unresolved" };
+  if (assetId.toLowerCase() === "native") return { rawSymbol, displaySymbol, kind: "native" };
+  if (getChainKind4(routedChain) === "evm") {
+    if (!/^0x[0-9a-f]{40}$/iu.test(assetId)) return { rawSymbol, displaySymbol, kind: "unresolved" };
+  } else if (!/^[\p{L}\p{N}:._/-]{1,128}$/u.test(assetId)) {
+    return { rawSymbol, displaySymbol, kind: "unresolved" };
+  }
+  return { rawSymbol, displaySymbol, kind: "token", contract: assetId };
+}
+function replaceUnsafeSymbol(text, identity) {
+  if (!identity.rawSymbol || identity.rawSymbol === identity.displaySymbol) return text;
+  return text.split(identity.rawSymbol).join(identity.displaySymbol);
+}
+function anchorEnd(text, label) {
+  if (!label) return -1;
+  const tokenChar = /[\p{L}\p{N}._+-]/u;
+  const trimmedLength = text.trimEnd().length;
+  const index = trimmedLength - label.length;
+  if (index < 0 || !text.startsWith(label, index)) return -1;
+  const before = text[index - 1];
+  if (before && tokenChar.test(before)) return -1;
+  return trimmedLength;
+}
+function hasAnchor(text, anchors) {
+  return anchors.some((anchor) => anchorEnd(text, anchor) >= 0);
+}
+function hasSingleSwapDelimiter(summary, labels) {
+  const identities = [
+    unresolvedTokenIdentity(labels.from_token),
+    untrustedSymbolIdentity(labels.from_token_symbol),
+    unresolvedTokenIdentity(labels.to_token),
+    untrustedSymbolIdentity(labels.to_token_symbol)
+  ];
+  const structuralSummary = identities.reduce((text, identity) => replaceUnsafeSymbol(text, identity), summary);
+  const firstArrow = structuralSummary.indexOf("\u2192");
+  return firstArrow >= 0 && structuralSummary.indexOf("\u2192", firstArrow + 1) < 0;
+}
+function splitSwapHead(head, sellAnchors, buyAnchors) {
+  let best;
+  let arrowAt = head.indexOf("\u2192");
+  while (arrowAt >= 0) {
+    const left = head.slice(0, arrowAt);
+    const right = head.slice(arrowAt + 1);
+    const viaAt = right.indexOf(" via ");
+    const buy = viaAt >= 0 ? right.slice(0, viaAt) : right;
+    const provider = viaAt >= 0 ? right.slice(viaAt) : "";
+    const score = Number(hasAnchor(left, sellAnchors)) + Number(hasAnchor(buy, buyAnchors));
+    if (!best || score > best.score) {
+      best = { left, buy, provider, score };
+    }
+    arrowAt = head.indexOf("\u2192", arrowAt + 1);
+  }
+  return best;
+}
+function terminalAnchorSymbol(anchor) {
+  return anchor.trim().match(/[\p{L}\p{N}][\p{L}\p{N}._+-]*$/u)?.[0] ?? "";
+}
+function discloseSwapSide(side, anchors, suffix, expectedSymbol) {
+  if (!expectedSymbol) {
+    return `${side.trimEnd()} (contract unavailable)${side.slice(side.trimEnd().length)}`;
+  }
+  for (const anchor of anchors) {
+    const end = anchorEnd(side, anchor);
+    if (end < 0) continue;
+    const visibleSymbol = terminalAnchorSymbol(anchor);
+    if (expectedSymbol && visibleSymbol && visibleSymbol !== expectedSymbol) break;
+    if (!suffix) return side;
+    return `${side.slice(0, end)}${suffix}${side.slice(end)}`;
+  }
+  return `${side.trimEnd()} (contract unavailable)${side.slice(side.trimEnd().length)}`;
+}
+function discloseSwapTokenContracts(head, labels, payload, sourceChain) {
+  const destinationChain = Object.hasOwn(labels, "to_chain") ? labels.to_chain ?? null : typeof payload?.to_chain === "string" || typeof payload?.to_chain === "number" ? payload.to_chain : void 0;
+  const fromToken = resolvedTokenIdentity(labels.from_token, sourceChain);
+  const toToken = resolvedTokenIdentity(labels.to_token, destinationChain);
+  const fromSymbol = untrustedSymbolIdentity(labels.from_token_symbol);
+  const toSymbol = untrustedSymbolIdentity(labels.to_token_symbol);
+  const approvalArgs = payload?.approvalTxArgs;
+  const rawApprovalTarget = tokenLabel(
+    approvalArgs && typeof approvalArgs === "object" ? approvalArgs.tx?.to : void 0
+  );
+  const approvalTarget = /^0x[0-9a-f]{40}$/iu.test(rawApprovalTarget) ? rawApprovalTarget : "";
+  const symbolIdentities = [fromToken, fromSymbol, toToken, toSymbol];
+  const sanitizeText = (value) => symbolIdentities.reduce((text, identity) => replaceUnsafeSymbol(text, identity), tokenLabel(value));
+  const sanitizedHead = sanitizeText(head);
+  const sellAnchors = [sanitizeText(labels.amount_in), fromSymbol.displaySymbol, fromToken.displaySymbol].filter(
+    Boolean
+  );
+  const buyAnchors = [sanitizeText(labels.expected_output), toSymbol.displaySymbol, toToken.displaySymbol].filter(
+    Boolean
+  );
+  const approvalMatchesResolvedSellToken = fromToken.kind === "token" && !!fromToken.contract && !!approvalTarget && fromToken.contract.toLowerCase() === approvalTarget.toLowerCase();
+  const sellSuffix = payload?.approvalTxArgs ? approvalMatchesResolvedSellToken ? ` (${approvalTarget})` : " (contract unavailable)" : fromToken.kind === "native" ? "" : fromToken.kind === "token" && fromToken.contract ? ` (${fromToken.contract})` : " (contract unavailable)";
+  const buySuffix = toToken.kind === "native" ? "" : toToken.kind === "token" && toToken.contract ? ` (${toToken.contract})` : " (contract unavailable)";
+  const halves = splitSwapHead(sanitizedHead, sellAnchors, buyAnchors);
+  if (!halves) return `${sanitizedHead} (contract unavailable)`;
+  const sellResolved = fromToken.kind !== "unresolved";
+  const buyResolved = toToken.kind !== "unresolved";
+  const sell = discloseSwapSide(
+    halves.left,
+    sellAnchors,
+    sellResolved ? sellSuffix : "",
+    sellResolved ? fromToken.displaySymbol : void 0
+  );
+  const buy = discloseSwapSide(
+    halves.buy,
+    buyAnchors,
+    buyResolved ? buySuffix : "",
+    buyResolved ? toToken.displaySymbol : void 0
+  );
+  return `${sell}\u2192${buy}${halves.provider}`;
+}
 var isEvmChain = (chain) => EVM_CHAINS.has(chain);
 function stripEmbeddedPayloadContract(value, disclosedContract) {
   if (!disclosedContract) return value;
@@ -14571,12 +14809,12 @@ var AgentExecutor = class {
       if (this.vault.isEncrypted && !this.vault.isUnlocked?.() && this.password) {
         await this.vault.unlock?.(this.password);
       }
-      const expectedAddress = await this.vault.address(Chain11.Ethereum);
+      const expectedAddress = await this.vault.address(Chain12.Ethereum);
       const signatures = [];
       for (const step of payload.steps) {
         const signed = await this.vault.signBytes({
           data: step.digest,
-          chain: Chain11.Ethereum
+          chain: Chain12.Ethereum
         });
         const canonical = toCanonicalEvmSignature(signed.signature, signed.recovery ?? 0);
         const v = canonical.recovery + 27;
@@ -14751,7 +14989,7 @@ var AgentExecutor = class {
     if (!nestedTx && txReadyData && typeof txReadyData === "object") {
       const txArgs = txReadyData.txArgs;
       if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
-        const chain2 = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
+        const chain2 = resolveChainFromTxReady(txReadyData) || Chain12.Ethereum;
         if (getChainKind4(chain2) !== "evm") {
           this.pendingPayloads.clear();
           this.pendingLegs = [];
@@ -14776,7 +15014,7 @@ var AgentExecutor = class {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain12.Ethereum;
     this.pendingPayloads.clear();
     this.pendingLegs = [];
     this.pendingPayloads.set("latest", {
@@ -14885,12 +15123,22 @@ var AgentExecutor = class {
     }
     const isSwap = !!(p?.approvalTxArgs || p?.swap_tx || labels.quote_summary || labels.to_token_symbol);
     if (isSwap) {
-      const usedQuoteSummary = !!labels.quote_summary;
-      const head = labels.quote_summary || `swap ${labels.amount_in ?? p?.txArgs?.amount ?? "?"} ${labels.from_token_symbol ?? ""} \u2192 ${labels.to_token_symbol ?? ""}`.trim();
+      const rawQuoteSummary = tokenLabel(labels.quote_summary);
+      const quoteSummary = hasSingleSwapDelimiter(rawQuoteSummary, labels) ? rawQuoteSummary : "";
+      const usedQuoteSummary = !!quoteSummary;
+      const amountIn = tokenLabel(labels.amount_in) || tokenLabel(p?.txArgs?.amount) || "?";
+      const fromSymbol = tokenLabel(labels.from_token_symbol);
+      const sellHead = fromSymbol && !amountIn.endsWith(` ${fromSymbol}`) ? `${amountIn} ${fromSymbol}` : amountIn;
+      const head = discloseSwapTokenContracts(
+        quoteSummary || `swap ${sellHead} \u2192 ${tokenLabel(labels.to_token_symbol) || "?"}`,
+        labels,
+        p,
+        stored.chain
+      );
       const parts = [head, `on ${stored.chain}`];
-      if (!usedQuoteSummary && labels.provider) parts.push(`via ${labels.provider}`);
+      if (!usedQuoteSummary && tokenLabel(labels.provider)) parts.push(`via ${tokenLabel(labels.provider)}`);
       if (p?.__multiLeg) parts.push("(+ token approval \u2014 2 transactions)");
-      if (labels.estimated_fee) parts.push(`est. fee ${labels.estimated_fee}`);
+      if (tokenLabel(labels.estimated_fee)) parts.push(`est. fee ${tokenLabel(labels.estimated_fee)}`);
       return parts.join(" ");
     }
     const signedTx = extractNestedTx(p);
@@ -14914,18 +15162,18 @@ var AgentExecutor = class {
    */
   renderLabelSendSummary(p, labels, chain, to, disclosedContract) {
     const amount = stripEmbeddedPayloadContract(labels.resolved_amount ?? p?.txArgs?.amount ?? "?", disclosedContract);
-    const tokenLabel = stripEmbeddedPayloadContract(
+    const tokenLabel2 = stripEmbeddedPayloadContract(
       (labels.token_resolved || labels.token_symbol || "").trim(),
       disclosedContract
     );
-    const symbol = tokenLabel.split(/\s+/, 1)[0];
+    const symbol = tokenLabel2.split(/\s+/, 1)[0];
     const escapedChain = String(chain).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const routedChainPattern = new RegExp(`(?:^|\\s)(?:not\\s+)?on ${escapedChain}(?=\\s|$)`);
     const positiveRoutedChainPattern = new RegExp(`(?:^|\\s)(?<!\\bnot\\s+)on ${escapedChain}(?=\\s|$)`);
-    const tokenContext = tokenLabel.slice(symbol.length);
+    const tokenContext = tokenLabel2.slice(symbol.length);
     const labelCarriesRoutedChain = positiveRoutedChainPattern.test(tokenContext);
     const tokenDetail = tokenContext.replace(routedChainPattern, "").trim();
-    const amountEmbedsTokenLabel = tokenLabel.length > 0 && amount.endsWith(` ${tokenLabel}`);
+    const amountEmbedsTokenLabel = tokenLabel2.length > 0 && amount.endsWith(` ${tokenLabel2}`);
     const amountWithSymbol = symbol && !amount.endsWith(` ${symbol}`) && !amountEmbedsTokenLabel ? `${amount} ${symbol}` : amount;
     const tokenDetailSuffix = amountEmbedsTokenLabel || !tokenDetail ? "" : ` ${tokenDetail}`;
     const location = amountEmbedsTokenLabel && labelCarriesRoutedChain ? "" : `on ${chain}${tokenDetailSuffix}`;
@@ -15424,8 +15672,9 @@ var AgentExecutor = class {
           nonce: swapTx.nonce
         }
       });
-      await this.patchEvmNonce(chain, keysignPayload);
+      const nonceGraceAge = Date.now() - (this.evmLastBroadcast.get(chain.toString()) ?? 0);
       await this.patchEvmGas(chain, keysignPayload);
+      await this.patchEvmNonce(chain, keysignPayload, nonceGraceAge);
       const messageHashes = await this.vault.extractMessageHashes(keysignPayload);
       const signature = await this.vault.sign(
         {
@@ -15677,33 +15926,45 @@ var AgentExecutor = class {
     }
   }
   /**
-   * Patch the EVM nonce in a keysign payload if our local state is ahead of on-chain.
-   * The payload's blockchainSpecific.ethereumSpecific.nonce was set from RPC during
-   * prepareSendTx(). If we have locally-tracked pending txs, we override with a higher value.
+   * Refresh the EVM nonce from pending RPC state, then patch it if our local state
+   * is further ahead. Raw server envelopes may carry a nonce that became stale
+   * before signing, so the RPC refresh must not depend on local state existing.
    *
    * Also detects evicted txs: if local state claims a higher nonce but there are
    * no pending txs in the mempool (pending == latest), the intermediate txs were
    * dropped and local state is stale.
    */
-  async patchEvmNonce(chain, payload) {
-    if (!this.stateStore || !isEvmChain(chain)) return;
+  async patchEvmNonce(chain, payload, capturedBroadcastAge) {
+    if (!isEvmChain(chain)) return;
     const bs = payload.blockchainSpecific;
     if (!bs || bs.case !== "ethereumSpecific") return;
-    const rpcNonce = bs.value.nonce;
+    const recentBroadcastAge = capturedBroadcastAge ?? Date.now() - (this.evmLastBroadcast.get(chain.toString()) ?? 0);
+    const hasRecentBroadcast = recentBroadcastAge < 3e4;
+    const payloadNonce = bs.value.nonce;
+    const latestNonce = this.stateStore && !hasRecentBroadcast ? await this.fetchEvmLatestNonce(chain) : null;
+    const pendingNonce = await this.fetchEvmPendingNonce(chain);
+    const rpcNonce = [payloadNonce, latestNonce, pendingNonce].reduce(
+      (highest, nonce) => nonce !== null && nonce > highest ? nonce : highest,
+      payloadNonce
+    );
+    if (rpcNonce !== payloadNonce) {
+      bs.value.nonce = rpcNonce;
+      if (this.verbose) process.stderr.write(`[nonce] Refreshed ${chain} nonce: ${payloadNonce} \u2192 ${rpcNonce}
+`);
+    }
+    if (!this.stateStore) return;
     const nextNonce = this.stateStore.getNextEvmNonce(chain, rpcNonce);
     if (nextNonce !== rpcNonce) {
-      const lastBroadcast = this.evmLastBroadcast.get(chain.toString()) ?? 0;
-      if (Date.now() - lastBroadcast < 3e4) {
+      if (hasRecentBroadcast) {
         if (this.verbose)
           process.stderr.write(
-            `[nonce] Keeping local nonce ${nextNonce} for ${chain} (broadcast ${Date.now() - lastBroadcast}ms ago)
+            `[nonce] Keeping local nonce ${nextNonce} for ${chain} (broadcast ${recentBroadcastAge}ms ago)
 `
           );
         bs.value.nonce = nextNonce;
         return;
       }
-      const pendingNonce = await this.fetchEvmPendingNonce(chain);
-      if (pendingNonce !== null && pendingNonce === rpcNonce) {
+      if (latestNonce !== null && pendingNonce === latestNonce) {
         if (this.verbose)
           process.stderr.write(
             `[nonce] Stale local state for ${chain}: local=${nextNonce}, on-chain=${rpcNonce}, no pending txs \u2014 using on-chain nonce
@@ -15713,7 +15974,8 @@ var AgentExecutor = class {
         return;
       }
       const nonceGap = nextNonce - rpcNonce;
-      if (pendingNonce === null && nonceGap > 3n) {
+      const pendingStateVerified = pendingNonce !== null && latestNonce !== null && pendingNonce >= latestNonce;
+      if (!pendingStateVerified && nonceGap > 3n) {
         process.stderr.write(
           `[nonce] Warning: pending nonce was not verified for ${chain}; signing will continue with on-chain nonce ${rpcNonce} because the local gap is ${nonceGap}
 `
@@ -15722,7 +15984,7 @@ var AgentExecutor = class {
         return;
       }
       bs.value.nonce = nextNonce;
-      if (pendingNonce === null) {
+      if (!pendingStateVerified) {
         process.stderr.write(
           `[nonce] Warning: pending nonce was not verified for ${chain}; signing will continue with local nonce ${nextNonce}
 `
@@ -15741,7 +16003,51 @@ var AgentExecutor = class {
     if (!isEvmChain(chain)) return;
     const bs = payload.blockchainSpecific;
     if (!bs || bs.case !== "ethereumSpecific") return;
+    const isEip1559 = evmChainTxFeeFormat[chain] === "enveloped";
+    if (!isEip1559) return;
     const rpcUrl = getEvmRpcUrl(chain);
+    const currentPriorityFee = BigInt(bs.value.priorityFee || "0");
+    const currentMaxFee = BigInt(bs.value.maxFeePerGasWei || "0");
+    const baseFee = await this.fetchEvmBaseFee(chain, rpcUrl);
+    let priorityFee = currentPriorityFee;
+    if (currentPriorityFee > 0n) {
+      priorityFee = clampEvmPriorityFee(chain, currentPriorityFee);
+      if (priorityFee < currentPriorityFee) {
+        process.stderr.write(
+          `[gas] Warning: ${chain} maxPriorityFeePerGas ${currentPriorityFee} exceeded the safety ceiling; clamped to ${priorityFee}
+`
+        );
+      }
+    } else {
+      const rpcPriorityFee = await this.fetchEvmPriorityFee(rpcUrl);
+      const baseFeeFallback = baseFee === null ? 0n : baseFee / 10n;
+      const fallbackPriorityFee = baseFeeFallback < 2000000000n ? baseFeeFallback : 2000000000n;
+      priorityFee = clampEvmPriorityFee(chain, rpcPriorityFee > 0n ? rpcPriorityFee : fallbackPriorityFee);
+    }
+    const minMaxFee = baseFee === null ? priorityFee : baseFee * 25n / 10n + priorityFee;
+    const patchedMaxFee = currentMaxFee < minMaxFee ? minMaxFee : currentMaxFee;
+    if (priorityFee !== currentPriorityFee) {
+      bs.value.priorityFee = priorityFee.toString();
+      if (this.verbose)
+        process.stderr.write(`[gas] Patched ${chain} maxPriorityFeePerGas: ${currentPriorityFee} \u2192 ${priorityFee}
+`);
+    }
+    if (currentMaxFee < patchedMaxFee) {
+      bs.value.maxFeePerGasWei = patchedMaxFee.toString();
+      if (this.verbose)
+        process.stderr.write(
+          `[gas] Bumped ${chain} maxFeePerGas: ${currentMaxFee} \u2192 ${patchedMaxFee} (baseFee=${baseFee ?? "unavailable"})
+`
+        );
+    }
+    if (changedByMoreThanHalf(currentPriorityFee, priorityFee) || changedByMoreThanHalf(currentMaxFee, patchedMaxFee)) {
+      process.stderr.write(
+        `[gas] Notice: ${chain} fees adjusted after confirmation: maxPriorityFeePerGas ${currentPriorityFee} \u2192 ${priorityFee}, maxFeePerGas ${currentMaxFee} \u2192 ${patchedMaxFee}
+`
+      );
+    }
+  }
+  async fetchEvmBaseFee(chain, rpcUrl) {
     try {
       const res = await fetch(rpcUrl, {
         method: "POST",
@@ -15758,24 +16064,33 @@ var AgentExecutor = class {
       if (!res.ok || data?.error || data?.result?.baseFeePerGas === void 0 || data?.result?.baseFeePerGas === null) {
         throw new Error(`Failed to fetch current base fee for ${chain}`);
       }
-      const baseFee = BigInt(data.result.baseFeePerGas);
-      if (baseFee === 0n) return;
-      const currentPriorityFee = BigInt(bs.value.priorityFee || "0");
-      const currentMaxFee = BigInt(bs.value.maxFeePerGasWei || "0");
-      const minMaxFee = baseFee * 25n / 10n + currentPriorityFee;
-      if (currentMaxFee < minMaxFee) {
-        bs.value.maxFeePerGasWei = minMaxFee.toString();
-        if (this.verbose)
-          process.stderr.write(
-            `[gas] Bumped ${chain} maxFeePerGas: ${currentMaxFee} \u2192 ${minMaxFee} (baseFee=${baseFee})
-`
-          );
-      }
+      return BigInt(data.result.baseFeePerGas);
     } catch {
       process.stderr.write(
         `[gas] Warning: gas estimate was not refreshed for ${chain}; signing will continue with the original estimate
 `
       );
+      return null;
+    }
+  }
+  async fetchEvmPriorityFee(rpcUrl) {
+    try {
+      const res = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          method: "eth_maxPriorityFeePerGas",
+          params: [],
+          id: 2
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      const data = await res.json();
+      if (!res.ok || data?.error || data?.result === void 0) return 0n;
+      return BigInt(data.result);
+    } catch {
+      return 0n;
     }
   }
   /**
@@ -15783,6 +16098,16 @@ var AgentExecutor = class {
    * Returns null if the RPC call fails (non-fatal).
    */
   async fetchEvmPendingNonce(chain) {
+    return this.fetchEvmNonce(chain, "pending");
+  }
+  /**
+   * Fetch the confirmed nonce from RPC (eth_getTransactionCount with "latest" tag).
+   * Returns null if the RPC call fails (non-fatal).
+   */
+  async fetchEvmLatestNonce(chain) {
+    return this.fetchEvmNonce(chain, "latest");
+  }
+  async fetchEvmNonce(chain, blockTag) {
     if (!isEvmChain(chain)) return null;
     const rpcUrl = getEvmRpcUrl(chain);
     try {
@@ -15793,7 +16118,7 @@ var AgentExecutor = class {
         body: JSON.stringify({
           jsonrpc: "2.0",
           method: "eth_getTransactionCount",
-          params: [address, "pending"],
+          params: [address, blockTag],
           id: 1
         }),
         signal: AbortSignal.timeout(5e3)
@@ -15893,11 +16218,11 @@ var AgentExecutor = class {
 `);
     const chainName = params.chain;
     const chainId = domain.chainId;
-    let chain = Chain11.Ethereum;
+    let chain = Chain12.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain11.Ethereum;
+      chain = resolveChain(chainName) || Chain12.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain11.Ethereum;
+      chain = resolveChainId(chainId) || Chain12.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -17231,7 +17556,9 @@ var PipeInterface = class {
   session;
   rl = null;
   stopped = false;
+  inputClosed = false;
   pendingPasswordResolve = null;
+  pendingPasswordReject = null;
   pendingConfirmResolve = null;
   constructor(session) {
     this.session = session;
@@ -17263,38 +17590,45 @@ var PipeInterface = class {
         }))
       });
     }
-    const lines = [];
+    const commands = [];
     let inputDone = false;
     let processing = false;
     this.rl.on("line", async (line) => {
       const trimmed = line.trim();
       if (!trimmed) return;
-      lines.push(trimmed);
+      let cmd;
+      try {
+        cmd = JSON.parse(trimmed);
+      } catch {
+        this.emitInvalidInput("Malformed JSON input");
+        return;
+      }
+      if (cmd?.type === "confirm" || cmd?.type === "password") {
+        this.handleControlCommand(cmd);
+        return;
+      }
+      commands.push(cmd);
       if (!processing) {
         processing = true;
-        while (lines.length > 0) {
-          const nextLine = lines.shift();
+        while (commands.length > 0) {
+          const nextCommand = commands.shift();
           try {
-            const cmd = JSON.parse(nextLine);
-            await this.handleCommand(cmd);
+            await this.handleCommand(nextCommand);
           } catch (err) {
-            const { message, code } = normalizeAgentError(err);
-            this.emit({
-              type: "error",
-              message: `Invalid input: ${message}`,
-              code: code === "UNKNOWN_ERROR" /* UNKNOWN_ERROR */ ? "INVALID_INPUT" /* INVALID_INPUT */ : code
-            });
+            this.emitInvalidInput(err);
           }
         }
         processing = false;
-        if (inputDone && lines.length === 0) {
+        if (inputDone && commands.length === 0) {
           this.stop();
         }
       }
     });
     this.rl.on("close", () => {
+      this.inputClosed = true;
       inputDone = true;
-      if (!processing && lines.length === 0) {
+      this.settlePendingPrompts("Password input closed before a reply was received");
+      if (!processing && commands.length === 0) {
         this.stop();
       }
     });
@@ -17374,17 +17708,30 @@ var PipeInterface = class {
       onDone: () => {
         this.emit({ type: "done" });
       },
-      requestPassword: async () => {
-        return new Promise((resolve) => {
+      requestPassword: () => {
+        if (this.inputClosed) {
+          const password2 = Promise.reject(
+            Object.assign(new Error("Password input closed before a reply was received"), {
+              code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
+            })
+          );
+          void password2.catch(() => void 0);
+          return password2;
+        }
+        const password = new Promise((resolve, reject) => {
           this.pendingPasswordResolve = resolve;
+          this.pendingPasswordReject = reject;
           this.emit({
             type: "error",
             message: "PASSWORD_REQUIRED",
             code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
           });
         });
+        void password.catch(() => void 0);
+        return password;
       },
       requestConfirmation: async (message) => {
+        if (this.inputClosed) return false;
         return new Promise((resolve) => {
           this.pendingConfirmResolve = resolve;
           this.emit({
@@ -17406,21 +17753,14 @@ var PipeInterface = class {
           const { message, code } = normalizeAgentError(err);
           this.emit({ type: "error", message, code });
           this.emit({ type: "done" });
+        } finally {
+          this.settlePendingPrompts("Password request cancelled because the turn ended");
         }
         break;
       }
-      case "password": {
-        if (this.pendingPasswordResolve) {
-          this.pendingPasswordResolve(cmd.password);
-          this.pendingPasswordResolve = null;
-        }
-        break;
-      }
+      case "password":
       case "confirm": {
-        if (this.pendingConfirmResolve) {
-          this.pendingConfirmResolve(cmd.confirmed);
-          this.pendingConfirmResolve = null;
-        }
+        this.handleControlCommand(cmd);
         break;
       }
       default:
@@ -17431,6 +17771,54 @@ var PipeInterface = class {
         });
     }
   }
+  handleControlCommand(cmd) {
+    if (cmd.type === "password") {
+      if (!this.pendingPasswordResolve) {
+        this.emitInvalidInput("No pending password request for this reply");
+        return;
+      }
+      if (typeof cmd.password !== "string") {
+        this.emitInvalidInput("Password reply must contain a string password");
+        return;
+      }
+      const resolve2 = this.pendingPasswordResolve;
+      this.pendingPasswordResolve = null;
+      this.pendingPasswordReject = null;
+      resolve2(cmd.password);
+      return;
+    }
+    if (!this.pendingConfirmResolve) {
+      this.emitInvalidInput("No pending confirmation for this reply");
+      return;
+    }
+    if (cmd.confirmed !== true && cmd.confirmed !== false) {
+      this.emitInvalidInput("Confirmation reply must contain a boolean confirmed value");
+      return;
+    }
+    const resolve = this.pendingConfirmResolve;
+    this.pendingConfirmResolve = null;
+    resolve(cmd.confirmed === true);
+  }
+  settlePendingPrompts(passwordMessage) {
+    const confirmResolve = this.pendingConfirmResolve;
+    this.pendingConfirmResolve = null;
+    confirmResolve?.(false);
+    const passwordReject = this.pendingPasswordReject;
+    this.pendingPasswordResolve = null;
+    this.pendingPasswordReject = null;
+    if (passwordReject) {
+      const error2 = Object.assign(new Error(passwordMessage), { code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */ });
+      passwordReject(error2);
+    }
+  }
+  emitInvalidInput(err) {
+    const { message, code } = normalizeAgentError(err);
+    this.emit({
+      type: "error",
+      message: `Invalid input: ${message}`,
+      code: code === "UNKNOWN_ERROR" /* UNKNOWN_ERROR */ ? "INVALID_INPUT" /* INVALID_INPUT */ : code
+    });
+  }
   emit(event) {
     process.stdout.write(JSON.stringify(event) + "\n");
   }
@@ -18344,6 +18732,11 @@ var AgentSession = class {
           recordResolution(txHash, "failed");
           return;
         }
+        if (result.status === "expired") {
+          ui.onTxStatus(txHash, chainName ?? "", "failed", explorerUrl);
+          recordResolution(txHash, "failed");
+          return;
+        }
       } catch (err) {
         if (this.config.verbose) {
           process.stderr.write(`[session] tx confirm poll ${attempt + 1} failed: ${err?.message ?? err}
@@ -19480,7 +19873,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "6.2.0";
+    cachedVersion = "7.0.0";
     return cachedVersion;
   }
   try {
@@ -19977,7 +20370,7 @@ var EventBuffer = class {
 };
 
 // src/interactive/session.ts
-import { Chain as Chain13, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
+import { Chain as Chain14, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
 import chalk14 from "chalk";
 import ora3 from "ora";
 import * as readline3 from "readline";
@@ -20828,7 +21221,7 @@ Error: ${error2.message}`));
       } else if (rest[i] === "--destination-tag") {
         const tag = rest[i + 1];
         const parsedTag = Number(tag);
-        if (chain !== Chain13.Ripple || !/^(0|[1-9]\d*)$/.test(tag ?? "") || !Number.isSafeInteger(parsedTag) || parsedTag > 4294967295) {
+        if (chain !== Chain14.Ripple || !/^(0|[1-9]\d*)$/.test(tag ?? "") || !Number.isSafeInteger(parsedTag) || parsedTag > 4294967295) {
           throw new Error("Invalid XRP DestinationTag: expected an integer from 0 to 4294967295");
         }
         destinationTag = parsedTag;
@@ -21676,7 +22069,7 @@ See also: balance, tx-status`
       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 chain = resolveChainOrThrow(chainStr);
-      if (options.destinationTag !== void 0 && chain !== Chain14.Ripple) {
+      if (options.destinationTag !== void 0 && chain !== Chain15.Ripple) {
         throw new Error("--destination-tag is only supported for XRP");
       }
       const destinationTag = options.destinationTag === void 0 ? void 0 : Number(options.destinationTag);
@@ -21804,7 +22197,7 @@ program2.command("broadcast").description("Broadcast a pre-signed raw transactio
 program2.command("tx-status").description("Check transaction status (polls until terminal or timeout)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--tx-hash <hash>", "Transaction hash to check").option("--no-wait", "Return immediately without waiting for confirmation").option("--timeout <seconds>", "Max seconds to poll before giving up (default 120)").addHelpText(
   "after",
   `
-Statuses: pending, not_found, confirmed, failed
+Statuses: pending, not_found, expired, confirmed, failed
 Malformed hashes fail with INVALID_HASH (exit 4).
 
 Examples:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "6.2.0",
+  "version": "7.0.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": {
@@ -73,10 +73,10 @@
     "@msgpack/msgpack": "^3.1.2",
     "@napi-rs/keyring": "^1.3.0",
     "@noble/hashes": "^2.2.0",
-    "@vultisig/client-shared": "^0.3.5",
-    "@vultisig/core-chain": "^4.1.0",
-    "@vultisig/rujira": "^70.0.0",
-    "@vultisig/sdk": "^6.2.0",
+    "@vultisig/client-shared": "^0.3.6",
+    "@vultisig/core-chain": "^5.0.0",
+    "@vultisig/rujira": "^71.0.0",
+    "@vultisig/sdk": "^7.0.0",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
@@ -94,7 +94,7 @@
     "@types/node": "^26.1.1",
     "@types/tabtab": "^3.0.4",
     "@types/ws": "^8.18.1",
-    "@vultisig/core-mpc": "^2.1.0",
+    "@vultisig/core-mpc": "^3.0.0",
     "esbuild": "^0.28.1",
     "ethers": "^6.17.0",
     "node-pty": "^1.1.0",