@arkade-os/sdk 0.4.17 → 0.4.19

package/dist/esm/wallet/wallet.js

@@ -12,7 +12,7 @@ import { validateConnectorsTxGraph, validateVtxoTxGraph, } from '../tree/validat
 import { validateBatchRecipients } from './validation.js';
 import { isBatchSignable } from '../identity/index.js';
 import { isExpired, isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
-import { createAssetPacket, selectedCoinsToAssetInputs, selectCoinsWithAsset, } from './asset.js';
+import { createAssetPacket, selectCoinsWithAsset, selectedCoinsToAssetInputs, } from './asset.js';
 import { VtxoScript } from '../script/base.js';
 import { CSVMultisigTapscript } from '../script/tapscript.js';
 import { buildOffchainTx, combineTapscriptSigs, hasBoardingTxExpired, isValidArkAddress, } from '../utils/arkTransaction.js';
@@ -20,7 +20,7 @@ import { DEFAULT_RENEWAL_CONFIG, DEFAULT_SETTLEMENT_CONFIG, VtxoManager, } from
 import { ArkNote } from '../arknote/index.js';
 import { Intent } from '../intent/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
-import { extendCoin, extendVirtualCoin, validateRecipients } from './utils.js';
+import { extendCoin, validateRecipients } from './utils.js';
 import { ArkError } from '../providers/errors.js';
 import { Batch } from './batch.js';
 import { Estimator } from '../arkfee/index.js';
@@ -33,7 +33,7 @@ import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../repo
 import { ContractManager } from '../contracts/contractManager.js';
 import { contractHandlers } from '../contracts/handlers/index.js';
 import { timelockToSequence } from '../contracts/handlers/helpers.js';
-import { advanceSyncCursors, clearSyncCursors, computeSyncWindow, cursorCutoff, getAllSyncCursors, updateWalletState, } from '../utils/syncCursors.js';
+import { clearSyncCursor, updateWalletState } from '../utils/syncCursors.js';
 // Hardcoded unilateral exit delay for mainnet (~7 days in seconds).
 // Pinned here so that address derivation stays stable for existing mainnet
 // wallets even after the server lowers the delay it advertises.
@@ -63,6 +63,12 @@ export class ReadonlyWallet {
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
         this.delegatorProvider = delegatorProvider;
+        // Outpoints ("txid:vout") committed to an in-flight settle/send. Filtered
+        // from getVtxos() so concurrent callers (UI, VtxoManager auto-renewal,
+        // another send/settle racing the _txLock) can't reselect coins that are
+        // already on their way out. The set is in-memory only: a process crash
+        // clears it, and a stale entry only hides a VTXO (never spends one).
+        this._pendingSpendOutpoints = new Set();
         // Guard: detect identity/server network mismatch for descriptor-based identities.
         // This duplicates the check in setupWalletConfig() so that subclasses
         // bypassing the factory still get the safety net.
@@ -299,8 +305,13 @@ export 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 (this._pendingSpendOutpoints.has(`${vtxo.txid}:${vtxo.vout}`)) {
+                return false;
+            }
             if (isSpendable(vtxo)) {
                 if (!f.withRecoverable &&
                     (isRecoverable(vtxo) || isExpired(vtxo))) {
@@ -309,17 +320,15 @@ export 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 }] })
@@ -327,166 +336,11 @@ export class ReadonlyWallet {
         return 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(),
-            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 = 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 = cursorCutoff(requestStartedAt);
-        await this.walletRepository.saveVtxos(address, fetchedExtended);
-        await 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 clearSyncCursors(this.walletRepository);
+    async clearSyncCursor() {
+        await clearSyncCursor(this.walletRepository);
     }
     /**
      * Build a transaction history view for the wallet's boarding address.
@@ -529,6 +383,7 @@ export class ReadonlyWallet {
                         createdAt: tx.status.confirmed
                             ? new Date(tx.status.block_time * 1000)
                             : new Date(0),
+                        script: hex.encode(this.boardingTapscript.pkScript),
                     });
                 }
             }
@@ -618,22 +473,41 @@ export 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) => extendVirtualCoin(this, vtxo)),
-                                spentVtxos: update.spentVtxos.map((vtxo) => extendVirtualCoin(this, vtxo)),
+                                newVtxos,
+                                spentVtxos,
                             });
                         }
+                        catch (error) {
+                            console.warn("Dropping subscription update after annotation failed; next sync will reconcile:", error);
+                        }
                     }
                 }
                 catch (error) {
@@ -889,6 +763,20 @@ export class ReadonlyWallet {
  * ```
  */
 export class Wallet extends ReadonlyWallet {
+    _addPendingSpends(inputs) {
+        for (const input of inputs) {
+            if ("virtualStatus" in input) {
+                this._pendingSpendOutpoints.add(`${input.txid}:${input.vout}`);
+            }
+        }
+    }
+    _removePendingSpends(inputs) {
+        for (const input of inputs) {
+            if ("virtualStatus" in input) {
+                this._pendingSpendOutpoints.delete(`${input.txid}:${input.vout}`);
+            }
+        }
+    }
     _withTxLock(fn) {
         let release;
         const lock = new Promise((r) => (release = r));
@@ -903,11 +791,10 @@ export 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;
@@ -1027,7 +914,7 @@ export class Wallet extends ReadonlyWallet {
         const forfeitPubkey = hex.decode(setup.info.forfeitPubkey).slice(1);
         const forfeitAddress = Address(setup.network).decode(setup.info.forfeitAddress);
         const forfeitOutputScript = 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;
     }
@@ -1105,9 +992,15 @@ export class Wallet extends ReadonlyWallet {
                         amount: BigInt(selected.changeAmount),
                     });
                 }
-                const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selected.inputs, outputs);
-                await this.updateDbAfterOffchainTx(selected.inputs, arkTxid, signedCheckpointTxs, params.amount, selected.changeAmount, selected.changeAmount > 0n ? outputs.length - 1 : 0);
-                return arkTxid;
+                this._addPendingSpends(selected.inputs);
+                try {
+                    const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selected.inputs, outputs);
+                    await this.updateDbAfterOffchainTx(selected.inputs, arkTxid, signedCheckpointTxs, params.amount, selected.changeAmount, selected.changeAmount > 0n ? outputs.length - 1 : 0);
+                    return arkTxid;
+                }
+                finally {
+                    this._removePendingSpends(selected.inputs);
+                }
             });
         }
         return this.send({
@@ -1153,7 +1046,8 @@ export class Wallet extends ReadonlyWallet {
                 const tip = await this.onchainProvider.getChainTip();
                 chainTipHeight = tip.height;
             }
-            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !hasBoardingTxExpired(utxo, boardingTimelock, chainTipHeight));
+            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => utxo.status.confirmed &&
+                !hasBoardingTxExpired(utxo, boardingTimelock, chainTipHeight));
             const filteredBoardingUtxos = [];
             for (const utxo of boardingUtxos) {
                 const inputFee = estimator.evalOnchainInput({
@@ -1288,11 +1182,29 @@ export class Wallet extends ReadonlyWallet {
             ...params.inputs.map((input) => `${input.txid}:${input.vout}`),
         ];
         const abortController = new AbortController();
+        let stream;
+        // Optimistically hide these inputs from concurrent getVtxos() callers
+        // while the settlement is in flight. Set before safeRegisterIntent so
+        // there's no window between intent registration and coin-visibility.
+        this._addPendingSpends(params.inputs);
         try {
-            const stream = this.arkProvider.getEventStream(abortController.signal, topics);
-            const intentId = await this.safeRegisterIntent(intent);
+            stream = this.arkProvider.getEventStream(abortController.signal, topics);
+            // Prime the iterator so the provider opens the SSE subscription
+            // before safeRegisterIntent can trigger server-side batch events.
+            const firstNext = stream.next();
+            // If settle exits before Batch.join consumes the primed result,
+            // keep the orphaned promise from surfacing as an unhandled rejection.
+            void firstNext.catch(() => { });
+            const primedStream = (async function* () {
+                const first = await firstNext;
+                if (!first.done) {
+                    yield first.value;
+                }
+                yield* stream;
+            })();
+            const intentId = await this.safeRegisterIntent(intent, params.inputs);
             const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
-            const commitmentTxid = await Batch.join(stream, handler, {
+            const commitmentTxid = await Batch.join(primedStream, handler, {
                 abortController,
                 skipVtxoTreeSigning: !hasOffchainOutputs,
                 eventCallback: eventCallback
@@ -1303,28 +1215,41 @@ export 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 {
-            // close the stream
+            // Clear state first so a synchronous handler firing from abort()
+            // never observes a stale pending-spend set.
+            this._removePendingSpends(params.inputs);
+            // close the stream — abort() fires the in-body handler if the
+            // generator has started iterating; return() also releases the
+            // eager resource if the body is still suspended or never ran
+            // (e.g. safeRegisterIntent threw before Batch.join was called).
             abortController.abort();
+            await stream?.return?.().catch(() => { });
         }
     }
     async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
         // the signed forfeits transactions to submit
         const signedForfeits = [];
-        const vtxos = await this.getVtxos();
+        const isVtxo = (input) => "virtualStatus" in input;
         let settlementPsbt = Transaction.fromPSBT(base64.decode(event.commitmentTx));
         let hasBoardingUtxos = false;
         let connectorIndex = 0;
         const connectorsLeaves = connectorsGraph?.leaves() || [];
         for (const input of inputs) {
-            // check if the input is an offchain "virtual" coin
-            const vtxo = vtxos.find((vtxo) => vtxo.txid === input.txid && vtxo.vout === input.vout);
             // boarding input, we need to sign the settlement tx
-            if (!vtxo) {
+            if (!isVtxo(input)) {
                 for (let i = 0; i < settlementPsbt.inputsLength; i++) {
                     const settlementInput = settlementPsbt.getInput(i);
                     if (!settlementInput.txid ||
@@ -1348,7 +1273,7 @@ export class Wallet extends ReadonlyWallet {
                 }
                 continue;
             }
-            if (isRecoverable(vtxo) || isSubdust(vtxo, this.dustAmount)) {
+            if (isRecoverable(input) || isSubdust(input, this.dustAmount)) {
                 // recoverable or subdust coin, we don't need to create a forfeit tx
                 continue;
             }
@@ -1375,7 +1300,7 @@ export class Wallet extends ReadonlyWallet {
                     txid: input.txid,
                     index: input.vout,
                     witnessUtxo: {
-                        amount: BigInt(vtxo.value),
+                        amount: BigInt(input.value),
                         script: VtxoScript.decode(input.tapTree).pkScript,
                     },
                     sighashType: SigHash.DEFAULT,
@@ -1494,7 +1419,7 @@ export class Wallet extends ReadonlyWallet {
             },
         };
     }
-    async safeRegisterIntent(intent) {
+    async safeRegisterIntent(intent, inputs) {
         try {
             return await this.arkProvider.registerIntent(intent);
         }
@@ -1503,11 +1428,13 @@ export class Wallet extends ReadonlyWallet {
             if (error instanceof 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);
@@ -1575,9 +1502,7 @@ export 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" ||
@@ -1804,9 +1729,17 @@ export class Wallet extends ReadonlyWallet {
             outputs.push(Extension.create([assetPacket]).txOut());
         }
         const sentAmount = recipients.reduce((sum, r) => sum + r.amount, 0);
-        const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selectedCoins, outputs);
-        await this.updateDbAfterOffchainTx(selectedCoins, arkTxid, signedCheckpointTxs, sentAmount, BigInt(changeAmount), changeReceiver ? changeIndex : 0, changeReceiver?.assets);
-        return arkTxid;
+        // Optimistically hide selected coins from concurrent getVtxos() while
+        // the offchain tx is in flight.
+        this._addPendingSpends(selectedCoins);
+        try {
+            const { arkTxid, signedCheckpointTxs } = await this.buildAndSubmitOffchainTx(selectedCoins, outputs);
+            await this.updateDbAfterOffchainTx(selectedCoins, arkTxid, signedCheckpointTxs, sentAmount, BigInt(changeAmount), changeReceiver ? changeIndex : 0, changeReceiver?.assets);
+            return arkTxid;
+        }
+        finally {
+            this._removePendingSpends(selectedCoins);
+        }
     }
     /**
      * Build an offchain transaction from the given inputs and outputs,
@@ -1880,8 +1813,9 @@ export 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 = 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 = Transaction.fromPSBT(base64.decode(signedCheckpointTxs[inputIndex]));
@@ -1941,6 +1875,7 @@ export class Wallet extends ReadonlyWallet {
                         confirmed: false,
                     },
                     assets: changeAssets,
+                    script: hex.encode(this.offchainTapscript.pkScript),
                 };
             }
             await this.walletRepository.saveVtxos(addr, changeVtxo ? [...spentVtxos, changeVtxo] : spentVtxos);
@@ -1971,10 +1906,14 @@ export 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 = extendVirtualCoin(this, input);
+                    const vtxo = annotatedByKey.get(`${input.txid}:${input.vout}`);
                     if (vtxo.arkTxId) {
                         inputArkTxIds.add(vtxo.arkTxId);
                     }
@@ -2060,7 +1999,7 @@ export function selectVirtualCoins(coins, targetAmount) {
  */
 export async function waitForIncomingFunds(wallet) {
     let stopFunc;
-    const promise = new Promise((resolve) => {
+    return new Promise((resolve) => {
         wallet
             .notifyIncomingFunds((coins) => {
             resolve(coins);
@@ -2071,5 +2010,4 @@ export async function waitForIncomingFunds(wallet) {
             stopFunc = stop;
         });
     });
-    return promise;
 }

package/dist/esm/worker/expo/processors/contractPollProcessor.js

@@ -5,27 +5,24 @@ export const CONTRACT_POLL_TASK_TYPE = "contract-poll";
  *
  * Replicates the polling subset of @see ContractManager.initialize:
  * 1. Load all contracts from the contract repository.
- * 2. Mark expired active contracts as inactive.
- * 3. Paginated fetch of spendable VTXOs from the indexer.
- * 4. Extend each VTXO with tapscript data.
- * 5. Save to the wallet repository.
+ * 2. Paginated fetch of every VTXO (including spent) from the indexer.
+ * 3. Extend each VTXO with tapscript data.
+ * 4. Save to the wallet repository.
+ *
+ * NOTE: the indexer query deliberately omits `spendableOnly`. Every
+ * repository implements `saveVtxos` as an upsert with no batch delete,
+ * so filtering to spendable-only would leave VTXOs that became spent
+ * between polls marked as spendable forever. Fetching the full set lets
+ * the upsert overwrite stale records with their latest state.
  */
 export const contractPollProcessor = {
     taskType: CONTRACT_POLL_TASK_TYPE,
     async execute(item, deps) {
         const { contractRepository, walletRepository, indexerProvider, extendVtxo, } = deps;
         const contracts = await contractRepository.getContracts();
-        const now = Date.now();
         let contractsProcessed = 0;
         let vtxosSaved = 0;
         for (const contract of contracts) {
-            // Mark expired active contracts as inactive
-            if (contract.state === "active" &&
-                contract.expiresAt &&
-                contract.expiresAt <= now) {
-                contract.state = "inactive";
-                await contractRepository.saveContract(contract);
-            }
             // Paginated fetch of spendable virtual outputs
             const pageSize = 100;
             let pageIndex = 0;
@@ -34,7 +31,6 @@ export const contractPollProcessor = {
             while (hasMore) {
                 const { vtxos, page } = await indexerProvider.getVtxos({
                     scripts: [contract.script],
-                    spendableOnly: true,
                     pageIndex,
                     pageSize,
                 });

package/dist/esm/worker/expo/taskRunner.js

@@ -1,4 +1,4 @@
-import { getRandomId, extendVirtualCoin, extendVtxoFromContract, } from '../../wallet/utils.js';
+import { getRandomId, extendVirtualCoinForContract } from '../../wallet/utils.js';
 /**
  * Run all pending tasks from the queue through matching processors.
  *
@@ -62,17 +62,8 @@ export async function runTasks(queue, processors, deps) {
  * can build deps without depending on Expo.
  */
 export function createTaskDependencies(options) {
-    const { walletRepository, contractRepository, indexerProvider, arkProvider, offchainTapscript, } = options;
     return {
-        walletRepository,
-        contractRepository,
-        indexerProvider,
-        arkProvider,
-        extendVtxo: (vtxo, contract) => {
-            if (contract) {
-                return extendVtxoFromContract(vtxo, contract);
-            }
-            return extendVirtualCoin({ offchainTapscript }, vtxo);
-        },
+        ...options,
+        extendVtxo: (vtxo, contract) => extendVirtualCoinForContract(vtxo, contract),
     };
 }