@arkade-os/sdk 0.4.7 → 0.4.9

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;
@@ -125,7 +158,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 = {
@@ -142,6 +178,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;
@@ -188,7 +227,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 +246,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();
@@ -523,6 +681,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",
@@ -592,7 +758,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 = {
@@ -610,6 +780,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;
@@ -671,34 +845,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 +920,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;
+    }
 }