@arkade-os/sdk 0.4.8 → 0.4.10

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -1,6 +1,7 @@
 import { RestIndexerProvider } from '../../providers/indexer.js';
 import { isExpired, isRecoverable, isSpendable, isSubdust, } from '../index.js';
 import { extendCoin, extendVirtualCoin } from '../utils.js';
+import { buildTransactionHistory } from '../../utils/transactionHistory.js';
 export class WalletNotInitializedError extends Error {
     constructor() {
         super("Wallet handler not initialized");
@@ -169,7 +170,8 @@ export class WalletMessageHandler {
                     });
                 }
                 case "GET_TRANSACTION_HISTORY": {
-                    const transactions = await this.readonlyWallet.getTransactionHistory();
+                    const allVtxos = await this.getVtxosFromRepo();
+                    const transactions = (await this.buildTransactionHistoryFromCache(allVtxos)) ?? [];
                     return this.tagged({
                         id,
                         type: "TRANSACTION_HISTORY",
@@ -196,7 +198,7 @@ export class WalletMessageHandler {
                     });
                 }
                 case "RELOAD_WALLET": {
-                    await this.onWalletInitialized();
+                    await this.reloadWallet();
                     return this.tagged({
                         id,
                         type: "RELOAD_SUCCESS",
@@ -282,6 +284,14 @@ export class WalletMessageHandler {
                         payload: { isWatching },
                     });
                 }
+                case "REFRESH_VTXOS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    await manager.refreshVtxos();
+                    return this.tagged({
+                        id,
+                        type: "REFRESH_VTXOS_SUCCESS",
+                    });
+                }
                 case "SEND": {
                     const { recipients } = message.payload;
                     const txid = await this.wallet.send(...recipients);
@@ -438,10 +448,9 @@ export class WalletMessageHandler {
         await this.onWalletInitialized();
     }
     async handleGetBalance() {
-        const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
+        const [boardingUtxos, allVtxos] = await Promise.all([
             this.getAllBoardingUtxos(),
-            this.getSpendableVtxos(),
-            this.getSweptVtxos(),
+            this.getVtxosFromRepo(),
         ]);
         // boarding
         let confirmed = 0;
@@ -454,7 +463,9 @@ export class WalletMessageHandler {
                 unconfirmed += utxo.value;
             }
         }
-        // offchain
+        // offchain — split spendable vs swept from single repo read
+        const spendableVtxos = allVtxos.filter(isSpendable);
+        const sweptVtxos = allVtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
         let settled = 0;
         let preconfirmed = 0;
         let recoverable = 0;
@@ -504,23 +515,12 @@ export class WalletMessageHandler {
         return this.readonlyWallet.getBoardingUtxos();
     }
     /**
-     * Get spendable vtxos for the current wallet address
+     * Get spendable vtxos from the repository
      */
     async getSpendableVtxos() {
-        if (!this.readonlyWallet)
-            return [];
-        const vtxos = await this.readonlyWallet.getVtxos();
+        const vtxos = await this.getVtxosFromRepo();
         return vtxos.filter(isSpendable);
     }
-    /**
-     * Get swept vtxos for the current wallet address
-     */
-    async getSweptVtxos() {
-        if (!this.readonlyWallet)
-            return [];
-        const vtxos = await this.readonlyWallet.getVtxos();
-        return vtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
-    }
     async onWalletInitialized() {
         if (!this.readonlyWallet ||
             !this.arkProvider ||
@@ -528,10 +528,11 @@ export class WalletMessageHandler {
             !this.walletRepository) {
             return;
         }
-        // Get all wallet scripts (current + historical delegate/non-delegate)
-        const scripts = await this.readonlyWallet.getWalletScripts();
-        const response = await this.indexerProvider.getVtxos({ scripts });
-        const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.readonlyWallet, vtxo));
+        // Initialize contract manager FIRST — this populates the repository
+        // with full VTXO history for all contracts (one indexer call per contract)
+        await this.ensureContractEventBroadcasting();
+        // Read VTXOs from repository (now populated by contract manager)
+        const vtxos = await this.getVtxosFromRepo();
         if (this.wallet) {
             try {
                 // recover pending transactions if possible
@@ -543,15 +544,13 @@ export class WalletMessageHandler {
                 console.error("Error recovering pending transactions:", error);
             }
         }
-        // Get wallet address and save vtxos using unified repository
-        const address = await this.readonlyWallet.getAddress();
-        await this.walletRepository.saveVtxos(address, vtxos);
         // Fetch boarding utxos and save using unified repository
         const boardingAddress = await this.readonlyWallet.getBoardingAddress();
         const coins = await this.readonlyWallet.onchainProvider.getCoins(boardingAddress);
         await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.readonlyWallet, utxo)));
-        // Get transaction history to cache boarding txs
-        const txs = await this.readonlyWallet.getTransactionHistory();
+        // Build transaction history from cached VTXOs (no indexer call)
+        const address = await this.readonlyWallet.getAddress();
+        const txs = await this.buildTransactionHistoryFromCache(vtxos);
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
         // unsubscribe previous subscription if any
@@ -596,7 +595,6 @@ export class WalletMessageHandler {
                     }));
                 }
             });
-        await this.ensureContractEventBroadcasting();
         // Eagerly start the VtxoManager so its background tasks (auto-renewal,
         // boarding UTXO polling/sweep) run inside the service worker without
         // waiting for a client to send a vtxo-manager message first.
@@ -609,6 +607,17 @@ export class WalletMessageHandler {
             }
         }
     }
+    /**
+     * Force a full VTXO refresh from the indexer, then re-run bootstrap.
+     * Used by RELOAD_WALLET to ensure fresh data.
+     */
+    async reloadWallet() {
+        if (!this.readonlyWallet)
+            return;
+        const manager = await this.readonlyWallet.getContractManager();
+        await manager.refreshVtxos();
+        await this.onWalletInitialized();
+    }
     async handleSettle(message) {
         const wallet = this.requireWallet();
         const txid = await wallet.settle(message.payload.params, (e) => {
@@ -732,6 +741,77 @@ export class WalletMessageHandler {
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
     }
+    /**
+     * Read all VTXOs from the repository, aggregated across all contract
+     * addresses and the wallet's primary address, with deduplication.
+     */
+    async getVtxosFromRepo() {
+        if (!this.walletRepository || !this.readonlyWallet)
+            return [];
+        const seen = new Set();
+        const allVtxos = [];
+        const addVtxos = (vtxos) => {
+            for (const vtxo of vtxos) {
+                const key = `${vtxo.txid}:${vtxo.vout}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allVtxos.push(vtxo);
+                }
+            }
+        };
+        // Aggregate VTXOs from all contract addresses
+        const manager = await this.readonlyWallet.getContractManager();
+        const contracts = await manager.getContracts();
+        for (const contract of contracts) {
+            const vtxos = await this.walletRepository.getVtxos(contract.address);
+            addVtxos(vtxos);
+        }
+        // Also check the wallet's primary address
+        const walletAddress = await this.readonlyWallet.getAddress();
+        const walletVtxos = await this.walletRepository.getVtxos(walletAddress);
+        addVtxos(walletVtxos);
+        return allVtxos;
+    }
+    /**
+     * Build transaction history from cached VTXOs without hitting the indexer.
+     * Falls back to indexer only for uncached transaction timestamps.
+     */
+    async buildTransactionHistoryFromCache(vtxos) {
+        if (!this.readonlyWallet)
+            return null;
+        const { boardingTxs, commitmentsToIgnore } = await this.readonlyWallet.getBoardingTxs();
+        // Build a lookup for cached VTXO timestamps, keyed by txid.
+        // Multiple VTXOs can share a txid (different vouts) — we keep the
+        // earliest createdAt so the history ordering is stable.
+        const vtxoCreatedAt = new Map();
+        for (const vtxo of vtxos) {
+            const existing = vtxoCreatedAt.get(vtxo.txid);
+            const ts = vtxo.createdAt.getTime();
+            if (existing === undefined || ts < existing) {
+                vtxoCreatedAt.set(vtxo.txid, ts);
+            }
+        }
+        // getTxCreatedAt resolves the creation timestamp of a transaction.
+        // buildTransactionHistory calls this for spent-offchain VTXOs with
+        // no change outputs to determine the time of the sending tx.
+        // Returns undefined on miss so buildTransactionHistory uses its
+        // own fallback (vtxo.createdAt + 1) rather than epoch 0.
+        // The vout:0 lookup in the indexer fallback mirrors the pre-existing
+        // convention in ReadonlyWallet.getTransactionHistory().
+        const getTxCreatedAt = async (txid) => {
+            const cached = vtxoCreatedAt.get(txid);
+            if (cached !== undefined)
+                return cached;
+            if (this.indexerProvider) {
+                const res = await this.indexerProvider.getVtxos({
+                    outpoints: [{ txid, vout: 0 }],
+                });
+                return res.vtxos[0]?.createdAt.getTime();
+            }
+            return undefined;
+        };
+        return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
+    }
     async ensureContractEventBroadcasting() {
         if (!this.readonlyWallet)
             return;

package/dist/esm/wallet/serviceWorker/wallet.js

@@ -3,12 +3,13 @@ import { setupServiceWorker } from '../../worker/browser/utils.js';
 import { IndexedDBContractRepository, IndexedDBWalletRepository, } from '../../repositories/index.js';
 import { DEFAULT_MESSAGE_TAG, } from './wallet-message-handler.js';
 import { getRandomId } from '../utils.js';
-import { ServiceWorkerTimeoutError } from '../../worker/errors.js';
-// Check by error name instead of instanceof because postMessage uses the
+import { MESSAGE_BUS_NOT_INITIALIZED, ServiceWorkerTimeoutError, } from '../../worker/errors.js';
+// Check by error message content instead of instanceof because postMessage uses the
 // structured clone algorithm which strips the prototype chain — the page
 // receives a plain Error, not the original MessageBusNotInitializedError.
 function isMessageBusNotInitializedError(error) {
-    return (error instanceof Error && error.name === "MessageBusNotInitializedError");
+    return (error instanceof Error &&
+        error.message.includes(MESSAGE_BUS_NOT_INITIALIZED));
 }
 const DEDUPABLE_REQUEST_TYPES = new Set([
     "GET_ADDRESS",
@@ -158,7 +159,10 @@ export class ServiceWorkerReadonlyWallet {
                 publicKey: initConfig.arkServerPublicKey,
             },
             delegatorUrl: initConfig.delegatorUrl,
+            indexerUrl: options.indexerUrl,
+            esploraUrl: options.esploraUrl,
             timeoutMs: options.messageBusTimeoutMs,
+            watcherConfig: options.watcherConfig,
         }, options.messageBusTimeoutMs);
         // Initialize the wallet handler
         const initMessage = {
@@ -175,6 +179,9 @@ export class ServiceWorkerReadonlyWallet {
                 publicKey: initConfig.arkServerPublicKey,
             },
             delegatorUrl: initConfig.delegatorUrl,
+            indexerUrl: options.indexerUrl,
+            esploraUrl: options.esploraUrl,
+            watcherConfig: options.watcherConfig,
         };
         wallet.initWalletPayload = initConfig;
         wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
@@ -675,6 +682,14 @@ export class ServiceWorkerReadonlyWallet {
                     navigator.serviceWorker.removeEventListener("message", messageHandler);
                 };
             },
+            async refreshVtxos() {
+                const message = {
+                    type: "REFRESH_VTXOS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                };
+                await sendContractMessage(message);
+            },
             async isWatching() {
                 const message = {
                     type: "IS_CONTRACT_MANAGER_WATCHING",
@@ -744,7 +759,11 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
                 publicKey: initConfig.arkServerPublicKey,
             },
             delegatorUrl: initConfig.delegatorUrl,
+            indexerUrl: options.indexerUrl,
+            esploraUrl: options.esploraUrl,
             timeoutMs: options.messageBusTimeoutMs,
+            settlementConfig: options.settlementConfig,
+            watcherConfig: options.watcherConfig,
         }, options.messageBusTimeoutMs);
         // Initialize the service worker with the config
         const initMessage = {
@@ -762,6 +781,10 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
                 publicKey: initConfig.arkServerPublicKey,
             },
             delegatorUrl: initConfig.delegatorUrl,
+            indexerUrl: options.indexerUrl,
+            esploraUrl: options.esploraUrl,
+            settlementConfig: options.settlementConfig,
+            watcherConfig: options.watcherConfig,
         };
         wallet.initWalletPayload = initConfig;
         wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;

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

@@ -152,7 +152,12 @@ export class VtxoManager {
         this.knownBoardingUtxos = new Set();
         this.sweptBoardingUtxos = new Set();
         this.pollInProgress = false;
+        this.disposed = false;
         this.consecutivePollFailures = 0;
+        // Guards against renewal feedback loop: when renewVtxos() settles, the
+        // server emits new VTXOs → vtxo_received → renewVtxos() again → infinite loop.
+        this.renewalInProgress = false;
+        this.lastRenewalTimestamp = 0;
         // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
         if (settlementConfig !== undefined) {
             this.settlementConfig = settlementConfig;
@@ -336,32 +341,43 @@ export class VtxoManager {
      * ```
      */
     async renewVtxos(eventCallback) {
-        // Get all VTXOs (including recoverable ones)
-        // Use default threshold to bypass settlementConfig gate (manual API should always work)
-        const vtxos = await this.getExpiringVtxos(this.settlementConfig !== false &&
-            this.settlementConfig?.vtxoThreshold !== undefined
-            ? this.settlementConfig.vtxoThreshold * 1000
-            : DEFAULT_RENEWAL_CONFIG.thresholdMs);
-        if (vtxos.length === 0) {
-            throw new Error("No VTXOs available to renew");
-        }
-        const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
-        // Get dust amount from wallet
-        const dustAmount = getDustAmount(this.wallet);
-        // Check if total amount is above dust threshold
-        if (BigInt(totalAmount) < dustAmount) {
-            throw new Error(`Total amount ${totalAmount} is below dust threshold ${dustAmount}`);
+        if (this.renewalInProgress) {
+            throw new Error("Renewal already in progress");
+        }
+        this.renewalInProgress = true;
+        try {
+            // Get all VTXOs (including recoverable ones)
+            // Use default threshold to bypass settlementConfig gate (manual API should always work)
+            const vtxos = await this.getExpiringVtxos(this.settlementConfig !== false &&
+                this.settlementConfig?.vtxoThreshold !== undefined
+                ? this.settlementConfig.vtxoThreshold * 1000
+                : DEFAULT_RENEWAL_CONFIG.thresholdMs);
+            if (vtxos.length === 0) {
+                throw new Error("No VTXOs available to renew");
+            }
+            const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+            // Get dust amount from wallet
+            const dustAmount = getDustAmount(this.wallet);
+            // Check if total amount is above dust threshold
+            if (BigInt(totalAmount) < dustAmount) {
+                throw new Error(`Total amount ${totalAmount} is below dust threshold ${dustAmount}`);
+            }
+            const arkAddress = await this.wallet.getAddress();
+            const txid = await this.wallet.settle({
+                inputs: vtxos,
+                outputs: [
+                    {
+                        address: arkAddress,
+                        amount: BigInt(totalAmount),
+                    },
+                ],
+            }, eventCallback);
+            this.lastRenewalTimestamp = Date.now();
+            return txid;
+        }
+        finally {
+            this.renewalInProgress = false;
         }
-        const arkAddress = await this.wallet.getAddress();
-        return this.wallet.settle({
-            inputs: vtxos,
-            outputs: [
-                {
-                    address: arkAddress,
-                    amount: BigInt(totalAmount),
-                },
-            ],
-        }, eventCallback);
     }
     // ========== Boarding UTXO Sweep Methods ==========
     /**
@@ -529,7 +545,11 @@ export class VtxoManager {
         }
         // Start polling for boarding UTXOs independently of contract manager
         // SSE setup. Use a short delay to let the wallet finish construction.
-        setTimeout(() => this.startBoardingUtxoPoll(), 1000);
+        this.startupPollTimeoutId = setTimeout(() => {
+            if (this.disposed)
+                return;
+            this.startBoardingUtxoPoll();
+        }, 1000);
         try {
             const [delegatorManager, contractManager, destination] = await Promise.all([
                 this.wallet.getDelegatorManager(),
@@ -540,28 +560,33 @@ export class VtxoManager {
                 if (event.type !== "vtxo_received") {
                     return;
                 }
-                this.renewVtxos().catch((e) => {
-                    if (e instanceof Error) {
-                        if (e.message.includes("No VTXOs available to renew")) {
-                            // Not an error, just no VTXO eligible for renewal.
-                            return;
+                const msSinceLastRenewal = Date.now() - this.lastRenewalTimestamp;
+                const shouldRenew = !this.renewalInProgress &&
+                    msSinceLastRenewal >= VtxoManager.RENEWAL_COOLDOWN_MS;
+                if (shouldRenew) {
+                    this.renewVtxos().catch((e) => {
+                        if (e instanceof Error) {
+                            if (e.message.includes("No VTXOs available to renew")) {
+                                // Not an error, just no VTXO eligible for renewal.
+                                return;
+                            }
+                            if (e.message.includes("is below dust threshold")) {
+                                // Not an error, just below dust threshold.
+                                // As more VTXOs are received, the threshold will be raised.
+                                return;
+                            }
+                            if (e.message.includes("VTXO_ALREADY_REGISTERED") ||
+                                e.message.includes("duplicated input")) {
+                                // VTXO is already being used in a concurrent
+                                // user-initiated operation. Skip silently — the
+                                // wallet's tx lock serializes these, but the
+                                // renewal will retry on the next cycle.
+                                return;
+                            }
                         }
-                        if (e.message.includes("is below dust threshold")) {
-                            // Not an error, just below dust threshold.
-                            // As more VTXOs are received, the threshold will be raised.
-                            return;
-                        }
-                        if (e.message.includes("VTXO_ALREADY_REGISTERED") ||
-                            e.message.includes("duplicated input")) {
-                            // VTXO is already being used in a concurrent
-                            // user-initiated operation. Skip silently — the
-                            // wallet's tx lock serializes these, but the
-                            // renewal will retry on the next cycle.
-                            return;
-                        }
-                    }
-                    console.error("Error renewing VTXOs:", e);
-                });
+                        console.error("Error renewing VTXOs:", e);
+                    });
+                }
                 delegatorManager
                     ?.delegate(event.vtxos, destination)
                     .catch((e) => {
@@ -601,7 +626,7 @@ export class VtxoManager {
         this.pollBoardingUtxos();
     }
     schedulePoll() {
-        if (this.settlementConfig === false)
+        if (this.disposed || this.settlementConfig === false)
             return;
         const delay = this.getNextPollDelay();
         this.pollTimeoutId = setTimeout(() => this.pollBoardingUtxos(), delay);
@@ -675,8 +700,8 @@ export class VtxoManager {
             const expired = boardingUtxos.filter((utxo) => hasBoardingTxExpired(utxo, boardingTimelock, chainTipHeight));
             expiredSet = new Set(expired.map((u) => `${u.txid}:${u.vout}`));
         }
-        catch {
-            return;
+        catch (e) {
+            throw e instanceof Error ? e : new Error(String(e));
         }
         const unsettledUtxos = boardingUtxos.filter((u) => !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) &&
             !expiredSet.has(`${u.txid}:${u.vout}`));
@@ -698,6 +723,11 @@ export class VtxoManager {
     }
     async dispose() {
         this.disposePromise ?? (this.disposePromise = (async () => {
+            this.disposed = true;
+            if (this.startupPollTimeoutId) {
+                clearTimeout(this.startupPollTimeoutId);
+                this.startupPollTimeoutId = undefined;
+            }
             if (this.pollTimeoutId) {
                 clearTimeout(this.pollTimeoutId);
                 this.pollTimeoutId = undefined;
@@ -713,3 +743,4 @@ export class VtxoManager {
     }
 }
 VtxoManager.MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes
+VtxoManager.RENEWAL_COOLDOWN_MS = 30000; // 30 seconds

package/dist/esm/wallet/wallet.js

@@ -273,27 +273,33 @@ export class ReadonlyWallet {
         const scriptMap = await this.getScriptMap();
         const f = filter ?? { withRecoverable: true, withUnrolled: false };
         const allExtended = [];
-        // Query each script separately so we can extend VTXOs with the correct tapscript
-        for (const [scriptHex, vtxoScript] of scriptMap) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts: [scriptHex],
-            });
-            let vtxos = response.vtxos.filter(isSpendable);
-            if (!f.withRecoverable) {
-                vtxos = vtxos.filter((vtxo) => !isRecoverable(vtxo) && !isExpired(vtxo));
-            }
-            if (f.withUnrolled) {
-                const spentVtxos = response.vtxos.filter((vtxo) => !isSpendable(vtxo));
-                vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
+        // Batch all scripts into a single indexer call
+        const allScripts = [...scriptMap.keys()];
+        const response = await this.indexerProvider.getVtxos({
+            scripts: allScripts,
+        });
+        for (const vtxo of response.vtxos) {
+            const vtxoScript = vtxo.script
+                ? scriptMap.get(vtxo.script)
+                : undefined;
+            if (!vtxoScript)
+                continue;
+            if (isSpendable(vtxo)) {
+                if (!f.withRecoverable &&
+                    (isRecoverable(vtxo) || isExpired(vtxo))) {
+                    continue;
+                }
             }
-            for (const vtxo of vtxos) {
-                allExtended.push({
-                    ...vtxo,
-                    forfeitTapLeafScript: vtxoScript.forfeit(),
-                    intentTapLeafScript: vtxoScript.forfeit(),
-                    tapTree: vtxoScript.encode(),
-                });
+            else {
+                if (!f.withUnrolled || !vtxo.isUnrolled)
+                    continue;
             }
+            allExtended.push({
+                ...vtxo,
+                forfeitTapLeafScript: vtxoScript.forfeit(),
+                intentTapLeafScript: vtxoScript.forfeit(),
+                tapTree: vtxoScript.encode(),
+            });
         }
         // Update cache with fresh data
         await this.walletRepository.saveVtxos(address, allExtended);
@@ -305,7 +311,7 @@ export class ReadonlyWallet {
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
         const getTxCreatedAt = (txid) => this.indexerProvider
             .getVtxos({ outpoints: [{ txid, vout: 0 }] })
-            .then((res) => res.vtxos[0]?.createdAt.getTime() || 0);
+            .then((res) => res.vtxos[0]?.createdAt.getTime());
         return buildTransactionHistory(response.vtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
     }
     async getBoardingTxs() {
@@ -1338,23 +1344,29 @@ export class Wallet extends ReadonlyWallet {
     async finalizePendingTxs(vtxos) {
         const MAX_INPUTS_PER_INTENT = 20;
         if (!vtxos || vtxos.length === 0) {
-            // Query per-script so each VTXO is extended with the correct tapscript
+            // Batch all scripts into a single indexer call
             const scriptMap = await this.getScriptMap();
             const allExtended = [];
-            for (const [scriptHex, vtxoScript] of scriptMap) {
-                const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
-                    scripts: [scriptHex],
-                });
-                const pending = fetchedVtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
-                    vtxo.virtualStatus.state !== "settled");
-                for (const vtxo of pending) {
-                    allExtended.push({
-                        ...vtxo,
-                        forfeitTapLeafScript: vtxoScript.forfeit(),
-                        intentTapLeafScript: vtxoScript.forfeit(),
-                        tapTree: vtxoScript.encode(),
-                    });
+            const allScripts = [...scriptMap.keys()];
+            const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
+                scripts: allScripts,
+            });
+            for (const vtxo of fetchedVtxos) {
+                const vtxoScript = vtxo.script
+                    ? scriptMap.get(vtxo.script)
+                    : undefined;
+                if (!vtxoScript)
+                    continue;
+                if (vtxo.virtualStatus.state === "swept" ||
+                    vtxo.virtualStatus.state === "settled") {
+                    continue;
                 }
+                allExtended.push({
+                    ...vtxo,
+                    forfeitTapLeafScript: vtxoScript.forfeit(),
+                    intentTapLeafScript: vtxoScript.forfeit(),
+                    tapTree: vtxoScript.encode(),
+                });
             }
             if (allExtended.length === 0) {
                 return { finalized: [], pending: [] };

package/dist/esm/worker/errors.js

@@ -1,12 +1,11 @@
+export const MESSAGE_BUS_NOT_INITIALIZED = "MessageBus not initialized";
 export class MessageBusNotInitializedError extends Error {
     constructor() {
-        super("MessageBus not initialized");
-        this.name = "MessageBusNotInitializedError";
+        super(MESSAGE_BUS_NOT_INITIALIZED);
     }
 }
 export class ServiceWorkerTimeoutError extends Error {
     constructor(detail) {
         super(detail);
-        this.name = "ServiceWorkerTimeoutError";
     }
 }

package/dist/esm/worker/messageBus.js

@@ -149,8 +149,12 @@ export class MessageBus {
                 identity,
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
+                indexerUrl: config.indexerUrl,
+                esploraUrl: config.esploraUrl,
                 storage,
                 delegatorProvider,
+                settlementConfig: config.settlementConfig,
+                watcherConfig: config.watcherConfig,
             });
             return { wallet, arkProvider, readonlyWallet: wallet };
         }
@@ -160,8 +164,11 @@ export class MessageBus {
                 identity,
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
+                indexerUrl: config.indexerUrl,
+                esploraUrl: config.esploraUrl,
                 storage,
                 delegatorProvider,
+                watcherConfig: config.watcherConfig,
             });
             return { readonlyWallet, arkProvider };
         }

package/dist/types/contracts/contractManager.d.ts

@@ -102,6 +102,11 @@ export interface IContractManager extends Disposable {
      * @returns Unsubscribe function
      */
     onContractEvent(callback: ContractEventCallback): () => void;
+    /**
+     * Force a full VTXO refresh from the indexer for all contracts.
+     * Populates the wallet repository with complete VTXO history.
+     */
+    refreshVtxos(): Promise<void>;
     /**
      * Whether the underlying watcher is currently active.
      */
@@ -292,6 +297,11 @@ export declare class ContractManager implements IContractManager {
      * ```
      */
     onContractEvent(callback: ContractEventCallback): () => void;
+    /**
+     * Force a full VTXO refresh from the indexer for all contracts.
+     * Populates the wallet repository with complete VTXO history.
+     */
+    refreshVtxos(): Promise<void>;
     /**
      * Check if currently watching.
      */