@vultisig/cli 2.8.0 → 2.8.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @vultisig/cli
 
+## 2.8.1
+
+### Patch Changes
+
+- [#867](https://github.com/vultisig/vultisig-sdk/pull/867) [`ddd08af`](https://github.com/vultisig/vultisig-sdk/commit/ddd08af883a1b2ee2f72dac4d406782de9090672) Thanks [@neavra](https://github.com/neavra)! - Agent: poll for final on-chain confirmation after broadcasting a signed tx
+  (audit F1). A `pending` `tx_status` only means "broadcast accepted" — the tx can
+  still revert, expire, or be dropped. After broadcast the session now polls
+  `vault.getTxStatus` until the tx reaches a final state and emits `confirmed` /
+  `failed`, or `timeout` when the bounded poll budget (~120s) is exhausted. The
+  `ask` result records the latest per-tx `status` (deduped by hash), and the pipe
+  `tx_status` event gains a `timeout` status. Best-effort and non-fatal: when the
+  chain can't be resolved or the vault can't poll status, the existing `pending`
+  status stands. The blocking confirmation wait is scoped to the top of the
+  message loop (depth 0 — the single-tx ask/pipe case); inside a multi-turn tool
+  loop a leg keeps its honest `pending` instead of stacking the poll budget per
+  tx. The shared `pending | confirmed | failed | timeout` union is now threaded
+  through the ask result, pipe event, and UI callback without unchecked casts.
+
 ## 2.8.0
 
 ### Patch Changes

package/dist/index.js

@@ -8224,9 +8224,15 @@ var AskInterface = class {
       onSuggestions: (_suggestions) => {
       },
       onTxStatus: (txHash, chain, status, explorerUrl) => {
-        this.transactions.push({ hash: txHash, chain, ...status ? { status } : {}, explorerUrl });
+        const existing = this.transactions.find((t) => t.hash === txHash);
+        if (existing) {
+          existing.status = status;
+          if (explorerUrl) existing.explorerUrl = explorerUrl;
+        } else {
+          this.transactions.push({ hash: txHash, chain, explorerUrl, status });
+        }
         if (this.verbose) {
-          process.stderr.write(`[tx] ${chain}: ${txHash}
+          process.stderr.write(`[tx] ${chain}: ${txHash} (${status})
 `);
         }
       },
@@ -12080,6 +12086,8 @@ var CLIENT_SIDE_TOOL_DISPATCH = {
 var MAX_MESSAGE_LOOP_DEPTH = 16;
 var RECOVERY_POLL_INTERVAL_MS = 2e3;
 var RECOVERY_MAX_POLLS = 90;
+var TX_CONFIRM_POLL_INTERVAL_MS = 3e3;
+var TX_CONFIRM_MAX_POLLS = 40;
 var AgentSession = class {
   client;
   vault;
@@ -12097,6 +12105,10 @@ var AgentSession = class {
   // poll loop without real 2s waits.
   recoveryPollIntervalMs = RECOVERY_POLL_INTERVAL_MS;
   recoveryMaxPolls = RECOVERY_MAX_POLLS;
+  // Post-broadcast confirmation poll cadence — instance fields so tests can
+  // drive the loop without real waits.
+  txConfirmPollIntervalMs = TX_CONFIRM_POLL_INTERVAL_MS;
+  txConfirmMaxPolls = TX_CONFIRM_MAX_POLLS;
   constructor(vault, config) {
     this.vault = vault;
     this.config = config;
@@ -12375,7 +12387,9 @@ var AgentSession = class {
         const txHash = recent.data.tx_hash;
         const chain = recent.data.chain;
         const explorerUrl = recent.data.explorer_url;
-        if (txHash) ui.onTxStatus(txHash, chain || "", "pending", explorerUrl);
+        if (txHash) {
+          await this.emitAndConfirmTx(txHash, chain, explorerUrl, depth, ui);
+        }
       }
       await this.processMessageLoop(null, ui, depth + 1);
       return;
@@ -12434,6 +12448,75 @@ var AgentSession = class {
   recoverySleep() {
     return new Promise((resolve) => setTimeout(resolve, this.recoveryPollIntervalMs));
   }
+  /**
+   * Post-broadcast confirmation polling (audit F1). A bare `pending` status only
+   * means "broadcast accepted"; the tx can still revert, expire, or be dropped,
+   * so a headless caller that stops at `pending` may mark a later-reverted
+   * operation complete. Poll vault.getTxStatus until the tx reaches a final
+   * state and emit the matching lifecycle status (`confirmed`/`failed`), or
+   * `timeout` when the bounded poll budget is exhausted (the tx may still
+   * confirm later — callers can re-check with `vultisig tx-status`).
+   *
+   * Transient RPC/network errors are treated as "not final yet" and retried
+   * until the budget is spent. Best-effort and non-fatal: if the chain can't be
+   * resolved or the vault doesn't expose getTxStatus, the caller's already-
+   * emitted `pending` status stands and this returns quietly.
+   *
+   * Scoped to headless callers (ask/pipe) that need machine-readable finality.
+   * The interactive TUI already shows `pending` + an explorer link immediately
+   * and has the dedicated `vultisig tx-status` command, so blocking its prompt
+   * for the full poll budget would be a UX regression the audit didn't scope.
+   * The poll also bails on cancel (Ctrl-C aborts the controller) so a long wait
+   * is interruptible.
+   *
+   * The caller only invokes this at message-loop depth 0 (see the call site):
+   * inside a multi-turn tool loop the broadcast result already drives the next
+   * turn, so blocking here would stack the poll budget per leg without feeding
+   * the server any extra signal. Those deeper legs keep their honest `pending`.
+   */
+  async emitAndConfirmTx(txHash, chain, explorerUrl, depth, ui) {
+    ui.onTxStatus(txHash, chain || "", "pending", explorerUrl);
+    if (depth === 0) {
+      await this.confirmBroadcastedTx(txHash, chain, explorerUrl, ui);
+    }
+  }
+  async confirmBroadcastedTx(txHash, chainName, explorerUrl, ui) {
+    if (!this.config.askMode && !this.config.viaAgent) return;
+    const chain = resolveChain(chainName ?? "");
+    if (!chain || typeof this.vault?.getTxStatus !== "function") return;
+    for (let attempt = 0; attempt < this.txConfirmMaxPolls; attempt++) {
+      if (this.abortController?.signal?.aborted) return;
+      try {
+        const result = await this.vault.getTxStatus({ chain, txHash });
+        if (result.status === "success") {
+          ui.onTxStatus(txHash, chainName ?? "", "confirmed", explorerUrl);
+          return;
+        }
+        if (result.status === "error") {
+          ui.onTxStatus(txHash, chainName ?? "", "failed", explorerUrl);
+          return;
+        }
+      } catch (err) {
+        if (this.config.verbose) {
+          process.stderr.write(`[session] tx confirm poll ${attempt + 1} failed: ${err?.message ?? err}
+`);
+        }
+      }
+      if (attempt < this.txConfirmMaxPolls - 1) await this.txConfirmSleep();
+    }
+    if (this.abortController?.signal?.aborted) return;
+    if (this.config.verbose) {
+      process.stderr.write(
+        `[session] tx ${txHash} not confirmed within ${this.txConfirmMaxPolls} polls; emitting timeout
+`
+      );
+    }
+    ui.onTxStatus(txHash, chainName ?? "", "timeout", explorerUrl);
+  }
+  /** Sleep between confirmation polls. Separate method so tests can stub it out. */
+  txConfirmSleep() {
+    return new Promise((resolve) => setTimeout(resolve, this.txConfirmPollIntervalMs));
+  }
   /**
    * Fold a recovered assistant message back into the live stream result: the
    * authoritative message wins over any partial deltas, and any persisted
@@ -13283,7 +13366,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.8.0";
+    cachedVersion = "2.8.1";
     return cachedVersion;
   }
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "2.8.0",
+  "version": "2.8.1",
   "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": {