@arkade-os/sdk 0.4.27 → 0.4.29

package/dist/esm/worker/messageBus.js

@@ -1,470 +0,0 @@
-/// <reference lib="webworker" />
-import { getActiveServiceWorker, setupServiceWorkerOnce, } from "./browser/service-worker-manager.js";
-import { RestArkProvider } from "../providers/ark.js";
-import { RestDelegatorProvider } from "../providers/delegator.js";
-import { hydrateIdentity, isSigningSerialized, normalizeSerializedIdentity, } from "../identity/index.js";
-import { ReadonlyWallet, Wallet } from "../wallet/wallet.js";
-import { MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from "./errors.js";
-/**
- * Grace period after a handler times out during which late handler
- * completion is still delivered to the client. Once this expires,
- * the bus sends an "Operation abandoned" error so the message id
- * never goes silent indefinitely.
- */
-const LATE_DELIVERY_GRACE_MS = 5 * 60000;
-export class MessageBus {
-    /** Create the service-worker message bus with repositories and handler configuration. */
-    constructor(walletRepository, contractRepository, { messageHandlers, tickIntervalMs = 10000, messageTimeoutMs = 30000, messageTimeoutOverrides = {}, debug = false, buildServices, }) {
-        this.walletRepository = walletRepository;
-        this.contractRepository = contractRepository;
-        this.lateDeliveries = new Set();
-        this.running = false;
-        this.tickTimeout = null;
-        this.tickInProgress = false;
-        this.debug = false;
-        this.initialized = false;
-        this.boundOnMessage = this.onMessage.bind(this);
-        this.handlers = new Map(messageHandlers.map((u) => [u.messageTag, u]));
-        this.tickIntervalMs = tickIntervalMs;
-        this.messageTimeoutMs = messageTimeoutMs;
-        this.constructorTimeoutOverrides = { ...messageTimeoutOverrides };
-        this.messageTimeoutOverrides = { ...this.constructorTimeoutOverrides };
-        this.debug = debug;
-        this.buildServicesFn = buildServices ?? this.buildServices.bind(this);
-    }
-    /** Start the message bus and attach service-worker event listeners. */
-    async start() {
-        if (this.running)
-            return;
-        this.running = true;
-        if (this.debug)
-            console.log("MessageBus starting");
-        // Hook message routing
-        self.addEventListener("message", this.boundOnMessage);
-        // activate service worker immediately
-        self.addEventListener("install", () => {
-            self.skipWaiting();
-        });
-        // take control of clients immediately
-        self.addEventListener("activate", () => {
-            self.clients.claim();
-            if (this.initialized) {
-                this.runTick();
-            }
-        });
-    }
-    /** Stop the message bus, cancel ticks, and stop all registered handlers. */
-    async stop() {
-        if (this.debug)
-            console.log("MessageBus stopping");
-        this.running = false;
-        this.tickInProgress = false;
-        this.initialized = false;
-        if (this.tickTimeout !== null) {
-            self.clearTimeout(this.tickTimeout);
-            this.tickTimeout = null;
-        }
-        for (const record of this.lateDeliveries) {
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-        }
-        this.lateDeliveries.clear();
-        self.removeEventListener("message", this.boundOnMessage);
-        await Promise.all(Array.from(this.handlers.values()).map((updater) => updater.stop()));
-    }
-    scheduleNextTick() {
-        if (!this.running)
-            return;
-        if (this.tickTimeout !== null)
-            return;
-        if (this.tickInProgress)
-            return;
-        this.tickTimeout = self.setTimeout(() => this.runTick(), this.tickIntervalMs);
-    }
-    async runTick() {
-        if (!this.running)
-            return;
-        if (this.tickInProgress)
-            return;
-        this.tickInProgress = true;
-        if (this.tickTimeout !== null) {
-            self.clearTimeout(this.tickTimeout);
-            this.tickTimeout = null;
-        }
-        try {
-            const now = Date.now();
-            for (const updater of this.handlers.values()) {
-                try {
-                    const tickLabel = `${updater.messageTag}:tick`;
-                    const response = await this.withTimeout(updater.tick(now), this.resolveTimeoutMs(tickLabel, updater.messageTag), tickLabel);
-                    if (this.debug)
-                        console.log(`[${updater.messageTag}] outgoing tick response:`, response);
-                    if (response && response.length > 0) {
-                        self.clients
-                            .matchAll({
-                            includeUncontrolled: true,
-                            type: "window",
-                        })
-                            .then((clients) => {
-                            for (const message of response) {
-                                clients.forEach((client) => {
-                                    client.postMessage(message);
-                                });
-                            }
-                        });
-                    }
-                }
-                catch (err) {
-                    if (this.debug)
-                        console.error(`[${updater.messageTag}] tick failed`, err);
-                }
-            }
-        }
-        finally {
-            this.tickInProgress = false;
-            this.scheduleNextTick();
-        }
-    }
-    async waitForInit(config) {
-        if (this.initialized) {
-            // Stop existing handlers before re-initializing.
-            // This handles the case where CLEAR was called, which nullifies
-            // handler state (readonlyWallet, etc.) without resetting the
-            // initialized flag. Without this, handlers never get start()
-            // called again and all messages fail with "not initialized".
-            //
-            // Clear the flag first so onMessage() rejects incoming messages
-            // during the stop/start window instead of routing them to
-            // half-reset handlers. Restored to true after start() completes.
-            this.initialized = false;
-            await Promise.all(Array.from(this.handlers.values()).map((h) => h.stop().catch(() => { })));
-        }
-        // Recompute the active timeout map from scratch so a prior init's
-        // keys cannot linger after re-init with a smaller map.
-        this.messageTimeoutOverrides = {
-            ...this.constructorTimeoutOverrides,
-            ...(config.messageTimeouts ?? {}),
-        };
-        const services = await this.buildServicesFn(config);
-        // Start all handlers
-        for (const updater of this.handlers.values()) {
-            if (this.debug)
-                console.log(`Starting updater: ${updater.messageTag}`);
-            await updater.start(services, {
-                walletRepository: this.walletRepository,
-            });
-        }
-        // Kick off scheduler
-        this.scheduleNextTick();
-        this.initialized = true;
-    }
-    async buildServices(config) {
-        const arkProvider = new RestArkProvider(config.arkServer.url);
-        const storage = {
-            walletRepository: this.walletRepository,
-            contractRepository: this.contractRepository,
-        };
-        const delegatorProvider = config.delegatorUrl
-            ? new RestDelegatorProvider(config.delegatorUrl)
-            : undefined;
-        const serialized = normalizeSerializedIdentity(config.wallet);
-        if (isSigningSerialized(serialized)) {
-            const identity = hydrateIdentity(serialized);
-            const wallet = await Wallet.create({
-                identity,
-                arkServerUrl: config.arkServer.url,
-                arkServerPublicKey: config.arkServer.publicKey,
-                indexerUrl: config.indexerUrl,
-                esploraUrl: config.esploraUrl,
-                storage,
-                delegatorProvider,
-                settlementConfig: config.settlementConfig,
-                walletMode: config.walletMode,
-                watcherConfig: config.watcherConfig,
-            });
-            return { wallet, arkProvider, readonlyWallet: wallet };
-        }
-        const identity = hydrateIdentity(serialized);
-        const readonlyWallet = await ReadonlyWallet.create({
-            identity,
-            arkServerUrl: config.arkServer.url,
-            arkServerPublicKey: config.arkServer.publicKey,
-            indexerUrl: config.indexerUrl,
-            esploraUrl: config.esploraUrl,
-            storage,
-            delegatorProvider,
-            watcherConfig: config.watcherConfig,
-        });
-        return { readonlyWallet, arkProvider };
-    }
-    onMessage(event) {
-        // Keep the service worker alive while async work is pending.
-        // Without this, the browser may terminate the SW mid-operation,
-        // causing all pending responses to be lost silently.
-        const promise = this.processMessage(event);
-        if (typeof event.waitUntil === "function") {
-            event.waitUntil(promise);
-        }
-        return promise;
-    }
-    async processMessage(event) {
-        const { id, tag, broadcast } = event.data;
-        if (tag === "PING") {
-            this.deliverResponse(event.source, { id, tag: "PONG" }, { id, tag: "PONG" });
-            return;
-        }
-        if (tag === "INITIALIZE_MESSAGE_BUS") {
-            if (this.debug) {
-                console.log("Init Command received");
-            }
-            // Intentionally not wrapped with withTimeout: initialization
-            // performs network calls (buildServices) and handler startup
-            // that may legitimately exceed the message timeout.
-            await this.waitForInit(event.data.config);
-            this.deliverResponse(event.source, { id, tag }, { id, tag });
-            if (this.debug) {
-                console.log("MessageBus initialized");
-            }
-            return;
-        }
-        if (!this.initialized) {
-            if (this.debug)
-                console.warn("Event received before initialization, dropping", event.data);
-            // Send error response so the caller's promise rejects instead of
-            // hanging forever. This happens when the browser kills and restarts
-            // the service worker — the new instance has initialized=false and
-            // messages arrive before INITIALIZE_MESSAGE_BUS is re-sent.
-            const fallbackTag = tag ?? "unknown";
-            this.deliverResponse(event.source, {
-                id,
-                tag: fallbackTag,
-                error: new MessageBusNotInitializedError(),
-            }, { id, tag: fallbackTag });
-            return;
-        }
-        if (!id || !tag) {
-            if (this.debug)
-                console.error("Invalid message received, missing required fields:", event.data);
-            const fallbackTag = tag ?? "unknown";
-            this.deliverResponse(event.source, {
-                id,
-                tag: fallbackTag,
-                error: new TypeError("Invalid message received, missing required fields"),
-            }, { id, tag: fallbackTag });
-            return;
-        }
-        const messageType = this.extractMessageType(event.data);
-        if (broadcast) {
-            const updaters = Array.from(this.handlers.values());
-            const entries = updaters.map((updater) => {
-                const label = this.labelFor(messageType, updater.messageTag);
-                const timeoutMs = this.resolveTimeoutMs(messageType, updater.messageTag);
-                const handlerPromise = updater.handleMessage(event.data);
-                const raced = updater.isLongRunning?.(event.data)
-                    ? handlerPromise
-                    : this.withTimeout(handlerPromise, timeoutMs, label);
-                return { updater, handlerPromise, raced };
-            });
-            const results = await Promise.allSettled(entries.map((e) => e.raced));
-            results.forEach((result, index) => {
-                const { updater, handlerPromise } = entries[index];
-                const handlerTag = updater.messageTag;
-                const context = { id, tag: handlerTag, messageType };
-                if (result.status === "fulfilled") {
-                    const response = result.value;
-                    // Always deliver a response so the caller's message id
-                    // never goes silent. Handlers returning null/undefined
-                    // get an explicit ack envelope.
-                    this.deliverResponse(event.source, response ?? { id, tag: handlerTag }, context);
-                }
-                else {
-                    if (this.debug)
-                        console.error(`[${handlerTag}] handleMessage failed`, result.reason);
-                    const error = toError(result.reason);
-                    this.deliverResponse(event.source, { id, tag: handlerTag, error }, context);
-                    // If the error was a timeout, keep watching the
-                    // underlying handler and surface its eventual result
-                    // under the same id.
-                    if (result.reason instanceof ServiceWorkerTimeoutError) {
-                        this.attachLateDelivery(handlerPromise, event.source, id, handlerTag, messageType);
-                    }
-                }
-            });
-            return;
-        }
-        const updater = this.handlers.get(tag);
-        if (!updater) {
-            if (this.debug)
-                console.warn(`[${tag}] unknown message tag, ignoring message`);
-            this.deliverResponse(event.source, {
-                id,
-                tag,
-                error: new Error(`Unknown handler tag: ${tag}`),
-            }, { id, tag, messageType });
-            return;
-        }
-        const label = this.labelFor(messageType, tag);
-        const timeoutMs = this.resolveTimeoutMs(messageType, tag);
-        const handlerPromise = updater.handleMessage(event.data);
-        const context = { id, tag, messageType };
-        try {
-            const response = updater.isLongRunning?.(event.data)
-                ? await handlerPromise
-                : await this.withTimeout(handlerPromise, timeoutMs, label);
-            if (this.debug)
-                console.log(`[${tag}] outgoing response:`, response);
-            // Always deliver a response so the caller's message id never
-            // goes silent. A handler returning null/undefined yields an
-            // explicit ack envelope.
-            this.deliverResponse(event.source, response ?? { id, tag }, context);
-        }
-        catch (err) {
-            if (this.debug)
-                console.error(`[${tag}] handleMessage failed`, err);
-            const error = toError(err);
-            this.deliverResponse(event.source, { id, tag, error }, context);
-            // When we abandoned the handler via timeout, keep watching it
-            // so the client's message id eventually gets a final response.
-            if (err instanceof ServiceWorkerTimeoutError) {
-                this.attachLateDelivery(handlerPromise, event.source, id, tag, messageType);
-            }
-        }
-    }
-    /**
-     * Race `promise` against a timeout. Note: this does NOT cancel the
-     * underlying work — the original promise keeps running. Call
-     * `attachLateDelivery` after catching the timeout to surface the
-     * eventual result so the message id does not go silent.
-     */
-    withTimeout(promise, timeoutMs, label) {
-        if (timeoutMs <= 0)
-            return promise;
-        return new Promise((resolve, reject) => {
-            const timer = self.setTimeout(() => {
-                reject(new ServiceWorkerTimeoutError(`Message handler timed out after ${timeoutMs}ms (${label})`));
-            }, timeoutMs);
-            promise.then((val) => {
-                self.clearTimeout(timer);
-                resolve(val);
-            }, (err) => {
-                self.clearTimeout(timer);
-                reject(err);
-            });
-        });
-    }
-    /**
-     * Extract the declared `type` from a request envelope (e.g. "SETTLE").
-     * Not every envelope carries a type (PING/INIT are special cased
-     * earlier), so this returns undefined for envelopes that lack one.
-     */
-    extractMessageType(data) {
-        const maybeType = data.type;
-        return typeof maybeType === "string" ? maybeType : undefined;
-    }
-    /**
-     * Resolve the timeout for an operation. Message-type overrides take
-     * precedence over handler-tag overrides, with the bus-wide default
-     * (`messageTimeoutMs`) as the final fallback.
-     */
-    resolveTimeoutMs(messageType, handlerTag) {
-        if (messageType &&
-            Object.prototype.hasOwnProperty.call(this.messageTimeoutOverrides, messageType)) {
-            return this.messageTimeoutOverrides[messageType];
-        }
-        if (Object.prototype.hasOwnProperty.call(this.messageTimeoutOverrides, handlerTag)) {
-            return this.messageTimeoutOverrides[handlerTag];
-        }
-        return this.messageTimeoutMs;
-    }
-    /**
-     * Build a human-readable label for timeout errors. Format:
-     * `"<MESSAGE_TYPE> via <HANDLER_TAG>"` when both are known, else the
-     * handler tag alone. Used so timeout errors name the operation the
-     * client actually triggered (e.g. SETTLE) rather than just the
-     * handler that received it (e.g. WALLET_UPDATER).
-     */
-    labelFor(messageType, handlerTag) {
-        return messageType ? `${messageType} via ${handlerTag}` : handlerTag;
-    }
-    /**
-     * Post a response to the originating client. When `source` is null
-     * (client tab closed, detached frame, etc.) the response cannot be
-     * delivered; we log the drop in debug mode so it is not invisible.
-     */
-    deliverResponse(source, response, context) {
-        if (!source) {
-            if (this.debug)
-                console.warn(`[${context.tag}] cannot deliver response: event.source is null`, {
-                    id: context.id,
-                    messageType: context.messageType,
-                });
-            return;
-        }
-        source.postMessage(response);
-    }
-    /**
-     * After a handler times out the client has already received a timeout
-     * error, but the handler keeps running. Attach a follow-up so the
-     * handler's eventual result (or error) is delivered under the same
-     * message id, or — if the handler never completes within
-     * {@link LATE_DELIVERY_GRACE_MS} — an "Operation abandoned" error is
-     * sent so the client's listener (if still attached) does not hang.
-     */
-    attachLateDelivery(handlerPromise, source, id, tag, messageType) {
-        const context = { id, tag, messageType };
-        const record = {
-            settled: false,
-            deadline: self.setTimeout(() => {
-                if (record.settled)
-                    return;
-                record.settled = true;
-                this.lateDeliveries.delete(record);
-                this.deliverResponse(source, {
-                    id,
-                    tag,
-                    error: new Error(`Operation abandoned: handler did not complete within ${LATE_DELIVERY_GRACE_MS}ms after timeout (${this.labelFor(messageType, tag)})`),
-                }, context);
-            }, LATE_DELIVERY_GRACE_MS),
-        };
-        this.lateDeliveries.add(record);
-        handlerPromise.then((response) => {
-            if (record.settled)
-                return;
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-            this.lateDeliveries.delete(record);
-            this.deliverResponse(source, response ?? { id, tag }, context);
-        }, (err) => {
-            if (record.settled)
-                return;
-            record.settled = true;
-            self.clearTimeout(record.deadline);
-            this.lateDeliveries.delete(record);
-            this.deliverResponse(source, { id, tag, error: toError(err) }, context);
-        });
-    }
-    /**
-     * Returns the registered SW for the path.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static async getServiceWorker(path) {
-        return getActiveServiceWorker(path);
-    }
-    /**
-     * Set up and register the Service Worker, ensuring it's done once at most.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static async setup(path) {
-        await setupServiceWorkerOnce(path);
-        return getActiveServiceWorker(path);
-    }
-}
-function toError(value) {
-    return value instanceof Error ? value : new Error(String(value));
-}

package/dist/types/adapters/asyncStorage.d.ts

@@ -1,2 +0,0 @@
-export { AsyncStorageAdapter } from "../storage/asyncStorage.js";
-export type { StorageAdapter } from "../storage/index.js";

package/dist/types/adapters/expo.d.ts

@@ -1,4 +0,0 @@
-export { ExpoArkProvider } from "../providers/expoArk.js";
-export { ExpoIndexerProvider } from "../providers/expoIndexer.js";
-export type { ArkProvider } from "../providers/ark.js";
-export type { IndexerProvider } from "../providers/indexer.js";

package/dist/types/adapters/fileSystem.d.ts

@@ -1,2 +0,0 @@
-export { FileSystemStorageAdapter } from "../storage/fileSystem.js";
-export type { StorageAdapter } from "../storage/index.js";

package/dist/types/adapters/indexedDB.d.ts

@@ -1,2 +0,0 @@
-export { IndexedDBStorageAdapter } from "../storage/indexedDB.js";
-export type { StorageAdapter } from "../storage/index.js";

package/dist/types/adapters/localStorage.d.ts

@@ -1,2 +0,0 @@
-export { LocalStorageAdapter } from "../storage/localStorage.js";
-export type { StorageAdapter } from "../storage/index.js";

package/dist/types/arkfee/celenv.d.ts

@@ -1,25 +0,0 @@
-import { Environment } from "@marcbachmann/cel-js";
-/**
- * Variable names used in CEL expressions
- */
-export declare const AmountVariableName = "amount";
-export declare const ExpiryVariableName = "expiry";
-export declare const BirthVariableName = "birth";
-export declare const WeightVariableName = "weight";
-export declare const InputTypeVariableName = "inputType";
-export declare const OutputScriptVariableName = "script";
-/**
- * IntentOutputEnv is the CEL environment for output fee calculation
- * Variables: amount, script
- */
-export declare const IntentOutputEnv: Environment;
-/**
- * IntentOffchainInputEnv is the CEL environment for offchain input fee calculation
- * Variables: amount, expiry, birth, weight, inputType
- */
-export declare const IntentOffchainInputEnv: Environment;
-/**
- * IntentOnchainInputEnv is the CEL environment for onchain input fee calculation
- * Variables: amount
- */
-export declare const IntentOnchainInputEnv: Environment;

package/dist/types/arkfee/estimator.d.ts

@@ -1,49 +0,0 @@
-import { IntentFeeConfig, OffchainInput, OnchainInput, FeeOutput, FeeAmount } from "./types.js";
-/**
- * Estimator evaluates CEL expressions to calculate fees for Arkade intents
- */
-export declare class Estimator {
-    readonly config: IntentFeeConfig;
-    private intentOffchainInput?;
-    private intentOnchainInput?;
-    private intentOffchainOutput?;
-    private intentOnchainOutput?;
-    /**
-     * Creates a new Estimator with the given config
-     * @param config - Configuration containing CEL programs for fee calculation
-     */
-    constructor(config: IntentFeeConfig);
-    /**
-     * Evaluates the fee for a given vtxo input
-     * @param input - The offchain input to evaluate
-     * @returns The fee amount for this input
-     */
-    evalOffchainInput(input: OffchainInput): FeeAmount;
-    /**
-     * Evaluates the fee for a given boarding input
-     * @param input - The onchain input to evaluate
-     * @returns The fee amount for this input
-     */
-    evalOnchainInput(input: OnchainInput): FeeAmount;
-    /**
-     * Evaluates the fee for a given vtxo output
-     * @param output - The output to evaluate
-     * @returns The fee amount for this output
-     */
-    evalOffchainOutput(output: FeeOutput): FeeAmount;
-    /**
-     * Evaluates the fee for a given collaborative exit output
-     * @param output - The output to evaluate
-     * @returns The fee amount for this output
-     */
-    evalOnchainOutput(output: FeeOutput): FeeAmount;
-    /**
-     * Evaluates the fee for a given set of inputs and outputs
-     * @param offchainInputs - Array of offchain inputs to evaluate
-     * @param onchainInputs - Array of onchain inputs to evaluate
-     * @param offchainOutputs - Array of offchain outputs to evaluate
-     * @param onchainOutputs - Array of onchain outputs to evaluate
-     * @returns The total fee amount
-     */
-    eval(offchainInputs: OffchainInput[], onchainInputs: OnchainInput[], offchainOutputs: FeeOutput[], onchainOutputs: FeeOutput[]): FeeAmount;
-}

package/dist/types/arkfee/index.d.ts

@@ -1,2 +0,0 @@
-export { Estimator } from "./estimator.js";
-export type { FeeAmount, IntentFeeConfig, OffchainInput, OnchainInput, FeeOutput, VtxoType, } from "./types.js";

package/dist/types/arkfee/types.d.ts

@@ -1,38 +0,0 @@
-/**
- * FeeAmount is a wrapper around a number that represents a fee amount in satoshis floating point.
- * @param value - The fee amount in floating point.
- * @example
- * const fee = new FeeAmount(1.23456789);
- * console.log(fee.value); // 1.23456789
- * console.log(fee.satoshis); // 2
- */
-export declare class FeeAmount {
-    readonly value: number;
-    static ZERO: FeeAmount;
-    constructor(value: number);
-    /** Returns the fee amount rounded up to whole satoshis. */
-    get satoshis(): number;
-    /** Add two fee amounts together. */
-    add(other: FeeAmount): FeeAmount;
-}
-export interface IntentFeeConfig {
-    offchainInput?: string;
-    onchainInput?: string;
-    offchainOutput?: string;
-    onchainOutput?: string;
-}
-export type VtxoType = "recoverable" | "vtxo" | "note";
-export interface OffchainInput {
-    amount: bigint;
-    expiry?: Date;
-    birth?: Date;
-    type: VtxoType;
-    weight: number;
-}
-export interface OnchainInput {
-    amount: bigint;
-}
-export interface FeeOutput {
-    amount: bigint;
-    script: string;
-}