@arkade-os/sdk 0.4.6 → 0.4.8

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

@@ -3,6 +3,37 @@ 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
+// 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");
+}
+const DEDUPABLE_REQUEST_TYPES = new Set([
+    "GET_ADDRESS",
+    "GET_BALANCE",
+    "GET_BOARDING_ADDRESS",
+    "GET_BOARDING_UTXOS",
+    "GET_STATUS",
+    "GET_TRANSACTION_HISTORY",
+    "IS_CONTRACT_MANAGER_WATCHING",
+    "GET_DELEGATE_INFO",
+    "GET_RECOVERABLE_BALANCE",
+    "GET_EXPIRED_BOARDING_UTXOS",
+    "GET_VTXOS",
+    "GET_CONTRACTS",
+    "GET_CONTRACTS_WITH_VTXOS",
+    "GET_SPENDABLE_PATHS",
+    "GET_ALL_SPENDING_PATHS",
+    "GET_ASSET_DETAILS",
+    "GET_EXPIRING_VTXOS",
+    "RELOAD_WALLET",
+]);
+function getRequestDedupKey(request) {
+    const { id, tag, ...rest } = request;
+    return JSON.stringify(rest);
+}
 const isPrivateKeyIdentity = (identity) => {
     return typeof identity.toHex === "function";
 };
@@ -79,7 +110,7 @@ const initializeMessageBus = (serviceWorker, config, timeoutMs = 2000) => {
         };
         const timeoutId = setTimeout(() => {
             cleanup();
-            reject(new Error("MessageBus timed out!"));
+            reject(new ServiceWorkerTimeoutError("MessageBus timed out"));
         }, timeoutMs);
         navigator.serviceWorker.addEventListener("message", onMessage);
         serviceWorker.postMessage(initCmd);
@@ -95,6 +126,8 @@ export class ServiceWorkerReadonlyWallet {
         this.initConfig = null;
         this.initWalletPayload = null;
         this.reinitPromise = null;
+        this.pingPromise = null;
+        this.inflightRequests = new Map();
         this.identity = identity;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
@@ -188,7 +221,7 @@ export class ServiceWorkerReadonlyWallet {
             };
             const timeoutId = setTimeout(() => {
                 cleanup();
-                reject(new Error(`Service worker message timed out (${request.type})`));
+                reject(new ServiceWorkerTimeoutError(`Service worker message timed out (${request.type})`));
             }, 30000);
             const messageHandler = (event) => {
                 const response = event.data;
@@ -207,18 +240,137 @@ export class ServiceWorkerReadonlyWallet {
             this.serviceWorker.postMessage(request);
         });
     }
+    // Like sendMessageDirect but supports streaming responses: intermediate
+    // messages are forwarded via onEvent while the promise resolves on the
+    // first response for which isComplete returns true. The timeout resets
+    // on every intermediate event so long-running but progressing operations
+    // don't time out prematurely.
+    sendMessageStreaming(request, onEvent, isComplete) {
+        return new Promise((resolve, reject) => {
+            const resetTimeout = () => {
+                clearTimeout(timeoutId);
+                timeoutId = setTimeout(() => {
+                    cleanup();
+                    reject(new ServiceWorkerTimeoutError(`Service worker message timed out (${request.type})`));
+                }, 30000);
+            };
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                navigator.serviceWorker.removeEventListener("message", messageHandler);
+            };
+            let timeoutId;
+            resetTimeout();
+            const messageHandler = (event) => {
+                const response = event.data;
+                if (request.id !== response.id)
+                    return;
+                if (response.error) {
+                    cleanup();
+                    reject(response.error);
+                    return;
+                }
+                if (isComplete(response)) {
+                    cleanup();
+                    resolve(response);
+                }
+                else {
+                    resetTimeout();
+                    onEvent(response);
+                }
+            };
+            navigator.serviceWorker.addEventListener("message", messageHandler);
+            this.serviceWorker.postMessage(request);
+        });
+    }
+    async sendMessage(request) {
+        if (!DEDUPABLE_REQUEST_TYPES.has(request.type)) {
+            return this.sendMessageWithRetry(request);
+        }
+        const key = getRequestDedupKey(request);
+        const existing = this.inflightRequests.get(key);
+        if (existing)
+            return existing;
+        const promise = this.sendMessageWithRetry(request).finally(() => {
+            this.inflightRequests.delete(key);
+        });
+        this.inflightRequests.set(key, promise);
+        return promise;
+    }
+    pingServiceWorker() {
+        if (this.pingPromise)
+            return this.pingPromise;
+        this.pingPromise = new Promise((resolve, reject) => {
+            const pingId = getRandomId();
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                navigator.serviceWorker.removeEventListener("message", onMessage);
+            };
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                reject(new ServiceWorkerTimeoutError("Service worker ping timed out"));
+            }, 2000);
+            const onMessage = (event) => {
+                if (event.data?.id === pingId && event.data?.tag === "PONG") {
+                    cleanup();
+                    resolve();
+                }
+            };
+            navigator.serviceWorker.addEventListener("message", onMessage);
+            this.serviceWorker.postMessage({
+                id: pingId,
+                tag: "PING",
+            });
+        }).finally(() => {
+            this.pingPromise = null;
+        });
+        return this.pingPromise;
+    }
     // send a message, retrying up to 2 times if the service worker was
     // killed and restarted by the OS (mobile browsers do this aggressively)
-    async sendMessage(request) {
+    async sendMessageWithRetry(request) {
+        // Skip the preflight ping during the initial INIT_WALLET call:
+        // create() hasn't set initConfig yet, so reinitialize() would throw.
+        if (this.initConfig) {
+            try {
+                await this.pingServiceWorker();
+            }
+            catch {
+                await this.reinitialize();
+            }
+        }
         const maxRetries = 2;
         for (let attempt = 0;; attempt++) {
             try {
                 return await this.sendMessageDirect(request);
             }
             catch (error) {
-                const isNotInitialized = typeof error?.message === "string" &&
-                    error.message.includes("MessageBus not initialized");
-                if (!isNotInitialized || attempt >= maxRetries) {
+                if (!isMessageBusNotInitializedError(error) ||
+                    attempt >= maxRetries) {
+                    throw error;
+                }
+                await this.reinitialize();
+            }
+        }
+    }
+    // Like sendMessage but for streaming responses — retries with
+    // reinitialize when the service worker has been killed/restarted.
+    async sendMessageWithEvents(request, onEvent, isComplete) {
+        if (this.initConfig) {
+            try {
+                await this.pingServiceWorker();
+            }
+            catch {
+                await this.reinitialize();
+            }
+        }
+        const maxRetries = 2;
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.sendMessageStreaming(request, onEvent, isComplete);
+            }
+            catch (error) {
+                if (!isMessageBusNotInitializedError(error) ||
+                    attempt >= maxRetries) {
                     throw error;
                 }
                 await this.reinitialize();
@@ -671,34 +823,8 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
             payload: { params },
         };
         try {
-            return new Promise((resolve, reject) => {
-                const messageHandler = (event) => {
-                    const response = event.data;
-                    if (response.id !== message.id) {
-                        return;
-                    }
-                    if (response.error) {
-                        navigator.serviceWorker.removeEventListener("message", messageHandler);
-                        reject(response.error);
-                        return;
-                    }
-                    switch (response.type) {
-                        case "SETTLE_EVENT":
-                            if (callback) {
-                                callback(response.payload);
-                            }
-                            break;
-                        case "SETTLE_SUCCESS":
-                            navigator.serviceWorker.removeEventListener("message", messageHandler);
-                            resolve(response.payload.txid);
-                            break;
-                        default:
-                            console.error(`Unexpected response type for SETTLE request: ${response.type}`);
-                    }
-                };
-                navigator.serviceWorker.addEventListener("message", messageHandler);
-                this.serviceWorker.postMessage(message);
-            });
+            const response = await this.sendMessageWithEvents(message, (resp) => callback?.(resp.payload), (resp) => resp.type === "SETTLE_SUCCESS");
+            return response.payload.txid;
         }
         catch (error) {
             throw new Error(`Settlement failed: ${error}`);
@@ -772,4 +898,108 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
         };
         return manager;
     }
+    async getVtxoManager() {
+        const wallet = this;
+        const messageTag = this.messageTag;
+        const manager = {
+            async recoverVtxos(eventCallback) {
+                const message = {
+                    tag: messageTag,
+                    type: "RECOVER_VTXOS",
+                    id: getRandomId(),
+                };
+                try {
+                    const response = await wallet.sendMessageWithEvents(message, (resp) => eventCallback?.(resp.payload), (resp) => resp.type === "RECOVER_VTXOS_SUCCESS");
+                    return response.payload.txid;
+                }
+                catch (e) {
+                    throw new Error(`Failed to recover vtxos: ${e}`);
+                }
+            },
+            async getRecoverableBalance() {
+                const message = {
+                    tag: messageTag,
+                    type: "GET_RECOVERABLE_BALANCE",
+                    id: getRandomId(),
+                };
+                try {
+                    const response = await wallet.sendMessage(message);
+                    const payload = response
+                        .payload;
+                    return {
+                        recoverable: BigInt(payload.recoverable),
+                        subdust: BigInt(payload.subdust),
+                        includesSubdust: payload.includesSubdust,
+                        vtxoCount: payload.vtxoCount,
+                    };
+                }
+                catch (e) {
+                    throw new Error(`Failed to get recoverable balance: ${e}`);
+                }
+            },
+            async getExpiringVtxos(thresholdMs) {
+                const message = {
+                    tag: messageTag,
+                    type: "GET_EXPIRING_VTXOS",
+                    id: getRandomId(),
+                    payload: { thresholdMs },
+                };
+                try {
+                    const response = await wallet.sendMessage(message);
+                    return response.payload.vtxos;
+                }
+                catch (e) {
+                    throw new Error(`Failed to get expiring vtxos: ${e}`);
+                }
+            },
+            async renewVtxos(eventCallback) {
+                const message = {
+                    tag: messageTag,
+                    type: "RENEW_VTXOS",
+                    id: getRandomId(),
+                };
+                try {
+                    const response = await wallet.sendMessageWithEvents(message, (resp) => eventCallback?.(resp.payload), (resp) => resp.type === "RENEW_VTXOS_SUCCESS");
+                    return response.payload.txid;
+                }
+                catch (e) {
+                    throw new Error(`Failed to renew vtxos: ${e}`);
+                }
+            },
+            async getExpiredBoardingUtxos() {
+                const message = {
+                    tag: messageTag,
+                    type: "GET_EXPIRED_BOARDING_UTXOS",
+                    id: getRandomId(),
+                };
+                try {
+                    const response = await wallet.sendMessage(message);
+                    return response.payload
+                        .utxos;
+                }
+                catch (e) {
+                    throw new Error(`Failed to get expired boarding utxos: ${e}`);
+                }
+            },
+            async sweepExpiredBoardingUtxos() {
+                const message = {
+                    tag: messageTag,
+                    type: "SWEEP_EXPIRED_BOARDING_UTXOS",
+                    id: getRandomId(),
+                };
+                try {
+                    const response = await wallet.sendMessage(message);
+                    return response
+                        .payload.txid;
+                }
+                catch (e) {
+                    throw new Error(`Failed to sweep expired boarding utxos: ${e}`);
+                }
+            },
+            async dispose() {
+                return;
+            },
+        };
+        return manager;
+    }
 }

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,7 @@ export class VtxoManager {
         this.knownBoardingUtxos = new Set();
         this.sweptBoardingUtxos = new Set();
         this.pollInProgress = false;
+        this.consecutivePollFailures = 0;
         // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
         if (settlementConfig !== undefined) {
             this.settlementConfig = settlementConfig;
@@ -577,6 +541,25 @@ export class VtxoManager {
                     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;
+                        }
+                        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);
                 });
                 delegatorManager
@@ -592,19 +575,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.settlementConfig === false)
+            return;
+        const delay = this.getNextPollDelay();
+        this.pollTimeoutId = setTimeout(() => this.pollBoardingUtxos(), delay);
     }
     async pollBoardingUtxos() {
         // Guard: wallet must support boarding UTXO + sweep operations
@@ -614,6 +614,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.
@@ -621,6 +622,7 @@ export class VtxoManager {
                 await this.settleBoardingUtxos();
             }
             catch (e) {
+                hadError = true;
                 console.error("Error auto-settling boarding UTXOs:", e);
             }
             const sweepEnabled = this.settlementConfig !== false &&
@@ -633,13 +635,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();
         }
     }
     /**
@@ -656,7 +666,13 @@ 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 {
@@ -682,9 +698,9 @@ export class VtxoManager {
     }
     async dispose() {
         this.disposePromise ?? (this.disposePromise = (async () => {
-            if (this.pollIntervalId) {
-                clearInterval(this.pollIntervalId);
-                this.pollIntervalId = undefined;
+            if (this.pollTimeoutId) {
+                clearTimeout(this.pollTimeoutId);
+                this.pollTimeoutId = undefined;
             }
             const subscription = await this.contractEventsSubscriptionReady;
             this.contractEventsSubscription = undefined;
@@ -696,3 +712,4 @@ export class VtxoManager {
         await this.dispose();
     }
 }
+VtxoManager.MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes