@arkade-os/sdk 0.4.17 → 0.4.18

package/dist/cjs/wallet/vtxo-manager.js

@@ -32,6 +32,38 @@ function assertSweepCapable(wallet) {
         throw new Error("Boarding UTXO sweep requires a Wallet instance with boardingTapscript, onchainProvider, and network");
     }
 }
+/**
+ * Web Locks name used to serialize boarding-poll work across same-origin
+ * browser contexts (tabs, service worker). Static because the goal is to
+ * deduplicate polls for the *same* wallet — two distinct wallets on the
+ * same origin will take turns, which is acceptable.
+ */
+const BOARDING_POLL_LOCK_NAME = "arkade-boarding-poll";
+/**
+ * Run `fn` under an exclusive Web Lock when the runtime provides one
+ * (browser main thread, service worker). In environments without
+ * `navigator.locks` (Node, React Native) the callback runs immediately
+ * with no coordination.
+ *
+ * Uses `ifAvailable: true`: if another context already holds the lock,
+ * skip this cycle entirely rather than queueing — the other context will
+ * do the work and the next poll will re-check.
+ */
+async function runWithCrossInstanceLock(name, fn) {
+    const locks = typeof globalThis !== "undefined" &&
+        typeof globalThis.navigator !== "undefined"
+        ? globalThis.navigator.locks
+        : undefined;
+    if (!locks) {
+        await fn();
+        return;
+    }
+    await locks.request(name, { ifAvailable: true, mode: "exclusive" }, async (lock) => {
+        if (lock === null)
+            return;
+        await fn();
+    });
+}
 /** Default renewal threshold in seconds (3 days). */
 exports.DEFAULT_THRESHOLD_SECONDS = 3 * 24 * 60 * 60;
 /**
@@ -191,6 +223,15 @@ class VtxoManager {
         // server emits new VTXOs → vtxo_received → renewVtxos() again → infinite loop.
         this.renewalInProgress = false;
         this.lastRenewalTimestamp = 0;
+        // Guards against a retry treadmill on the periodic-settle path: a failing
+        // settle would otherwise re-submit identical intents on every 60s poll,
+        // producing per-minute DeleteIntent RPCs forever. Mirrors the renewal
+        // cooldown but with exponential backoff on consecutive failures, so a
+        // persistently broken input eventually drops to the backoff cap instead
+        // of hammering the server. Shared across boarding + expiring-VTXO work
+        // because they now ride on the same settle intent.
+        this.lastPeriodicSettleTimestamp = 0;
+        this.consecutivePeriodicSettleFailures = 0;
         // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
         if (settlementConfig !== undefined) {
             this.settlementConfig = settlementConfig;
@@ -412,10 +453,15 @@ class VtxoManager {
                     },
                 ],
             }, eventCallback);
-            this.lastRenewalTimestamp = Date.now();
             return txid;
         }
         finally {
+            // Update cooldown on EVERY attempt (success or failure) so transient
+            // settle failures (stream close, connector mismatch, duplicated input)
+            // don't allow the next vtxo_received event to re-enter renewal
+            // immediately. Without this, a failed settle leaves lastRenewalTimestamp
+            // at its previous value and the cooldown check becomes a no-op.
+            this.lastRenewalTimestamp = Date.now();
             this.renewalInProgress = false;
         }
     }
@@ -693,33 +739,42 @@ class VtxoManager {
         this.pollDone = { promise, resolve: resolve };
         let hadError = false;
         try {
-            // Fetch boarding inputs once for the entire poll cycle so that
-            // settle and sweep don't each hit the network independently.
-            const boardingUtxos = await this.wallet.getBoardingUtxos();
-            // Settle new (unexpired) boarding inputs first, then sweep expired ones.
-            // Sequential to avoid racing for the same inputs.
-            try {
-                await this.settleBoardingUtxos(boardingUtxos);
-            }
-            catch (e) {
-                hadError = true;
-                console.error("Error auto-settling boarding UTXOs:", e);
-            }
-            const sweepEnabled = this.settlementConfig !== false &&
-                (this.settlementConfig?.boardingUtxoSweep ??
-                    exports.DEFAULT_SETTLEMENT_CONFIG.boardingUtxoSweep);
-            if (sweepEnabled) {
+            // Cross-instance guard: in browser / service worker environments,
+            // serialize the poll body across tabs and SW contexts so only one
+            // of them registers intents per interval. Without this, every tab
+            // submits a parallel RegisterIntent for the same boarding input
+            // and N-1 of them collide on the server's duplicated-input check,
+            // each producing a DeleteIntent RPC. No-op outside the browser.
+            await runWithCrossInstanceLock(BOARDING_POLL_LOCK_NAME, async () => {
+                // Fetch boarding inputs once for the entire poll cycle so that
+                // settle and sweep don't each hit the network independently.
+                const boardingUtxos = await this.wallet.getBoardingUtxos();
+                // Settle new (unexpired) boarding inputs + any near-expiry
+                // VTXOs in a single intent, then sweep expired boarding
+                // inputs. Sequential to avoid racing for the same inputs.
                 try {
-                    await this.sweepExpiredBoardingUtxos(boardingUtxos);
+                    await this.runPeriodicSettle(boardingUtxos);
                 }
                 catch (e) {
-                    if (!(e instanceof Error) ||
-                        !e.message.includes("No expired boarding UTXOs")) {
-                        hadError = true;
-                        console.error("Error auto-sweeping boarding UTXOs:", e);
+                    hadError = true;
+                    console.error("Error during periodic settle:", e);
+                }
+                const sweepEnabled = this.settlementConfig !== false &&
+                    (this.settlementConfig?.boardingUtxoSweep ??
+                        exports.DEFAULT_SETTLEMENT_CONFIG.boardingUtxoSweep);
+                if (sweepEnabled) {
+                    try {
+                        await this.sweepExpiredBoardingUtxos(boardingUtxos);
+                    }
+                    catch (e) {
+                        if (!(e instanceof Error) ||
+                            !e.message.includes("No expired boarding UTXOs")) {
+                            hadError = true;
+                            console.error("Error auto-sweeping boarding UTXOs:", e);
+                        }
                     }
                 }
-            }
+            });
         }
         catch (e) {
             hadError = true;
@@ -739,13 +794,19 @@ class VtxoManager {
         }
     }
     /**
-     * Auto-settle new (unexpired) boarding inputs into Arkade.
-     * Skips UTXOs that are already expired (those are handled by sweep).
-     * Only settles UTXOs not already in-flight (tracked in knownBoardingUtxos).
-     * UTXOs are marked as known only after a successful settle, so failed
-     * attempts will be retried on the next poll.
+     * Auto-settle new (unexpired) boarding inputs AND near-expiry VTXOs into
+     * Arkade in a single intent. Skips boarding UTXOs that are already expired
+     * (those are handled by sweep) and those already in-flight (tracked in
+     * knownBoardingUtxos). If the event-driven renewal path is currently
+     * running, VTXOs are omitted from this cycle to avoid double-spending.
+     *
+     * Failure bookkeeping: after every settle *attempt*, lastPeriodicSettleTimestamp
+     * is armed and consecutive failures are counted so the next attempt is
+     * blocked by an exponentially growing cooldown (capped). This stops a
+     * persistently failing input from producing identical RegisterIntent +
+     * DeleteIntent retries on every 60s poll.
      */
-    async settleBoardingUtxos(boardingUtxos) {
+    async runPeriodicSettle(boardingUtxos) {
         // Exclude expired boarding inputs — those should be swept, not settled.
         // If we can't determine expired status, bail out entirely to avoid
         // accidentally settling expired inputs (which would conflict with sweep).
@@ -763,22 +824,73 @@ class VtxoManager {
         catch (e) {
             throw e instanceof Error ? e : new Error(String(e));
         }
-        const unsettledUtxos = boardingUtxos.filter((u) => !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) &&
+        const unsettledBoarding = boardingUtxos.filter((u) => !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) &&
             !expiredSet.has(`${u.txid}:${u.vout}`));
-        if (unsettledUtxos.length === 0)
+        // Collect near-expiry VTXOs unless the event-driven path is mid-renewal.
+        // Skipping when renewalInProgress avoids double-submitting the same VTXOs.
+        let expiringVtxos = [];
+        if (!this.renewalInProgress) {
+            try {
+                expiringVtxos = await this.getExpiringVtxos();
+            }
+            catch (e) {
+                // Non-fatal: fall back to boarding-only settle.
+                console.error("Error fetching expiring VTXOs:", e);
+            }
+        }
+        if (unsettledBoarding.length === 0 && expiringVtxos.length === 0) {
+            return;
+        }
+        // Respect the cooldown armed by the previous attempt. Cooldown grows
+        // exponentially with consecutive failures and is capped by
+        // PERIODIC_SETTLE_MAX_BACKOFF_MS.
+        const cooldownMs = Math.min(VtxoManager.PERIODIC_SETTLE_COOLDOWN_MS *
+            Math.pow(2, this.consecutivePeriodicSettleFailures), VtxoManager.PERIODIC_SETTLE_MAX_BACKOFF_MS);
+        if (Date.now() - this.lastPeriodicSettleTimestamp < cooldownMs) {
             return;
+        }
         const dustAmount = getDustAmount(this.wallet);
-        const totalAmount = unsettledUtxos.reduce((sum, u) => sum + BigInt(u.value), 0n);
+        const boardingTotal = unsettledBoarding.reduce((sum, u) => sum + BigInt(u.value), 0n);
+        const vtxoTotal = expiringVtxos.reduce((sum, v) => sum + BigInt(v.value), 0n);
+        const totalAmount = boardingTotal + vtxoTotal;
         if (totalAmount < dustAmount)
             return;
         const arkAddress = await this.wallet.getAddress();
-        await this.wallet.settle({
-            inputs: unsettledUtxos,
-            outputs: [{ address: arkAddress, amount: totalAmount }],
-        });
-        // Mark as known only after successful settle
-        for (const u of unsettledUtxos) {
-            this.knownBoardingUtxos.add(`${u.txid}:${u.vout}`);
+        const includesVtxos = expiringVtxos.length > 0;
+        // Block the event-driven renewal path while this settle is in flight
+        // when VTXOs are part of the intent. Mirrors renewVtxos()'s guard so
+        // the two paths can't race on the same VTXO inputs.
+        if (includesVtxos) {
+            this.renewalInProgress = true;
+        }
+        let success = false;
+        try {
+            await this.wallet.settle({
+                inputs: [...unsettledBoarding, ...expiringVtxos],
+                outputs: [{ address: arkAddress, amount: totalAmount }],
+            });
+            // Mark boarding inputs as known only after successful settle.
+            for (const u of unsettledBoarding) {
+                this.knownBoardingUtxos.add(`${u.txid}:${u.vout}`);
+            }
+            success = true;
+        }
+        finally {
+            this.lastPeriodicSettleTimestamp = Date.now();
+            if (includesVtxos) {
+                // Match event-path semantics: bump the renewal cooldown
+                // whether we succeeded or failed so a failed periodic settle
+                // doesn't let the next vtxo_received event re-enter renewal
+                // immediately.
+                this.lastRenewalTimestamp = Date.now();
+                this.renewalInProgress = false;
+            }
+            if (success) {
+                this.consecutivePeriodicSettleFailures = 0;
+            }
+            else {
+                this.consecutivePeriodicSettleFailures++;
+            }
         }
     }
     async dispose() {
@@ -812,3 +924,5 @@ class VtxoManager {
 exports.VtxoManager = VtxoManager;
 VtxoManager.MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes
 VtxoManager.RENEWAL_COOLDOWN_MS = 30000; // 30 seconds
+VtxoManager.PERIODIC_SETTLE_COOLDOWN_MS = 30000;
+VtxoManager.PERIODIC_SETTLE_MAX_BACKOFF_MS = 5 * 60 * 1000;

package/dist/cjs/wallet/wallet.js

@@ -304,8 +304,10 @@ class ReadonlyWallet {
     async getVtxos(filter) {
         const f = filter ?? { withRecoverable: true, withUnrolled: false };
         const contractManager = await this.getContractManager();
-        const contractsWithVtxos = await contractManager.getContractsWithVtxos();
-        return contractsWithVtxos.flatMap(({ vtxos }) => vtxos.filter((vtxo) => {
+        const vtxos = await contractManager.getContractsWithVtxos();
+        return vtxos
+            .flatMap((_) => _.vtxos)
+            .filter((vtxo) => {
             if ((0, _1.isSpendable)(vtxo)) {
                 if (!f.withRecoverable &&
                     ((0, _1.isRecoverable)(vtxo) || (0, _1.isExpired)(vtxo))) {
@@ -314,17 +316,15 @@ class ReadonlyWallet {
                 return true;
             }
             return !!(f.withUnrolled && vtxo.isUnrolled);
-        }));
+        });
     }
     /**
      * Return wallet transaction history derived from Arkade state and boarding transactions.
      */
     async getTransactionHistory() {
-        // Delta-sync virtual outputs into cache, then build history from the cache.
-        const { isDelta, fetchedExtended, address } = await this.syncVtxos();
-        const allVtxos = isDelta
-            ? await this.walletRepository.getVtxos(address)
-            : fetchedExtended;
+        const contractManager = await this.getContractManager();
+        const response = await contractManager.getContractsWithVtxos();
+        const allVtxos = response.flatMap((_) => _.vtxos);
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
         const getTxCreatedAt = (txid) => this.indexerProvider
             .getVtxos({ outpoints: [{ txid, vout: 0 }] })
@@ -332,166 +332,11 @@ class ReadonlyWallet {
         return (0, transactionHistory_1.buildTransactionHistory)(allVtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
     }
     /**
-     * Delta-sync wallet virtual outputs: fetch only changed virtual outputs since the last
-     * cursor, or do a full bootstrap when no cursor exists. Upserts
-     * the result into the cache and advances the sync cursors.
-     *
-     * Concurrent calls are deduplicated: if a sync is already in flight,
-     * subsequent callers receive the same promise instead of triggering
-     * a second network round-trip.
-     */
-    syncVtxos() {
-        if (this._syncVtxosInflight)
-            return this._syncVtxosInflight;
-        const p = this.doSyncVtxos().finally(() => {
-            this._syncVtxosInflight = undefined;
-        });
-        this._syncVtxosInflight = p;
-        return p;
-    }
-    async doSyncVtxos() {
-        const address = await this.getAddress();
-        // Batch cursor read with script map to avoid extra async hops
-        // before the fetch (background operations may run between hops).
-        const [scriptMap, cursors] = await Promise.all([
-            this.getScriptMap(),
-            (0, syncCursors_1.getAllSyncCursors)(this.walletRepository),
-        ]);
-        const allScripts = [...scriptMap.keys()];
-        // Partition scripts into bootstrap (no cursor) and delta (has cursor).
-        const bootstrapScripts = [];
-        const deltaScripts = [];
-        for (const s of allScripts) {
-            if (cursors[s] === undefined) {
-                bootstrapScripts.push(s);
-            }
-            else {
-                deltaScripts.push(s);
-            }
-        }
-        const requestStartedAt = Date.now();
-        const allVtxos = [];
-        const extendWithScript = (vtxo) => {
-            const vtxoScript = vtxo.script
-                ? scriptMap.get(vtxo.script)
-                : undefined;
-            if (!vtxoScript)
-                return undefined;
-            return {
-                ...vtxo,
-                forfeitTapLeafScript: vtxoScript.forfeit(),
-                intentTapLeafScript: vtxoScript.forfeit(),
-                tapTree: vtxoScript.encode(),
-            };
-        };
-        // Full fetch for scripts with no cursor.
-        if (bootstrapScripts.length > 0) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts: bootstrapScripts,
-            });
-            allVtxos.push(...response.vtxos);
-        }
-        // Delta fetch for scripts with an existing cursor.
-        let hasDelta = false;
-        if (deltaScripts.length > 0) {
-            const minCursor = Math.min(...deltaScripts.map((s) => cursors[s]));
-            const window = (0, syncCursors_1.computeSyncWindow)(minCursor);
-            if (window) {
-                hasDelta = true;
-                const response = await this.indexerProvider.getVtxos({
-                    scripts: deltaScripts,
-                    after: window.after,
-                });
-                allVtxos.push(...response.vtxos);
-            }
-        }
-        // Extend every fetched virtual output and upsert into the cache.
-        const fetchedExtended = [];
-        for (const vtxo of allVtxos) {
-            const extended = extendWithScript(vtxo);
-            if (extended)
-                fetchedExtended.push(extended);
-        }
-        // Save virtual outputs first, then advance cursors only on success.
-        const cutoff = (0, syncCursors_1.cursorCutoff)(requestStartedAt);
-        await this.walletRepository.saveVtxos(address, fetchedExtended);
-        await (0, syncCursors_1.advanceSyncCursors)(this.walletRepository, Object.fromEntries(allScripts.map((s) => [s, cutoff])));
-        // Delta-sync reconciliation: full re-fetch for delta scripts.
-        //
-        // The delta fetch (above) only returns virtual outputs changed after the
-        // cursor, so it can miss preconfirmed virtual outputs that were consumed
-        // by a round between syncs.  Rather than layering targeted
-        // queries (pendingOnly, spendableOnly) with pagination guards
-        // and set algebra, we perform a single unfiltered re-fetch for
-        // delta scripts.  This is slightly more data over the wire but
-        // gives us complete, authoritative state in one call and keeps
-        // the reconciliation logic simple.
-        //
-        // Any cached non-spent virtual output that is absent from the full
-        // result set is marked spent; any virtual output whose state changed
-        // (e.g. preconfirmed → settled) is updated in place.
-        if (hasDelta) {
-            const { vtxos: fullVtxos, page: fullPage } = await this.indexerProvider.getVtxos({
-                scripts: deltaScripts,
-            });
-            // Reconciliation is best-effort: if the response is
-            // paginated we don't have a complete picture, so we skip
-            // rather than act on partial data.  Wallets with enough
-            // virtual outputs to exceed a single page rely solely on the
-            // cursor-based delta mechanism for state updates.
-            const fullSetComplete = !fullPage || fullPage.total <= 1;
-            if (fullSetComplete) {
-                const fullOutpoints = new Map(fullVtxos.map((v) => [`${v.txid}:${v.vout}`, v]));
-                const deltaScriptSet = new Set(deltaScripts);
-                const cachedVtxos = await this.walletRepository.getVtxos(address);
-                const reconciledExtended = [];
-                for (const cached of cachedVtxos) {
-                    if (!cached.script ||
-                        !deltaScriptSet.has(cached.script) ||
-                        cached.isSpent) {
-                        continue;
-                    }
-                    const outpoint = `${cached.txid}:${cached.vout}`;
-                    const fresh = fullOutpoints.get(outpoint);
-                    if (!fresh) {
-                        // Server no longer knows about this virtual output —
-                        // it was spent between syncs.
-                        reconciledExtended.push({
-                            ...cached,
-                            isSpent: true,
-                        });
-                        continue;
-                    }
-                    const extended = extendWithScript(fresh);
-                    if (extended &&
-                        extended.virtualStatus.state !==
-                            cached.virtualStatus.state) {
-                        // State transitioned (e.g. preconfirmed →
-                        // settled) — update the cached entry.
-                        reconciledExtended.push(extended);
-                    }
-                }
-                if (reconciledExtended.length > 0) {
-                    console.warn(`[ark-sdk] delta sync: reconciled ${reconciledExtended.length} stale VTXO(s) via full re-fetch`);
-                    await this.walletRepository.saveVtxos(address, reconciledExtended);
-                }
-            }
-            else {
-                console.warn("[ark-sdk] delta sync: skipping reconciliation — full re-fetch was paginated");
-            }
-        }
-        return {
-            isDelta: hasDelta || bootstrapScripts.length === 0,
-            fetchedExtended,
-            address,
-        };
-    }
-    /**
-     * Clear all virtual output sync cursors, forcing a full re-bootstrap on next sync.
+     * Clear the global VTXO sync cursor, forcing a full re-bootstrap on next sync.
      * Useful for recovery after indexer reprocessing or debugging.
      */
-    async clearSyncCursors() {
-        await (0, syncCursors_1.clearSyncCursors)(this.walletRepository);
+    async clearSyncCursor() {
+        await (0, syncCursors_1.clearSyncCursor)(this.walletRepository);
     }
     /**
      * Build a transaction history view for the wallet's boarding address.
@@ -534,6 +379,7 @@ class ReadonlyWallet {
                         createdAt: tx.status.confirmed
                             ? new Date(tx.status.block_time * 1000)
                             : new Date(0),
+                        script: base_1.hex.encode(this.boardingTapscript.pkScript),
                     });
                 }
             }
@@ -623,22 +469,41 @@ class ReadonlyWallet {
                 await this.indexerProvider?.unsubscribeForScripts(subscriptionId);
             };
             // Handle subscription updates asynchronously without blocking.
-            // Note: subscription covers all wallet scripts (default + delegate),
-            // but we can't determine which script each virtual output belongs to from the
-            // subscription event. Virtual outputs are extended with the current offchainTapscript;
-            // this is for notification/display only — not for spending.
-            // For correct extension metadata, use getVtxos() which queries per-script.
+            // Subscription covers all wallet scripts (default + delegate) plus
+            // any additional registered contracts. Virtual outputs carry a
+            // `script` field from the indexer which the contract manager
+            // resolves to the owning contract so the extension uses the
+            // correct forfeit/intent tapscripts.
             (async () => {
                 try {
+                    const cm = await this.getContractManager();
                     for await (const update of subscription) {
-                        if (update.newVtxos?.length > 0 ||
-                            update.spentVtxos?.length > 0) {
+                        if (update.newVtxos?.length === 0 &&
+                            update.spentVtxos?.length === 0) {
+                            continue;
+                        }
+                        // Isolate per-update annotation failures (e.g. a VTXO
+                        // arriving for a contract we haven't registered yet).
+                        // Without this a single bad update would kill the
+                        // for-await loop and silently drop every subsequent
+                        // subscription event for the session.
+                        try {
+                            // Default to `[]` so a one-sided update (e.g.
+                            // only `newVtxos`) doesn't pass `undefined` into
+                            // annotateVtxos and throw on `.length`.
+                            const [newVtxos, spentVtxos] = await Promise.all([
+                                cm.annotateVtxos(update.newVtxos ?? []),
+                                cm.annotateVtxos(update.spentVtxos ?? []),
+                            ]);
                             eventCallback({
                                 type: "vtxo",
-                                newVtxos: update.newVtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this, vtxo)),
-                                spentVtxos: update.spentVtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this, vtxo)),
+                                newVtxos,
+                                spentVtxos,
                             });
                         }
+                        catch (error) {
+                            console.warn("Dropping subscription update after annotation failed; next sync will reconcile:", error);
+                        }
                     }
                 }
                 catch (error) {
@@ -909,11 +774,10 @@ class Wallet extends ReadonlyWallet {
             }
         });
     }
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, 
+    constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, 
     /** @deprecated Use settlementConfig */
     renewalConfig, delegatorProvider, watcherConfig, settlementConfig) {
         super(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegatorProvider, watcherConfig);
-        this.networkName = networkName;
         this.arkProvider = arkProvider;
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
@@ -1033,7 +897,7 @@ class Wallet extends ReadonlyWallet {
         const forfeitPubkey = base_1.hex.decode(setup.info.forfeitPubkey).slice(1);
         const forfeitAddress = (0, btc_signer_1.Address)(setup.network).decode(setup.info.forfeitAddress);
         const forfeitOutputScript = btc_signer_1.OutScript.encode(forfeitAddress);
-        const wallet = new Wallet(config.identity, setup.network, setup.networkName, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig, config.delegatorProvider, config.watcherConfig, config.settlementConfig);
+        const wallet = new Wallet(config.identity, setup.network, setup.onchainProvider, setup.arkProvider, setup.indexerProvider, setup.serverPubKey, setup.offchainTapscript, setup.boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, setup.dustAmount, setup.walletRepository, setup.contractRepository, config.renewalConfig, config.delegatorProvider, config.watcherConfig, config.settlementConfig);
         await wallet.getVtxoManager();
         return wallet;
     }
@@ -1296,7 +1160,7 @@ class Wallet extends ReadonlyWallet {
         const abortController = new AbortController();
         try {
             const stream = this.arkProvider.getEventStream(abortController.signal, topics);
-            const intentId = await this.safeRegisterIntent(intent);
+            const intentId = await this.safeRegisterIntent(intent, params.inputs);
             const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
             const commitmentTxid = await batch_1.Batch.join(stream, handler, {
                 abortController,
@@ -1309,8 +1173,16 @@ class Wallet extends ReadonlyWallet {
             return commitmentTxid;
         }
         catch (error) {
-            // delete the intent to not be stuck in the queue
-            await this.arkProvider.deleteIntent(deleteIntent).catch(() => { });
+            // delete the intent to not be stuck in the queue. If deletion fails
+            // the intent stays on the server and the next settle will hit
+            // "duplicated input" in safeRegisterIntent — surface the failure
+            // rather than silently swallowing it.
+            const inputIds = params.inputs
+                .map((i) => `${i.txid}:${i.vout}`)
+                .join(",");
+            await this.arkProvider.deleteIntent(deleteIntent).catch((e) => {
+                console.warn(`Failed to delete intent after settle failure for inputs [${inputIds}]; intent may linger on server and cause 'duplicated input' on next settle`, e);
+            });
             throw error;
         }
         finally {
@@ -1500,7 +1372,7 @@ class Wallet extends ReadonlyWallet {
             },
         };
     }
-    async safeRegisterIntent(intent) {
+    async safeRegisterIntent(intent, inputs) {
         try {
             return await this.arkProvider.registerIntent(intent);
         }
@@ -1509,11 +1381,13 @@ class Wallet extends ReadonlyWallet {
             if (error instanceof errors_1.ArkError &&
                 error.code === 0 &&
                 error.message.includes("duplicated input")) {
-                // delete all intents spending one of the wallet coins
-                const allSpendableCoins = await this.getVtxos({
-                    withRecoverable: true,
-                });
-                const deleteIntent = await this.makeDeleteIntentSignature(allSpendableCoins);
+                // Clear any queued intent spending these exact inputs. The
+                // previous implementation signed a proof over getVtxos() only,
+                // which misses boarding UTXOs — the most common trigger for
+                // "duplicated input" on the auto-settle path. Signing the
+                // caller's own inputs keeps the proof surgical and correct
+                // regardless of whether the stuck input is a VTXO or boarding.
+                const deleteIntent = await this.makeDeleteIntentSignature(inputs);
                 await this.arkProvider.deleteIntent(deleteIntent);
                 // try again
                 return this.arkProvider.registerIntent(intent);
@@ -1581,9 +1455,7 @@ class Wallet extends ReadonlyWallet {
                 scripts: allScripts,
             });
             for (const vtxo of fetchedVtxos) {
-                const vtxoScript = vtxo.script
-                    ? scriptMap.get(vtxo.script)
-                    : undefined;
+                const vtxoScript = scriptMap.get(vtxo.script);
                 if (!vtxoScript)
                     continue;
                 if (vtxo.virtualStatus.state === "swept" ||
@@ -1886,8 +1758,9 @@ class Wallet extends ReadonlyWallet {
                 console.warn(`updateDbAfterOffchainTx: inputs length (${inputs.length}) differs from signedCheckpointTxs length (${signedCheckpointTxs.length})`);
             }
             const safeLength = Math.min(inputs.length, signedCheckpointTxs.length);
-            for (const [inputIndex, input] of inputs.entries()) {
-                const vtxo = (0, utils_1.extendVirtualCoin)(this, input);
+            const cm = await this.getContractManager();
+            const annotatedInputs = await cm.annotateVtxos(inputs);
+            for (const [inputIndex, vtxo] of annotatedInputs.entries()) {
                 if (inputIndex < safeLength &&
                     signedCheckpointTxs[inputIndex]) {
                     const checkpoint = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(signedCheckpointTxs[inputIndex]));
@@ -1947,6 +1820,7 @@ class Wallet extends ReadonlyWallet {
                         confirmed: false,
                     },
                     assets: changeAssets,
+                    script: base_1.hex.encode(this.offchainTapscript.pkScript),
                 };
             }
             await this.walletRepository.saveVtxos(addr, changeVtxo ? [...spentVtxos, changeVtxo] : spentVtxos);
@@ -1977,10 +1851,14 @@ class Wallet extends ReadonlyWallet {
             const inputArkTxIds = new Set();
             const boardingUtxoToRemove = new Set();
             const isVtxo = (input) => "virtualStatus" in input;
+            const vtxoInputs = inputs.filter(isVtxo);
+            const cm = await this.getContractManager();
+            const annotatedVtxos = await cm.annotateVtxos(vtxoInputs);
+            const annotatedByKey = new Map(annotatedVtxos.map((v) => [`${v.txid}:${v.vout}`, v]));
             for (const input of inputs) {
                 if (isVtxo(input)) {
                     // virtual output = mark it settled
-                    const vtxo = (0, utils_1.extendVirtualCoin)(this, input);
+                    const vtxo = annotatedByKey.get(`${input.txid}:${input.vout}`);
                     if (vtxo.arkTxId) {
                         inputArkTxIds.add(vtxo.arkTxId);
                     }
@@ -2067,7 +1945,7 @@ function selectVirtualCoins(coins, targetAmount) {
  */
 async function waitForIncomingFunds(wallet) {
     let stopFunc;
-    const promise = new Promise((resolve) => {
+    return new Promise((resolve) => {
         wallet
             .notifyIncomingFunds((coins) => {
             resolve(coins);
@@ -2078,5 +1956,4 @@ async function waitForIncomingFunds(wallet) {
             stopFunc = stop;
         });
     });
-    return promise;
 }