@arkade-os/sdk 0.4.7 → 0.4.9

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

@@ -143,43 +143,6 @@ export function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
         (isSpendable(vtxo) && isExpired(vtxo)) ||
         isSubdust(vtxo, dustAmount));
 }
-/**
- * VtxoManager is a unified class for managing VTXO lifecycle operations including
- * recovery of swept/expired VTXOs and renewal to prevent expiration.
- *
- * Key Features:
- * - **Recovery**: Reclaim swept or expired VTXOs back to the wallet
- * - **Renewal**: Refresh VTXO expiration time before they expire
- * - **Smart subdust handling**: Automatically includes subdust VTXOs when economically viable
- * - **Expiry monitoring**: Check for VTXOs that are expiring soon
- *
- * VTXOs become recoverable when:
- * - The Ark server sweeps them (virtualStatus.state === "swept") and they remain spendable
- * - They are preconfirmed subdust (to consolidate small amounts without locking liquidity on settled VTXOs)
- *
- * @example
- * ```typescript
- * // Initialize with renewal config
- * const manager = new VtxoManager(wallet, {
- *   enabled: true,
- *   thresholdMs: 86400000
- * });
- *
- * // Check recoverable balance
- * const balance = await manager.getRecoverableBalance();
- * if (balance.recoverable > 0n) {
- *   console.log(`Can recover ${balance.recoverable} sats`);
- *   const txid = await manager.recoverVtxos();
- * }
- *
- * // Check for expiring VTXOs
- * const expiring = await manager.getExpiringVtxos();
- * if (expiring.length > 0) {
- *   console.log(`${expiring.length} VTXOs expiring soon`);
- *   const txid = await manager.renewVtxos();
- * }
- * ```
- */
 export class VtxoManager {
     constructor(wallet, 
     /** @deprecated Use settlementConfig instead */
@@ -189,6 +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;
@@ -372,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 ==========
     /**
@@ -565,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(),
@@ -576,20 +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;
-                        }
-                    }
-                    console.error("Error renewing VTXOs:", e);
-                });
+                        console.error("Error renewing VTXOs:", e);
+                    });
+                }
                 delegatorManager
                     ?.delegate(event.vtxos, destination)
                     .catch((e) => {
@@ -603,19 +600,36 @@ export class VtxoManager {
             return undefined;
         }
     }
+    /** Computes the next poll delay, applying exponential backoff on failures. */
+    getNextPollDelay() {
+        if (this.settlementConfig === false)
+            return 0;
+        const baseMs = this.settlementConfig.pollIntervalMs ??
+            DEFAULT_SETTLEMENT_CONFIG.pollIntervalMs;
+        if (this.consecutivePollFailures === 0)
+            return baseMs;
+        const backoff = Math.min(baseMs * Math.pow(2, this.consecutivePollFailures), VtxoManager.MAX_BACKOFF_MS);
+        return backoff;
+    }
     /**
      * Starts a polling loop that:
      * 1. Auto-settles new boarding UTXOs into Ark
      * 2. Sweeps expired boarding UTXOs (when boardingUtxoSweep is enabled)
+     *
+     * Uses setTimeout chaining (not setInterval) so a slow/blocked poll
+     * cannot stack up and the next delay can incorporate backoff.
      */
     startBoardingUtxoPoll() {
         if (this.settlementConfig === false)
             return;
-        const intervalMs = this.settlementConfig.pollIntervalMs ??
-            DEFAULT_SETTLEMENT_CONFIG.pollIntervalMs;
-        // Run once immediately, then on interval
+        // Run once immediately, then schedule next
         this.pollBoardingUtxos();
-        this.pollIntervalId = setInterval(() => this.pollBoardingUtxos(), intervalMs);
+    }
+    schedulePoll() {
+        if (this.disposed || this.settlementConfig === false)
+            return;
+        const delay = this.getNextPollDelay();
+        this.pollTimeoutId = setTimeout(() => this.pollBoardingUtxos(), delay);
     }
     async pollBoardingUtxos() {
         // Guard: wallet must support boarding UTXO + sweep operations
@@ -625,6 +639,7 @@ export class VtxoManager {
         if (this.pollInProgress)
             return;
         this.pollInProgress = true;
+        let hadError = false;
         try {
             // Settle new (unexpired) UTXOs first, then sweep expired ones.
             // Sequential to avoid racing for the same UTXOs.
@@ -632,6 +647,7 @@ export class VtxoManager {
                 await this.settleBoardingUtxos();
             }
             catch (e) {
+                hadError = true;
                 console.error("Error auto-settling boarding UTXOs:", e);
             }
             const sweepEnabled = this.settlementConfig !== false &&
@@ -644,13 +660,21 @@ export class VtxoManager {
                 catch (e) {
                     if (!(e instanceof Error) ||
                         !e.message.includes("No expired boarding UTXOs")) {
+                        hadError = true;
                         console.error("Error auto-sweeping boarding UTXOs:", e);
                     }
                 }
             }
         }
         finally {
+            if (hadError) {
+                this.consecutivePollFailures++;
+            }
+            else {
+                this.consecutivePollFailures = 0;
+            }
             this.pollInProgress = false;
+            this.schedulePoll();
         }
     }
     /**
@@ -667,11 +691,17 @@ export class VtxoManager {
         // accidentally settling expired UTXOs (which would conflict with sweep).
         let expiredSet;
         try {
-            const expired = await this.getExpiredBoardingUtxos();
+            const boardingTimelock = this.getBoardingTimelock();
+            let chainTipHeight;
+            if (boardingTimelock.type === "blocks") {
+                const tip = await this.getOnchainProvider().getChainTip();
+                chainTipHeight = tip.height;
+            }
+            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}`));
@@ -693,9 +723,14 @@ export class VtxoManager {
     }
     async dispose() {
         this.disposePromise ?? (this.disposePromise = (async () => {
-            if (this.pollIntervalId) {
-                clearInterval(this.pollIntervalId);
-                this.pollIntervalId = undefined;
+            this.disposed = true;
+            if (this.startupPollTimeoutId) {
+                clearTimeout(this.startupPollTimeoutId);
+                this.startupPollTimeoutId = undefined;
+            }
+            if (this.pollTimeoutId) {
+                clearTimeout(this.pollTimeoutId);
+                this.pollTimeoutId = undefined;
             }
             const subscription = await this.contractEventsSubscriptionReady;
             this.contractEventsSubscription = undefined;
@@ -707,3 +742,5 @@ export class VtxoManager {
         await this.dispose();
     }
 }
+VtxoManager.MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes
+VtxoManager.RENEWAL_COOLDOWN_MS = 30000; // 30 seconds

package/dist/esm/wallet/wallet.js

@@ -57,6 +57,19 @@ export class ReadonlyWallet {
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
         this.delegatorProvider = delegatorProvider;
+        // 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.
+        if ("descriptor" in identity) {
+            const descriptor = identity.descriptor;
+            const identityIsMainnet = !descriptor.includes("tpub");
+            const serverIsMainnet = network.bech32 === "bc";
+            if (identityIsMainnet !== serverIsMainnet) {
+                throw new Error(`Network mismatch: identity uses ${identityIsMainnet ? "mainnet" : "testnet"} derivation ` +
+                    `but wallet network is ${serverIsMainnet ? "mainnet" : "testnet"}. ` +
+                    `Create identity with { isMainnet: ${serverIsMainnet} } to match.`);
+            }
+        }
         this.watcherConfig = watcherConfig;
         this._assetManager = new ReadonlyAssetManager(this.indexerProvider);
     }
@@ -84,6 +97,24 @@ export class ReadonlyWallet {
         const indexerProvider = config.indexerProvider || new RestIndexerProvider(indexerUrl);
         const info = await arkProvider.getInfo();
         const network = getNetwork(info.network);
+        // Guard: detect identity/server network mismatch for seed-based identities.
+        // A mainnet descriptor (xpub, coin type 0) connected to a testnet server
+        // (or vice versa) means wrong derivation path → wrong keys → potential fund loss.
+        if ("descriptor" in config.identity) {
+            const descriptor = config.identity.descriptor;
+            const identityIsMainnet = !descriptor.includes("tpub");
+            const serverIsMainnet = info.network === "bitcoin";
+            if (identityIsMainnet && !serverIsMainnet) {
+                throw new Error(`Network mismatch: identity uses mainnet derivation (coin type 0) ` +
+                    `but Ark server is on ${info.network}. ` +
+                    `Create identity with { isMainnet: false } to use testnet derivation.`);
+            }
+            if (!identityIsMainnet && serverIsMainnet) {
+                throw new Error(`Network mismatch: identity uses testnet derivation (coin type 1) ` +
+                    `but Ark server is on mainnet. ` +
+                    `Create identity with { isMainnet: true } or omit isMainnet (defaults to mainnet).`);
+            }
+        }
         // Extract esploraUrl from provider if not explicitly provided
         const esploraUrl = config.esploraUrl || ESPLORA_URL[info.network];
         // Use provided onchainProvider instance or create a new one
@@ -242,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);
@@ -274,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() {
@@ -658,6 +695,20 @@ export class ReadonlyWallet {
  * ```
  */
 export class Wallet extends ReadonlyWallet {
+    _withTxLock(fn) {
+        let release;
+        const lock = new Promise((r) => (release = r));
+        const prev = this._txLock;
+        this._txLock = lock;
+        return prev.then(async () => {
+            try {
+                return await fn();
+            }
+            finally {
+                release();
+            }
+        });
+    }
     constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, 
     /** @deprecated Use settlementConfig */
     renewalConfig, delegatorProvider, watcherConfig, settlementConfig) {
@@ -667,6 +718,13 @@ export class Wallet extends ReadonlyWallet {
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
         this.forfeitPubkey = forfeitPubkey;
+        /**
+         * Async mutex that serializes all operations submitting VTXOs to the Ark
+         * server (`settle`, `send`, `sendBitcoin`). This prevents VtxoManager's
+         * background renewal from racing with user-initiated transactions for the
+         * same VTXO inputs.
+         */
+        this._txLock = Promise.resolve();
         this.identity = identity;
         // Backwards-compatible: keep renewalConfig populated for any code reading it
         this.renewalConfig = {
@@ -805,40 +863,42 @@ export class Wallet extends ReadonlyWallet {
             throw new Error("Invalid Ark address " + params.address);
         }
         if (params.selectedVtxos && params.selectedVtxos.length > 0) {
-            const selectedVtxoSum = params.selectedVtxos
-                .map((v) => v.value)
-                .reduce((a, b) => a + b, 0);
-            if (selectedVtxoSum < params.amount) {
-                throw new Error("Selected VTXOs do not cover specified amount");
-            }
-            const changeAmount = selectedVtxoSum - params.amount;
-            const selected = {
-                inputs: params.selectedVtxos,
-                changeAmount: BigInt(changeAmount),
-            };
-            const outputAddress = ArkAddress.decode(params.address);
-            const outputScript = BigInt(params.amount) < this.dustAmount
-                ? outputAddress.subdustPkScript
-                : outputAddress.pkScript;
-            const outputs = [
-                {
-                    script: outputScript,
-                    amount: BigInt(params.amount),
-                },
-            ];
-            // add change output if needed
-            if (selected.changeAmount > 0n) {
-                const changeOutputScript = selected.changeAmount < this.dustAmount
-                    ? this.arkAddress.subdustPkScript
-                    : this.arkAddress.pkScript;
-                outputs.push({
-                    script: changeOutputScript,
-                    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;
+            return this._withTxLock(async () => {
+                const selectedVtxoSum = params
+                    .selectedVtxos.map((v) => v.value)
+                    .reduce((a, b) => a + b, 0);
+                if (selectedVtxoSum < params.amount) {
+                    throw new Error("Selected VTXOs do not cover specified amount");
+                }
+                const changeAmount = selectedVtxoSum - params.amount;
+                const selected = {
+                    inputs: params.selectedVtxos,
+                    changeAmount: BigInt(changeAmount),
+                };
+                const outputAddress = ArkAddress.decode(params.address);
+                const outputScript = BigInt(params.amount) < this.dustAmount
+                    ? outputAddress.subdustPkScript
+                    : outputAddress.pkScript;
+                const outputs = [
+                    {
+                        script: outputScript,
+                        amount: BigInt(params.amount),
+                    },
+                ];
+                // add change output if needed
+                if (selected.changeAmount > 0n) {
+                    const changeOutputScript = selected.changeAmount < this.dustAmount
+                        ? this.arkAddress.subdustPkScript
+                        : this.arkAddress.pkScript;
+                    outputs.push({
+                        script: changeOutputScript,
+                        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;
+            });
         }
         return this.send({
             address: params.address,
@@ -846,6 +906,9 @@ export class Wallet extends ReadonlyWallet {
         });
     }
     async settle(params, eventCallback) {
+        return this._withTxLock(() => this._settleImpl(params, eventCallback));
+    }
+    async _settleImpl(params, eventCallback) {
         if (params?.inputs) {
             for (const input of params.inputs) {
                 // validate arknotes inputs
@@ -1281,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: [] };
@@ -1347,6 +1416,9 @@ export class Wallet extends ReadonlyWallet {
      * ```
      */
     async send(...args) {
+        return this._withTxLock(() => this._sendImpl(...args));
+    }
+    async _sendImpl(...args) {
         if (args.length === 0) {
             throw new Error("At least one receiver is required");
         }

package/dist/esm/worker/errors.js

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

package/dist/esm/worker/messageBus.js

@@ -5,6 +5,7 @@ import { RestDelegatorProvider } from '../providers/delegator.js';
 import { ReadonlySingleKey, SingleKey } from '../identity/index.js';
 import { ReadonlyWallet, Wallet } from '../wallet/wallet.js';
 import { hex } from "@scure/base";
+import { MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from './errors.js';
 export class MessageBus {
     constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, messageTimeoutMs = 30000, debug = false, buildServices, }) {
         this.walletRepository = walletRepository;
@@ -148,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 };
         }
@@ -159,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 };
         }
@@ -180,6 +188,10 @@ export class MessageBus {
     }
     async processMessage(event) {
         const { id, tag, broadcast } = event.data;
+        if (tag === "PING") {
+            event.source?.postMessage({ id, tag: "PONG" });
+            return;
+        }
         if (tag === "INITIALIZE_MESSAGE_BUS") {
             if (this.debug) {
                 console.log("Init Command received");
@@ -204,7 +216,7 @@ export class MessageBus {
             event.source?.postMessage({
                 id,
                 tag: tag ?? "unknown",
-                error: new Error("MessageBus not initialized"),
+                error: new MessageBusNotInitializedError(),
             });
             return;
         }
@@ -275,7 +287,7 @@ export class MessageBus {
             return promise;
         return new Promise((resolve, reject) => {
             const timer = self.setTimeout(() => {
-                reject(new Error(`Message handler timed out after ${this.messageTimeoutMs}ms (${label})`));
+                reject(new ServiceWorkerTimeoutError(`Message handler timed out after ${this.messageTimeoutMs}ms (${label})`));
             }, this.messageTimeoutMs);
             promise.then((val) => {
                 self.clearTimeout(timer);