@arkade-os/sdk 0.4.27 → 0.4.28

package/dist/esm/worker/browser/service-worker-manager.js

@@ -1,177 +0,0 @@
-const registrations = new Map();
-let handshakes = new WeakSet();
-function ensureServiceWorkerSupport() {
-    if (!("serviceWorker" in navigator)) {
-        throw new Error("Service workers are not supported in this browser");
-    }
-}
-function debugLog(debug, ...args) {
-    if (debug) {
-        // eslint-disable-next-line no-console
-        console.debug(...args);
-    }
-}
-function normalizeOptions(pathOrOptions) {
-    if (typeof pathOrOptions === "string") {
-        return {
-            path: pathOrOptions,
-            updateViaCache: "none",
-            autoReload: true,
-            debug: false,
-            activationTimeoutMs: 10000,
-        };
-    }
-    return {
-        path: pathOrOptions.path,
-        updateViaCache: pathOrOptions.updateViaCache ?? "none",
-        autoReload: pathOrOptions.autoReload ?? true,
-        onNeedRefresh: pathOrOptions.onNeedRefresh,
-        onUpdated: pathOrOptions.onUpdated,
-        debug: pathOrOptions.debug ?? false,
-        activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? 10000,
-    };
-}
-function sendSkipWaiting(worker, debug) {
-    if (!worker)
-        return;
-    try {
-        worker.postMessage({ type: "SKIP_WAITING" });
-        debugLog(debug, "Sent SKIP_WAITING to waiting service worker");
-    }
-    catch (error) {
-        console.warn("Failed to post SKIP_WAITING to service worker", error);
-    }
-}
-function attachUpdateHandlers(registration, options) {
-    // Guard: only the first caller per registration attaches handlers.
-    // Subsequent calls with different options are silently ignored.
-    if (handshakes.has(registration))
-        return;
-    handshakes.add(registration);
-    const { autoReload, onNeedRefresh, onUpdated, activationTimeoutMs, debug } = options;
-    let reloadTriggered = false;
-    const maybeReload = () => {
-        if (reloadTriggered)
-            return;
-        reloadTriggered = true;
-        debugLog(debug, "Service worker controller change detected");
-        onUpdated?.();
-        if (autoReload &&
-            typeof window !== "undefined" &&
-            typeof window.location?.reload === "function") {
-            window.location.reload();
-        }
-    };
-    const handleWaiting = (worker) => {
-        if (!worker)
-            return;
-        onNeedRefresh?.();
-        sendSkipWaiting(worker, debug);
-        if (activationTimeoutMs > 0 && typeof window !== "undefined") {
-            window.setTimeout(() => {
-                if (registration.waiting) {
-                    debugLog(debug, "Waiting worker still pending; re-sending SKIP_WAITING");
-                    sendSkipWaiting(registration.waiting, debug);
-                    registration
-                        .update()
-                        .catch(() => debugLog(debug, "Service worker update retry failed (timeout path)"));
-                }
-            }, activationTimeoutMs);
-        }
-    };
-    // Handle an already waiting worker at startup.
-    if (registration.waiting) {
-        handleWaiting(registration.waiting);
-    }
-    // Listen for newly installed workers becoming waiting.
-    registration.addEventListener("updatefound", () => {
-        const installing = registration.installing;
-        if (!installing)
-            return;
-        installing.addEventListener("statechange", () => {
-            if (installing.state === "installed") {
-                handleWaiting(registration.waiting);
-            }
-        });
-    });
-    // Reload (or callback) once the new controller takes over.
-    navigator.serviceWorker.addEventListener("controllerchange", maybeReload, {
-        once: true,
-    });
-}
-function registerOnce(options) {
-    const { path, updateViaCache } = options;
-    if (!registrations.has(path)) {
-        const registrationPromise = navigator.serviceWorker
-            .register(path, { updateViaCache })
-            .then(async (registration) => {
-            try {
-                await registration.update();
-            }
-            catch (error) {
-                console.warn("Service worker update failed; continuing with registration", error);
-            }
-            return registration;
-        })
-            .catch((error) => {
-            // delete failed registration to allow retrials
-            registrations.delete(path);
-            throw error;
-        });
-        registrations.set(path, registrationPromise);
-    }
-    return registrations.get(path).then((registration) => {
-        attachUpdateHandlers(registration, options);
-        return registration;
-    });
-}
-/**
- * Registers a service worker for the given path only once, attaches an
- * update/activation handshake (SKIP_WAITING + controllerchange reload), and
- * caches the registration promise for subsequent calls.
- *
- * @param pathOrOptions - Service worker script path or a configuration object.
- * @throws if service workers are not supported or registration fails.
- */
-export async function setupServiceWorkerOnce(pathOrOptions) {
-    ensureServiceWorkerSupport();
-    const options = normalizeOptions(pathOrOptions);
-    return registerOnce(options);
-}
-/**
- * Returns an active service worker instance, optionally ensuring a specific
- * script path is registered before resolving.
- *
- * @param path - Optional service worker script path to register and prefer.
- * @throws if service workers are not supported or no active worker is available.
- */
-export async function getActiveServiceWorker(path) {
-    ensureServiceWorkerSupport();
-    const registration = path
-        ? await registerOnce(normalizeOptions(path))
-        : await navigator.serviceWorker.ready;
-    let serviceWorker = registration.active ||
-        registration.waiting ||
-        registration.installing ||
-        navigator.serviceWorker.controller;
-    if (!serviceWorker && path) {
-        const readyRegistration = await navigator.serviceWorker.ready;
-        serviceWorker =
-            readyRegistration.active ||
-                readyRegistration.waiting ||
-                readyRegistration.installing ||
-                navigator.serviceWorker.controller;
-    }
-    if (!serviceWorker) {
-        throw new Error("Service worker not ready yet");
-    }
-    return serviceWorker;
-}
-/**
- * Clears the cached registration promises.
- * Intended for tests to reset state between runs.
- */
-export const __resetServiceWorkerManager = () => {
-    registrations.clear();
-    handshakes = new WeakSet();
-};

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

@@ -1,63 +0,0 @@
-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 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(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
-    await registration.update();
-    const serviceWorker = registration.active || registration.waiting || registration.installing;
-    if (!serviceWorker) {
-        throw new Error("Failed to get service worker instance");
-    }
-    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/worker/errors.js

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

package/dist/esm/worker/expo/asyncStorageTaskQueue.js

@@ -1,74 +0,0 @@
-/**
- * AsyncStorage-backed TaskQueue for Expo/React Native.
- *
- * Persists inbox, outbox, and an optional config blob to AsyncStorage
- * so that data survives process restarts and can be shared between
- * foreground and background execution contexts.
- */
-export class AsyncStorageTaskQueue {
-    constructor(storage, prefix = "ark:task-queue") {
-        this.storage = storage;
-        this.inboxKey = `${prefix}:inbox`;
-        this.outboxKey = `${prefix}:outbox`;
-        this.configKey = `${prefix}:config`;
-    }
-    // ── Inbox ────────────────────────────────────────────────────────
-    async addTask(task) {
-        const tasks = await this.readList(this.inboxKey);
-        tasks.push(task);
-        await this.writeList(this.inboxKey, tasks);
-    }
-    async removeTask(id) {
-        const tasks = await this.readList(this.inboxKey);
-        await this.writeList(this.inboxKey, tasks.filter((t) => t.id !== id));
-    }
-    async getTasks(type) {
-        const tasks = await this.readList(this.inboxKey);
-        if (type) {
-            return tasks.filter((t) => t.type === type);
-        }
-        return tasks;
-    }
-    async clearTasks() {
-        await this.storage.removeItem(this.inboxKey);
-    }
-    // ── Outbox ───────────────────────────────────────────────────────
-    async pushResult(result) {
-        const results = await this.readList(this.outboxKey);
-        results.push(result);
-        await this.writeList(this.outboxKey, results);
-    }
-    async getResults() {
-        return this.readList(this.outboxKey);
-    }
-    async acknowledgeResults(ids) {
-        const idSet = new Set(ids);
-        const results = await this.readList(this.outboxKey);
-        await this.writeList(this.outboxKey, results.filter((r) => !idSet.has(r.id)));
-    }
-    // ── Config persistence (for background handler rehydration) ──────
-    /**
-     * Persist a config blob alongside the queue data.
-     * Used by @see ExpoWallet.setup to store the wallet parameters
-     * that the background handler needs to reconstruct providers.
-     */
-    async persistConfig(config) {
-        await this.storage.setItem(this.configKey, JSON.stringify(config));
-    }
-    /**
-     * Load the persisted config blob.
-     * Used by the background handler to rehydrate wallet dependencies.
-     */
-    async loadConfig() {
-        const raw = await this.storage.getItem(this.configKey);
-        return raw ? JSON.parse(raw) : null;
-    }
-    // ── Helpers ──────────────────────────────────────────────────────
-    async readList(key) {
-        const raw = await this.storage.getItem(key);
-        return raw ? JSON.parse(raw) : [];
-    }
-    async writeList(key, list) {
-        await this.storage.setItem(key, JSON.stringify(list));
-    }
-}

package/dist/esm/worker/expo/index.js

@@ -1,4 +0,0 @@
-export { InMemoryTaskQueue } from "./taskQueue.js";
-export { AsyncStorageTaskQueue } from "./asyncStorageTaskQueue.js";
-export { runTasks, createTaskDependencies } from "./taskRunner.js";
-export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE } from "./processors/index.js";

package/dist/esm/worker/expo/processors/contractPollProcessor.js

@@ -1,59 +0,0 @@
-import { warnAndFilterVtxosForScript, saveVtxosForContract, } from "../../../contracts/vtxoOwnership.js";
-export const CONTRACT_POLL_TASK_TYPE = "contract-poll";
-/**
- * Polls the indexer for the latest VTXO state of every contract and
- * persists the results to the wallet repository.
- *
- * Replicates the polling subset of @see ContractManager.initialize:
- * 1. Load all contracts from the contract repository.
- * 2. Paginated fetch of every VTXO (including spent) from the indexer.
- * 3. Extend each VTXO with tapscript data.
- * 4. Save to the wallet repository.
- *
- * NOTE: the indexer query deliberately omits `spendableOnly`. Every
- * repository implements `saveVtxos` as an upsert with no batch delete,
- * so filtering to spendable-only would leave VTXOs that became spent
- * between polls marked as spendable forever. Fetching the full set lets
- * the upsert overwrite stale records with their latest state.
- */
-export const contractPollProcessor = {
-    taskType: CONTRACT_POLL_TASK_TYPE,
-    async execute(item, deps) {
-        const { contractRepository, walletRepository, indexerProvider, extendVtxo, } = deps;
-        const contracts = await contractRepository.getContracts();
-        let contractsProcessed = 0;
-        let vtxosSaved = 0;
-        for (const contract of contracts) {
-            // Paginated fetch of spendable virtual outputs
-            const pageSize = 100;
-            let pageIndex = 0;
-            let hasMore = true;
-            const allVtxos = [];
-            while (hasMore) {
-                const { vtxos, page } = await indexerProvider.getVtxos({
-                    scripts: [contract.script],
-                    pageIndex,
-                    pageSize,
-                });
-                for (const vtxo of vtxos) {
-                    allVtxos.push(extendVtxo(vtxo, contract));
-                }
-                hasMore = page ? vtxos.length === pageSize : false;
-                pageIndex++;
-            }
-            // Skip wrong-script rows (legacy duplicates or indexer drift)
-            // before persisting; the loop must keep going for the remaining
-            // contracts even when one row is rejected.
-            const filtered = warnAndFilterVtxosForScript(allVtxos, contract.script, "contractPollProcessor");
-            await saveVtxosForContract(walletRepository, contract, filtered);
-            vtxosSaved += filtered.length;
-            contractsProcessed++;
-        }
-        return {
-            taskItemId: item.id,
-            type: CONTRACT_POLL_TASK_TYPE,
-            status: "success",
-            data: { contractsProcessed, vtxosSaved },
-        };
-    },
-};

package/dist/esm/worker/expo/processors/index.js

@@ -1 +0,0 @@
-export { contractPollProcessor, CONTRACT_POLL_TASK_TYPE, } from "./contractPollProcessor.js";

package/dist/esm/worker/expo/taskQueue.js

@@ -1,37 +0,0 @@
-/**
- * In-memory TaskQueue for testing and lightweight use.
- * State is lost when the process exits.
- */
-export class InMemoryTaskQueue {
-    constructor() {
-        this.inbox = new Map();
-        this.outbox = new Map();
-    }
-    async addTask(task) {
-        this.inbox.set(task.id, task);
-    }
-    async removeTask(id) {
-        this.inbox.delete(id);
-    }
-    async getTasks(type) {
-        const tasks = Array.from(this.inbox.values());
-        if (type) {
-            return tasks.filter((t) => t.type === type);
-        }
-        return tasks;
-    }
-    async clearTasks() {
-        this.inbox.clear();
-    }
-    async pushResult(result) {
-        this.outbox.set(result.id, result);
-    }
-    async getResults() {
-        return Array.from(this.outbox.values());
-    }
-    async acknowledgeResults(ids) {
-        for (const id of ids) {
-            this.outbox.delete(id);
-        }
-    }
-}

package/dist/esm/worker/expo/taskRunner.js

@@ -1,69 +0,0 @@
-import { getRandomId, extendVirtualCoinForContract } from "../../wallet/utils.js";
-/**
- * Run all pending tasks from the queue through matching processors.
- *
- * For each task in the inbox:
- * 1. Find the processor whose `taskType` matches `task.type`.
- * 2. Execute it, producing a @see TaskResult.
- * 3. Push the result to the outbox and remove the task from the inbox.
- *
- * Tasks with no matching processor produce a `"noop"` result.
- * Processor errors produce a `"failed"` result with the error message.
- */
-export async function runTasks(queue, processors, deps) {
-    const tasks = await queue.getTasks();
-    const processorMap = new Map(processors.map((p) => [p.taskType, p]));
-    const results = [];
-    for (const task of tasks) {
-        const processor = processorMap.get(task.type);
-        let partial;
-        if (!processor) {
-            partial = {
-                taskItemId: task.id,
-                type: task.type,
-                status: "noop",
-            };
-        }
-        else {
-            try {
-                partial = await processor.execute(task, deps);
-            }
-            catch (error) {
-                partial = {
-                    taskItemId: task.id,
-                    type: task.type,
-                    status: "failed",
-                    data: {
-                        error: error instanceof Error
-                            ? error.message
-                            : String(error),
-                    },
-                };
-            }
-        }
-        const result = {
-            ...partial,
-            id: getRandomId(),
-            executedAt: Date.now(),
-        };
-        await queue.pushResult(result);
-        await queue.removeTask(task.id);
-        results.push(result);
-    }
-    return results;
-}
-/**
- * Build the @see TaskDependencies needed by task processors
- * (e.g. `src/worker/expo/processors/contractPollProcessor.ts`)
- *
- * This is the same construction that `defineExpoBackgroundTask` does
- * internally, extracted so that consumers with custom schedulers
- * (e.g. bare React Native with `react-native-background-fetch`)
- * can build deps without depending on Expo.
- */
-export function createTaskDependencies(options) {
-    return {
-        ...options,
-        extendVtxo: (vtxo, contract) => extendVirtualCoinForContract(vtxo, contract),
-    };
-}