@arkade-os/sdk 0.4.0-next.7 → 0.4.0

package/dist/cjs/wallet/serviceWorker/wallet.js

@@ -95,6 +95,9 @@ class ServiceWorkerReadonlyWallet {
     constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag) {
         this.serviceWorker = serviceWorker;
         this.messageTag = messageTag;
+        this.initConfig = null;
+        this.initWalletPayload = null;
+        this.reinitPromise = null;
         this.identity = identity;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
@@ -135,6 +138,16 @@ class ServiceWorkerReadonlyWallet {
             payload: initConfig,
         };
         await wallet.sendMessage(initMessage);
+        wallet.initConfig = {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            delegatorUrl: initConfig.delegatorUrl,
+        };
+        wallet.initWalletPayload = initConfig;
+        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
         return wallet;
     }
     /**
@@ -160,15 +173,17 @@ class ServiceWorkerReadonlyWallet {
      */
     static async setup(options) {
         // Register and setup the service worker
-        const serviceWorker = await (0, utils_1.setupServiceWorker)(options.serviceWorkerPath);
+        const serviceWorker = await (0, utils_1.setupServiceWorker)({
+            path: options.serviceWorkerPath,
+            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
+        });
         // Use the existing create method
         return await ServiceWorkerReadonlyWallet.create({
             ...options,
             serviceWorker,
         });
     }
-    // send a message and wait for a response
-    async sendMessage(request) {
+    sendMessageDirect(request) {
         return new Promise((resolve, reject) => {
             const cleanup = () => {
                 clearTimeout(timeoutId);
@@ -195,6 +210,44 @@ class ServiceWorkerReadonlyWallet {
             this.serviceWorker.postMessage(request);
         });
     }
+    // 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) {
+        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) {
+                    throw error;
+                }
+                await this.reinitialize();
+            }
+        }
+    }
+    async reinitialize() {
+        if (this.reinitPromise)
+            return this.reinitPromise;
+        this.reinitPromise = (async () => {
+            if (!this.initConfig || !this.initWalletPayload) {
+                throw new Error("Cannot re-initialize: missing configuration");
+            }
+            await initializeMessageBus(this.serviceWorker, this.initConfig, this.messageBusTimeoutMs);
+            const initMessage = {
+                tag: this.messageTag,
+                type: "INIT_WALLET",
+                id: (0, utils_2.getRandomId)(),
+                payload: this.initWalletPayload,
+            };
+            await this.sendMessageDirect(initMessage);
+        })().finally(() => {
+            this.reinitPromise = null;
+        });
+        return this.reinitPromise;
+    }
     async clear() {
         const message = {
             id: (0, utils_2.getRandomId)(),
@@ -554,6 +607,16 @@ class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
         };
         // Initialize the service worker
         await wallet.sendMessage(initMessage);
+        wallet.initConfig = {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            delegatorUrl: initConfig.delegatorUrl,
+        };
+        wallet.initWalletPayload = initConfig;
+        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
         return wallet;
     }
     /**
@@ -579,7 +642,10 @@ class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
      */
     static async setup(options) {
         // Register and setup the service worker
-        const serviceWorker = await (0, utils_1.setupServiceWorker)(options.serviceWorkerPath);
+        const serviceWorker = await (0, utils_1.setupServiceWorker)({
+            path: options.serviceWorkerPath,
+            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
+        });
         // Use the existing create method
         return ServiceWorkerWallet.create({
             ...options,

package/dist/cjs/worker/browser/utils.js

@@ -1,22 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_DB_NAME = void 0;
+exports.DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = exports.DEFAULT_DB_NAME = void 0;
 exports.setupServiceWorker = setupServiceWorker;
 exports.DEFAULT_DB_NAME = "arkade-service-worker";
+exports.DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = 10000;
+function normalizeOptions(pathOrOptions) {
+    if (typeof pathOrOptions === "string") {
+        return {
+            path: pathOrOptions,
+            activationTimeoutMs: exports.DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS,
+        };
+    }
+    return {
+        path: pathOrOptions.path,
+        activationTimeoutMs: pathOrOptions.activationTimeoutMs ??
+            exports.DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS,
+    };
+}
+function waitForServiceWorkerReady(timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            reject(new Error(`Service worker activation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        navigator.serviceWorker.ready
+            .then((registration) => {
+            clearTimeout(timeoutId);
+            resolve(registration);
+        })
+            .catch((error) => {
+            clearTimeout(timeoutId);
+            reject(error);
+        });
+    });
+}
 /**
  * setupServiceWorker sets up the service worker.
- * @param path - the path to the service worker script
+ * @param pathOrOptions - the path to the service worker script or setup options
  * @throws if service workers are not supported or activation fails
  * @example
  * ```typescript
  * const worker = await setupServiceWorker("/service-worker.js");
  * ```
  */
-async function setupServiceWorker(path) {
+async function setupServiceWorker(pathOrOptions) {
     // check if service workers are supported
     if (!("serviceWorker" in navigator)) {
         throw new Error("Service workers are not supported in this browser");
     }
+    const { path, activationTimeoutMs } = normalizeOptions(pathOrOptions);
     // register service worker
     const registration = await navigator.serviceWorker.register(path);
     // force update to ensure the service worker is active
@@ -25,28 +56,12 @@ async function setupServiceWorker(path) {
     if (!serviceWorker) {
         throw new Error("Failed to get service worker instance");
     }
-    // wait for the service worker to be ready
-    return new Promise((resolve, reject) => {
-        if (serviceWorker.state === "activated")
-            return resolve(serviceWorker);
-        const onActivate = () => {
-            cleanup();
-            resolve(serviceWorker);
-        };
-        const onError = () => {
-            cleanup();
-            reject(new Error("Service worker failed to activate"));
-        };
-        const timeout = setTimeout(() => {
-            cleanup();
-            reject(new Error("Service worker activation timed out"));
-        }, 10000);
-        const cleanup = () => {
-            navigator.serviceWorker.removeEventListener("activate", onActivate);
-            navigator.serviceWorker.removeEventListener("error", onError);
-            clearTimeout(timeout);
-        };
-        navigator.serviceWorker.addEventListener("activate", onActivate);
-        navigator.serviceWorker.addEventListener("error", onError);
-    });
+    if (serviceWorker.state === "activated") {
+        return serviceWorker;
+    }
+    const readyRegistration = await waitForServiceWorkerReady(activationTimeoutMs);
+    if (!readyRegistration.active) {
+        throw new Error("Service worker registration is ready but has no active worker");
+    }
+    return readyRegistration.active;
 }

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

@@ -92,6 +92,9 @@ export class ServiceWorkerReadonlyWallet {
     constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag) {
         this.serviceWorker = serviceWorker;
         this.messageTag = messageTag;
+        this.initConfig = null;
+        this.initWalletPayload = null;
+        this.reinitPromise = null;
         this.identity = identity;
         this.walletRepository = walletRepository;
         this.contractRepository = contractRepository;
@@ -132,6 +135,16 @@ export class ServiceWorkerReadonlyWallet {
             payload: initConfig,
         };
         await wallet.sendMessage(initMessage);
+        wallet.initConfig = {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            delegatorUrl: initConfig.delegatorUrl,
+        };
+        wallet.initWalletPayload = initConfig;
+        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
         return wallet;
     }
     /**
@@ -157,15 +170,17 @@ export class ServiceWorkerReadonlyWallet {
      */
     static async setup(options) {
         // Register and setup the service worker
-        const serviceWorker = await setupServiceWorker(options.serviceWorkerPath);
+        const serviceWorker = await setupServiceWorker({
+            path: options.serviceWorkerPath,
+            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
+        });
         // Use the existing create method
         return await ServiceWorkerReadonlyWallet.create({
             ...options,
             serviceWorker,
         });
     }
-    // send a message and wait for a response
-    async sendMessage(request) {
+    sendMessageDirect(request) {
         return new Promise((resolve, reject) => {
             const cleanup = () => {
                 clearTimeout(timeoutId);
@@ -192,6 +207,44 @@ export class ServiceWorkerReadonlyWallet {
             this.serviceWorker.postMessage(request);
         });
     }
+    // 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) {
+        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) {
+                    throw error;
+                }
+                await this.reinitialize();
+            }
+        }
+    }
+    async reinitialize() {
+        if (this.reinitPromise)
+            return this.reinitPromise;
+        this.reinitPromise = (async () => {
+            if (!this.initConfig || !this.initWalletPayload) {
+                throw new Error("Cannot re-initialize: missing configuration");
+            }
+            await initializeMessageBus(this.serviceWorker, this.initConfig, this.messageBusTimeoutMs);
+            const initMessage = {
+                tag: this.messageTag,
+                type: "INIT_WALLET",
+                id: getRandomId(),
+                payload: this.initWalletPayload,
+            };
+            await this.sendMessageDirect(initMessage);
+        })().finally(() => {
+            this.reinitPromise = null;
+        });
+        return this.reinitPromise;
+    }
     async clear() {
         const message = {
             id: getRandomId(),
@@ -550,6 +603,16 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
         };
         // Initialize the service worker
         await wallet.sendMessage(initMessage);
+        wallet.initConfig = {
+            wallet: initConfig.key,
+            arkServer: {
+                url: initConfig.arkServerUrl,
+                publicKey: initConfig.arkServerPublicKey,
+            },
+            delegatorUrl: initConfig.delegatorUrl,
+        };
+        wallet.initWalletPayload = initConfig;
+        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
         return wallet;
     }
     /**
@@ -575,7 +638,10 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
      */
     static async setup(options) {
         // Register and setup the service worker
-        const serviceWorker = await setupServiceWorker(options.serviceWorkerPath);
+        const serviceWorker = await setupServiceWorker({
+            path: options.serviceWorkerPath,
+            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
+        });
         // Use the existing create method
         return ServiceWorkerWallet.create({
             ...options,

package/dist/esm/worker/browser/utils.js

@@ -1,18 +1,49 @@
 export const DEFAULT_DB_NAME = "arkade-service-worker";
+export const DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = 10000;
+function normalizeOptions(pathOrOptions) {
+    if (typeof pathOrOptions === "string") {
+        return {
+            path: pathOrOptions,
+            activationTimeoutMs: DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS,
+        };
+    }
+    return {
+        path: pathOrOptions.path,
+        activationTimeoutMs: pathOrOptions.activationTimeoutMs ??
+            DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS,
+    };
+}
+function waitForServiceWorkerReady(timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            reject(new Error(`Service worker activation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        navigator.serviceWorker.ready
+            .then((registration) => {
+            clearTimeout(timeoutId);
+            resolve(registration);
+        })
+            .catch((error) => {
+            clearTimeout(timeoutId);
+            reject(error);
+        });
+    });
+}
 /**
  * setupServiceWorker sets up the service worker.
- * @param path - the path to the service worker script
+ * @param pathOrOptions - the path to the service worker script or setup options
  * @throws if service workers are not supported or activation fails
  * @example
  * ```typescript
  * const worker = await setupServiceWorker("/service-worker.js");
  * ```
  */
-export async function setupServiceWorker(path) {
+export async function setupServiceWorker(pathOrOptions) {
     // check if service workers are supported
     if (!("serviceWorker" in navigator)) {
         throw new Error("Service workers are not supported in this browser");
     }
+    const { path, activationTimeoutMs } = normalizeOptions(pathOrOptions);
     // register service worker
     const registration = await navigator.serviceWorker.register(path);
     // force update to ensure the service worker is active
@@ -21,28 +52,12 @@ export async function setupServiceWorker(path) {
     if (!serviceWorker) {
         throw new Error("Failed to get service worker instance");
     }
-    // wait for the service worker to be ready
-    return new Promise((resolve, reject) => {
-        if (serviceWorker.state === "activated")
-            return resolve(serviceWorker);
-        const onActivate = () => {
-            cleanup();
-            resolve(serviceWorker);
-        };
-        const onError = () => {
-            cleanup();
-            reject(new Error("Service worker failed to activate"));
-        };
-        const timeout = setTimeout(() => {
-            cleanup();
-            reject(new Error("Service worker activation timed out"));
-        }, 10000);
-        const cleanup = () => {
-            navigator.serviceWorker.removeEventListener("activate", onActivate);
-            navigator.serviceWorker.removeEventListener("error", onError);
-            clearTimeout(timeout);
-        };
-        navigator.serviceWorker.addEventListener("activate", onActivate);
-        navigator.serviceWorker.addEventListener("error", onError);
-    });
+    if (serviceWorker.state === "activated") {
+        return serviceWorker;
+    }
+    const readyRegistration = await waitForServiceWorkerReady(activationTimeoutMs);
+    if (!readyRegistration.active) {
+        throw new Error("Service worker registration is ready but has no active worker");
+    }
+    return readyRegistration.active;
 }

package/dist/types/wallet/serviceWorker/wallet.d.ts

@@ -3,7 +3,7 @@ import { SettlementEvent } from "../../providers/ark";
 import { Identity, ReadonlyIdentity } from "../../identity";
 import { WalletRepository } from "../../repositories/walletRepository";
 import { ContractRepository } from "../../repositories/contractRepository";
-import { ResponseGetStatus, WalletUpdaterRequest, WalletUpdaterResponse } from "./wallet-message-handler";
+import { RequestInitWallet, ResponseGetStatus, WalletUpdaterRequest, WalletUpdaterResponse } from "./wallet-message-handler";
 import type { IContractManager } from "../../contracts/contractManager";
 import type { IDelegatorManager } from "../delegator";
 type PrivateKeyIdentity = Identity & {
@@ -56,6 +56,20 @@ export type ServiceWorkerWalletCreateOptions = ServiceWorkerWalletOptions & {
 };
 export type ServiceWorkerWalletSetupOptions = ServiceWorkerWalletOptions & {
     serviceWorkerPath: string;
+    serviceWorkerActivationTimeoutMs?: number;
+};
+type MessageBusInitConfig = {
+    wallet: {
+        privateKey: string;
+    } | {
+        publicKey: string;
+    };
+    arkServer: {
+        url: string;
+        publicKey?: string;
+    };
+    delegatorUrl?: string;
+    timeoutMs?: number;
 };
 export declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
     readonly serviceWorker: ServiceWorker;
@@ -64,6 +78,10 @@ export declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
     readonly contractRepository: ContractRepository;
     readonly identity: ReadonlyIdentity;
     private readonly _readonlyAssetManager;
+    protected initConfig: MessageBusInitConfig | null;
+    protected initWalletPayload: RequestInitWallet["payload"] | null;
+    protected messageBusTimeoutMs?: number;
+    private reinitPromise;
     get assetManager(): IReadonlyAssetManager;
     protected constructor(serviceWorker: ServiceWorker, identity: ReadonlyIdentity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string);
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerReadonlyWallet>;
@@ -89,7 +107,9 @@ export declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
      * ```
      */
     static setup(options: ServiceWorkerWalletSetupOptions): Promise<ServiceWorkerReadonlyWallet>;
+    private sendMessageDirect;
     protected sendMessage(request: WalletUpdaterRequest): Promise<WalletUpdaterResponse>;
+    private reinitialize;
     clear(): Promise<void>;
     getAddress(): Promise<string>;
     getBoardingAddress(): Promise<string>;

package/dist/types/worker/browser/utils.d.ts

@@ -1,11 +1,17 @@
 export declare const DEFAULT_DB_NAME = "arkade-service-worker";
+export declare const DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = 10000;
+type SetupServiceWorkerOptions = {
+    path: string;
+    activationTimeoutMs?: number;
+};
 /**
  * setupServiceWorker sets up the service worker.
- * @param path - the path to the service worker script
+ * @param pathOrOptions - the path to the service worker script or setup options
  * @throws if service workers are not supported or activation fails
  * @example
  * ```typescript
  * const worker = await setupServiceWorker("/service-worker.js");
  * ```
  */
-export declare function setupServiceWorker(path: string): Promise<ServiceWorker>;
+export declare function setupServiceWorker(pathOrOptions: string | SetupServiceWorkerOptions): Promise<ServiceWorker>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.0-next.7",
+  "version": "0.4.0",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",