@arkade-os/sdk 0.4.27 → 0.4.28

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

@@ -1,1169 +0,0 @@
-import { hex } from "@scure/base";
-import { serializeReadonlyIdentity, serializeSigningIdentity, } from "../../identity/index.js";
-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 { MESSAGE_BUS_NOT_INITIALIZED, ServiceWorkerTimeoutError, } from "../../worker/errors.js";
-import { getArkadeServerUrl } from "../wallet.js";
-// Check by error message content 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.message.includes(MESSAGE_BUS_NOT_INITIALIZED));
-}
-export const DEFAULT_MESSAGE_TIMEOUTS = {
-    // Fast reads — fail quickly
-    GET_ADDRESS: 10000,
-    GET_BALANCE: 10000,
-    GET_BOARDING_ADDRESS: 10000,
-    GET_STATUS: 10000,
-    GET_DELEGATE_INFO: 10000,
-    IS_CONTRACT_MANAGER_WATCHING: 10000,
-    // Medium reads — may involve indexer queries
-    GET_VTXOS: 20000,
-    GET_BOARDING_UTXOS: 20000,
-    GET_TRANSACTION_HISTORY: 20000,
-    GET_CONTRACTS: 20000,
-    GET_CONTRACTS_WITH_VTXOS: 20000,
-    ANNOTATE_VTXOS: 20000,
-    GET_SPENDABLE_PATHS: 20000,
-    GET_ALL_SPENDING_PATHS: 20000,
-    GET_ASSET_DETAILS: 20000,
-    GET_EXPIRING_VTXOS: 20000,
-    GET_EXPIRED_BOARDING_UTXOS: 20000,
-    GET_RECOVERABLE_BALANCE: 20000,
-    RELOAD_WALLET: 20000,
-    // Transactions — need more headroom.
-    // SETTLE / RECOVER_VTXOS / RENEW_VTXOS go through the streaming path and
-    // are treated as long-running on both sides of the bus: the values below
-    // are retained only for type completeness and are never enforced.
-    SEND_BITCOIN: 50000,
-    SEND: 50000,
-    SETTLE: 50000,
-    ISSUE: 50000,
-    REISSUE: 50000,
-    BURN: 50000,
-    DELEGATE: 50000,
-    RECOVER_VTXOS: 50000,
-    RENEW_VTXOS: 50000,
-    SWEEP_EXPIRED_BOARDING_UTXOS: 50000,
-    // Misc writes
-    INIT_WALLET: 30000,
-    CLEAR: 10000,
-    SIGN_TRANSACTION: 30000,
-    CREATE_CONTRACT: 30000,
-    UPDATE_CONTRACT: 30000,
-    DELETE_CONTRACT: 10000,
-    REFRESH_VTXOS: 30000,
-    REFRESH_OUTPOINTS: 30000,
-};
-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",
-    "ANNOTATE_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);
-}
-function isSigningCapable(identity) {
-    const candidate = identity;
-    return (typeof candidate.signMessage === "function" &&
-        typeof candidate.sign === "function" &&
-        typeof candidate.signerSession === "function");
-}
-class ServiceWorkerReadonlyAssetManager {
-    constructor(sendMessage, messageTag) {
-        this.sendMessage = sendMessage;
-        this.messageTag = messageTag;
-    }
-    async getAssetDetails(assetId) {
-        const message = {
-            tag: this.messageTag,
-            type: "GET_ASSET_DETAILS",
-            id: getRandomId(),
-            payload: { assetId },
-        };
-        const response = await this.sendMessage(message);
-        return response.payload.assetDetails;
-    }
-}
-class ServiceWorkerAssetManager extends ServiceWorkerReadonlyAssetManager {
-    async issue(params) {
-        const message = {
-            tag: this.messageTag,
-            type: "ISSUE",
-            id: getRandomId(),
-            payload: { params },
-        };
-        const response = await this.sendMessage(message);
-        return response.payload.result;
-    }
-    async reissue(params) {
-        const message = {
-            tag: this.messageTag,
-            type: "REISSUE",
-            id: getRandomId(),
-            payload: { params },
-        };
-        const response = await this.sendMessage(message);
-        return response.payload.txid;
-    }
-    async burn(params) {
-        const message = {
-            tag: this.messageTag,
-            type: "BURN",
-            id: getRandomId(),
-            payload: { params },
-        };
-        const response = await this.sendMessage(message);
-        return response.payload.txid;
-    }
-}
-const initializeMessageBus = (serviceWorker, config, timeoutMs = 2000) => {
-    const initCmd = {
-        tag: "INITIALIZE_MESSAGE_BUS",
-        id: getRandomId(),
-        config: { ...config, timeoutMs },
-    };
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            navigator.serviceWorker.removeEventListener("message", onMessage);
-            clearTimeout(timeoutId);
-        };
-        const onMessage = (event) => {
-            const response = event.data;
-            if (response?.id !== initCmd.id)
-                return;
-            cleanup();
-            if (response.error) {
-                reject(response.error);
-            }
-            else {
-                resolve();
-            }
-        };
-        const timeoutId = setTimeout(() => {
-            cleanup();
-            reject(new ServiceWorkerTimeoutError("MessageBus timed out"));
-        }, timeoutMs);
-        navigator.serviceWorker.addEventListener("message", onMessage);
-        serviceWorker.postMessage(initCmd);
-    });
-};
-export class ServiceWorkerReadonlyWallet {
-    get assetManager() {
-        return this._readonlyAssetManager;
-    }
-    constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag) {
-        this.serviceWorker = serviceWorker;
-        this.messageTag = messageTag;
-        this.initConfig = null;
-        this.initWalletPayload = null;
-        this.messageTimeouts = DEFAULT_MESSAGE_TIMEOUTS;
-        this.reinitPromise = null;
-        this.pingPromise = null;
-        this.inflightRequests = new Map();
-        this.identity = identity;
-        this.walletRepository = walletRepository;
-        this.contractRepository = contractRepository;
-        this._readonlyAssetManager = new ServiceWorkerReadonlyAssetManager((msg) => this.sendMessage(msg), messageTag);
-    }
-    getTimeoutForRequest(request) {
-        return this.messageTimeouts[request.type] ?? 30000;
-    }
-    /**
-     * Create a readonly service-worker wallet bound to an already-registered worker.
-     *
-     * @param options - Service worker, identity, and backend configuration
-     * @returns Initialized readonly service-worker wallet
-     * @throws Error if service-worker initialization fails
-     */
-    static async create(options) {
-        const walletRepository = options.storage?.walletRepository ??
-            new IndexedDBWalletRepository();
-        const contractRepository = options.storage?.contractRepository ??
-            new IndexedDBContractRepository();
-        const messageTag = options.walletUpdaterTag ?? DEFAULT_MESSAGE_TAG;
-        // Create the wallet instance
-        const wallet = new ServiceWorkerReadonlyWallet(options.serviceWorker, options.identity, walletRepository, contractRepository, messageTag);
-        const serializedWallet = await serializeReadonlyIdentity(options.identity);
-        // INIT_WALLET retains the legacy `key` payload for wire compatibility
-        // with older workers; the current handler does not read it.
-        const publicKey = await options.identity
-            .compressedPublicKey()
-            .then(hex.encode);
-        const initWalletPayload = {
-            key: { publicKey },
-            arkServerUrl: getArkadeServerUrl(options),
-            arkServerPublicKey: options.arkServerPublicKey,
-            delegatorUrl: options.delegatorUrl,
-        };
-        // Precompute the merged timeout map so page-side waiting and
-        // worker-side enforcement are derived from the same source.
-        const messageTimeouts = options.messageTimeouts
-            ? {
-                ...DEFAULT_MESSAGE_TIMEOUTS,
-                ...options.messageTimeouts,
-            }
-            : DEFAULT_MESSAGE_TIMEOUTS;
-        const busInitConfig = {
-            wallet: serializedWallet,
-            arkServer: {
-                url: getArkadeServerUrl(options),
-                publicKey: options.arkServerPublicKey,
-            },
-            delegatorUrl: options.delegatorUrl,
-            indexerUrl: options.indexerUrl,
-            esploraUrl: options.esploraUrl,
-            watcherConfig: options.watcherConfig,
-            messageTimeouts,
-        };
-        // Bootstrap the MessageBus in the service worker
-        await initializeMessageBus(options.serviceWorker, { ...busInitConfig, timeoutMs: options.messageBusTimeoutMs }, options.messageBusTimeoutMs);
-        // Initialize the wallet handler
-        const initMessage = {
-            tag: messageTag,
-            type: "INIT_WALLET",
-            id: getRandomId(),
-            payload: initWalletPayload,
-        };
-        await wallet.sendMessage(initMessage);
-        // Persist the full init config (including messageTimeouts) so
-        // reinitialize() re-sends the same map to a restarted worker.
-        wallet.initConfig = busInitConfig;
-        wallet.initWalletPayload = initWalletPayload;
-        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
-        wallet.messageTimeouts = messageTimeouts;
-        return wallet;
-    }
-    /**
-     * Simplified setup method that handles service worker registration
-     * and wallet initialization automatically.
-     *
-     * @see ServiceWorkerReadonlyWallet.create
-     *
-     * @example
-     * ```typescript
-     * const wallet = await ServiceWorkerReadonlyWallet.setup({
-     *   serviceWorkerPath: '/service-worker.js',
-     *   arkServerUrl: 'https://arkade.computer',
-     *   identity: ReadonlySingleKey.fromPublicKey('your_public_key_hex')
-     * });
-     * ```
-     */
-    static async setup(options) {
-        // Register and setup the service worker
-        const serviceWorker = await setupServiceWorker({
-            path: options.serviceWorkerPath,
-            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
-        });
-        // Use the existing create method
-        return await ServiceWorkerReadonlyWallet.create({
-            ...options,
-            serviceWorker,
-        });
-    }
-    sendMessageDirect(request, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                clearTimeout(timeoutId);
-                navigator.serviceWorker.removeEventListener("message", messageHandler);
-            };
-            const timeoutId = setTimeout(() => {
-                cleanup();
-                reject(new ServiceWorkerTimeoutError(`Service worker message timed out (${request.type})`));
-            }, timeoutMs);
-            const messageHandler = (event) => {
-                const response = event.data;
-                if (request.id !== response.id) {
-                    return;
-                }
-                cleanup();
-                if (response.error) {
-                    reject(response.error);
-                }
-                else {
-                    resolve(response);
-                }
-            };
-            navigator.serviceWorker.addEventListener("message", messageHandler);
-            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. No inactivity deadline:
-    // settlement-class flows surrender control to remote peers and can sit
-    // idle for long stretches between protocol events. Service-worker death
-    // is detected out-of-band via concurrent short requests that surface
-    // MESSAGE_BUS_NOT_INITIALIZED.
-    sendMessageStreaming(request, onEvent, isComplete) {
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                navigator.serviceWorker.removeEventListener("message", messageHandler);
-            };
-            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 {
-                    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 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 timeoutMs = this.getTimeoutForRequest(request);
-        const maxRetries = 2;
-        for (let attempt = 0;; attempt++) {
-            try {
-                return await this.sendMessageDirect(request, timeoutMs);
-            }
-            catch (error) {
-                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();
-            }
-        }
-    }
-    /**
-     * Produce a serialized envelope for the wallet's identity. The base
-     * class always emits a readonly envelope; `ServiceWorkerWallet`
-     * overrides to emit a signing envelope.
-     */
-    async serializeIdentity() {
-        return serializeReadonlyIdentity(this.identity);
-    }
-    /**
-     * Return the cached init config, or rebuild one from live instance
-     * state when the cache was never populated. Recovery path for
-     * SDK-factory-created wallets; manual constructor bypasses do not
-     * retain enough state here and will hit the "never initialized" throw.
-     */
-    async buildInitConfig() {
-        if (this.initConfig)
-            return this.initConfig;
-        if (!this.arkServerUrl) {
-            throw new Error("Cannot re-initialize: wallet was not initialized via the SDK factory");
-        }
-        const wallet = await this.serializeIdentity();
-        this.initConfig = {
-            wallet,
-            arkServer: {
-                url: this.arkServerUrl,
-                publicKey: this.arkServerPublicKey,
-            },
-            delegatorUrl: this.delegatorUrl,
-            indexerUrl: this.indexerUrl,
-            esploraUrl: this.esploraUrl,
-            watcherConfig: this.watcherConfig,
-            settlementConfig: this.settlementConfig,
-        };
-        return this.initConfig;
-    }
-    /** Minimal INIT_WALLET payload used on reinitialize when the cache is gone. */
-    buildInitWalletPayload() {
-        if (this.initWalletPayload)
-            return this.initWalletPayload;
-        if (!this.arkServerUrl) {
-            throw new Error("Cannot re-initialize: wallet was not initialized via the SDK factory");
-        }
-        this.initWalletPayload = {
-            // `key` is deprecated and ignored by the current handler.
-            key: {},
-            arkServerUrl: this.arkServerUrl,
-            arkServerPublicKey: this.arkServerPublicKey,
-        };
-        return this.initWalletPayload;
-    }
-    async reinitialize() {
-        if (this.reinitPromise)
-            return this.reinitPromise;
-        this.reinitPromise = (async () => {
-            const config = await this.buildInitConfig();
-            const payload = this.buildInitWalletPayload();
-            await initializeMessageBus(this.serviceWorker, config, this.messageBusTimeoutMs);
-            const initMessage = {
-                tag: this.messageTag,
-                type: "INIT_WALLET",
-                id: getRandomId(),
-                payload,
-            };
-            await this.sendMessageDirect(initMessage, this.getTimeoutForRequest(initMessage));
-        })().finally(() => {
-            this.reinitPromise = null;
-        });
-        return this.reinitPromise;
-    }
-    /** Clear cached wallet state from both the page and service worker storage. */
-    async clear() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "CLEAR",
-        };
-        // Clear page-side storage to maintain parity with SW
-        try {
-            const address = await this.getAddress();
-            await this.walletRepository.deleteVtxos(address);
-        }
-        catch (_) {
-            console.warn("Failed to clear vtxos from wallet repository");
-        }
-        await this.sendMessage(message);
-    }
-    async getAddress() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_ADDRESS",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.address;
-        }
-        catch (error) {
-            throw new Error(`Failed to get address: ${error}`);
-        }
-    }
-    async getBoardingAddress() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_BOARDING_ADDRESS",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.address;
-        }
-        catch (error) {
-            throw new Error(`Failed to get boarding address: ${error}`);
-        }
-    }
-    async getBalance() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_BALANCE",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload;
-        }
-        catch (error) {
-            throw new Error(`Failed to get balance: ${error}`);
-        }
-    }
-    async getBoardingUtxos() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_BOARDING_UTXOS",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.utxos;
-        }
-        catch (error) {
-            throw new Error(`Failed to get boarding UTXOs: ${error}`);
-        }
-    }
-    /**
-     * Return service-worker wallet status, including connectivity and sync state.
-     *
-     * @returns Current service-worker wallet status payload including `walletInitalized` and `xOnlyPublicKey`
-     */
-    async getStatus() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_STATUS",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload;
-        }
-        catch (error) {
-            throw new Error(`Failed to get status: ${error}`);
-        }
-    }
-    async getTransactionHistory() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_TRANSACTION_HISTORY",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload
-                .transactions;
-        }
-        catch (error) {
-            throw new Error(`Failed to get transaction history: ${error}`);
-        }
-    }
-    async getVtxos(filter) {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "GET_VTXOS",
-            payload: { filter },
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.vtxos;
-        }
-        catch (error) {
-            throw new Error(`Failed to get vtxos: ${error}`);
-        }
-    }
-    /**
-     * Trigger a wallet reload inside the service worker.
-     *
-     * @returns `true` when the wallet was reloaded
-     */
-    async reload() {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "RELOAD_WALLET",
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.reloaded;
-        }
-        catch (error) {
-            throw new Error(`Failed to reload wallet: ${error}`);
-        }
-    }
-    async getContractManager() {
-        const wallet = this;
-        const sendContractMessage = async (message) => {
-            return wallet.sendMessage(message);
-        };
-        const messageTag = this.messageTag;
-        const manager = {
-            async createContract(params) {
-                const message = {
-                    type: "CREATE_CONTRACT",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: params,
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload
-                        .contract;
-                }
-                catch (e) {
-                    throw new Error("Failed to create contract");
-                }
-            },
-            async getContracts(filter) {
-                const message = {
-                    type: "GET_CONTRACTS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { filter },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload.contracts;
-                }
-                catch (e) {
-                    throw new Error("Failed to get contracts");
-                }
-            },
-            async getContractsWithVtxos(filter) {
-                const message = {
-                    type: "GET_CONTRACTS_WITH_VTXOS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { filter },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload
-                        .contracts;
-                }
-                catch (e) {
-                    throw new Error("Failed to get contracts with vtxos");
-                }
-            },
-            async annotateVtxos(vtxos) {
-                if (vtxos.length === 0)
-                    return [];
-                const message = {
-                    type: "ANNOTATE_VTXOS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { vtxos },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload.vtxos;
-                }
-                catch (e) {
-                    throw new Error("Failed to annotate vtxos");
-                }
-            },
-            async updateContract(script, updates) {
-                const message = {
-                    type: "UPDATE_CONTRACT",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { script, updates },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload
-                        .contract;
-                }
-                catch (e) {
-                    throw new Error("Failed to update contract");
-                }
-            },
-            async setContractState(script, state) {
-                const message = {
-                    type: "UPDATE_CONTRACT",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { script, updates: { state } },
-                };
-                try {
-                    await sendContractMessage(message);
-                    return;
-                }
-                catch (e) {
-                    throw new Error("Failed to update contract state");
-                }
-            },
-            async deleteContract(script) {
-                const message = {
-                    type: "DELETE_CONTRACT",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { script },
-                };
-                try {
-                    await sendContractMessage(message);
-                    return;
-                }
-                catch (e) {
-                    throw new Error("Failed to delete contract");
-                }
-            },
-            async getSpendablePaths(options) {
-                const message = {
-                    type: "GET_SPENDABLE_PATHS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { options },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload
-                        .paths;
-                }
-                catch (e) {
-                    throw new Error("Failed to get spendable paths");
-                }
-            },
-            async getAllSpendingPaths(options) {
-                const message = {
-                    type: "GET_ALL_SPENDING_PATHS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { options },
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response.payload
-                        .paths;
-                }
-                catch (e) {
-                    throw new Error("Failed to get all spending paths");
-                }
-            },
-            onContractEvent(callback) {
-                const messageHandler = (event) => {
-                    const response = event.data;
-                    if (response.type !== "CONTRACT_EVENT") {
-                        return;
-                    }
-                    if (response.tag !== messageTag) {
-                        return;
-                    }
-                    callback(response.payload.event);
-                };
-                navigator.serviceWorker.addEventListener("message", messageHandler);
-                return () => {
-                    navigator.serviceWorker.removeEventListener("message", messageHandler);
-                };
-            },
-            async refreshVtxos(opts) {
-                const message = {
-                    type: "REFRESH_VTXOS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: opts,
-                };
-                await sendContractMessage(message);
-            },
-            async refreshOutpoints(outpoints) {
-                const message = {
-                    type: "REFRESH_OUTPOINTS",
-                    id: getRandomId(),
-                    tag: messageTag,
-                    payload: { outpoints },
-                };
-                await sendContractMessage(message);
-            },
-            async isWatching() {
-                const message = {
-                    type: "IS_CONTRACT_MANAGER_WATCHING",
-                    id: getRandomId(),
-                    tag: messageTag,
-                };
-                try {
-                    const response = await sendContractMessage(message);
-                    return response
-                        .payload.isWatching;
-                }
-                catch (e) {
-                    throw new Error("Failed to check if contract manager is watching");
-                }
-            },
-            dispose() {
-                return;
-            },
-            [Symbol.dispose]() {
-                // no-op
-                return;
-            },
-        };
-        return manager;
-    }
-}
-export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
-    constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag, hasDelegator) {
-        super(serviceWorker, identity, walletRepository, contractRepository, messageTag);
-        this.serviceWorker = serviceWorker;
-        this.identity = identity;
-        this.walletRepository = walletRepository;
-        this.contractRepository = contractRepository;
-        this._assetManager = new ServiceWorkerAssetManager((msg) => this.sendMessage(msg), messageTag);
-        this.hasDelegator = hasDelegator;
-    }
-    get assetManager() {
-        return this._assetManager;
-    }
-    async serializeIdentity() {
-        return serializeSigningIdentity(this.identity);
-    }
-    static async create(options) {
-        const walletRepository = options.storage?.walletRepository ??
-            new IndexedDBWalletRepository();
-        const contractRepository = options.storage?.contractRepository ??
-            new IndexedDBContractRepository();
-        if (!isSigningCapable(options.identity)) {
-            throw new Error("ServiceWorkerWallet.create() requires a signing Identity; got a ReadonlyIdentity");
-        }
-        const identity = options.identity;
-        const serializedWallet = serializeSigningIdentity(identity);
-        const messageTag = options.walletUpdaterTag ?? DEFAULT_MESSAGE_TAG;
-        // Create the wallet instance
-        const wallet = new ServiceWorkerWallet(options.serviceWorker, identity, walletRepository, contractRepository, messageTag, !!options.delegatorUrl);
-        // INIT_WALLET retains the legacy `key` payload for wire compatibility
-        // with older workers; the current handler does not read it, and only
-        // SingleKey-style identities can populate it. Kept optional so seed /
-        // mnemonic identities simply omit it.
-        const legacyPrivateKey = serializedWallet.type === "single-key"
-            ? serializedWallet.privateKey
-            : null;
-        const initWalletPayload = {
-            key: legacyPrivateKey ? { privateKey: legacyPrivateKey } : {},
-            arkServerUrl: getArkadeServerUrl(options),
-            arkServerPublicKey: options.arkServerPublicKey,
-            delegatorUrl: options.delegatorUrl,
-        };
-        // Precompute the merged timeout map so page-side waiting and
-        // worker-side enforcement are derived from the same source.
-        const messageTimeouts = options.messageTimeouts
-            ? {
-                ...DEFAULT_MESSAGE_TIMEOUTS,
-                ...options.messageTimeouts,
-            }
-            : DEFAULT_MESSAGE_TIMEOUTS;
-        const busInitConfig = {
-            wallet: serializedWallet,
-            arkServer: {
-                url: getArkadeServerUrl(options),
-                publicKey: options.arkServerPublicKey,
-            },
-            delegatorUrl: options.delegatorUrl,
-            indexerUrl: options.indexerUrl,
-            esploraUrl: options.esploraUrl,
-            settlementConfig: options.settlementConfig,
-            walletMode: options.walletMode,
-            watcherConfig: options.watcherConfig,
-            messageTimeouts,
-        };
-        await initializeMessageBus(options.serviceWorker, { ...busInitConfig, timeoutMs: options.messageBusTimeoutMs }, options.messageBusTimeoutMs);
-        // Initialize the service worker with the config
-        const initMessage = {
-            tag: messageTag,
-            type: "INIT_WALLET",
-            id: getRandomId(),
-            payload: initWalletPayload,
-        };
-        // Initialize the service worker
-        await wallet.sendMessage(initMessage);
-        // Persist the full init config (including messageTimeouts) so
-        // reinitialize() re-sends the same map to a restarted worker.
-        wallet.initConfig = busInitConfig;
-        wallet.initWalletPayload = initWalletPayload;
-        wallet.messageBusTimeoutMs = options.messageBusTimeoutMs;
-        wallet.messageTimeouts = messageTimeouts;
-        return wallet;
-    }
-    /**
-     * Simplified setup method that handles service worker registration
-     * and wallet initialization automatically.
-     *
-     * @example
-     * ```typescript
-     * const wallet = await ServiceWorkerWallet.setup({
-     *   serviceWorkerPath: '/service-worker.js',
-     *   arkServerUrl: 'https://arkade.computer',
-     *   identity: MnemonicIdentity.fromMnemonic('abandon abandon...')
-     * });
-     * ```
-     */
-    static async setup(options) {
-        // Register and setup the service worker
-        const serviceWorker = await setupServiceWorker({
-            path: options.serviceWorkerPath,
-            activationTimeoutMs: options.serviceWorkerActivationTimeoutMs,
-        });
-        // Use the existing create method
-        return ServiceWorkerWallet.create({
-            ...options,
-            serviceWorker,
-        });
-    }
-    async sendBitcoin(params) {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "SEND_BITCOIN",
-            payload: params,
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.txid;
-        }
-        catch (error) {
-            throw new Error(`Failed to send bitcoin: ${error}`);
-        }
-    }
-    async settle(params, callback) {
-        const message = {
-            id: getRandomId(),
-            tag: this.messageTag,
-            type: "SETTLE",
-            payload: { params },
-        };
-        try {
-            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}`);
-        }
-    }
-    async send(...recipients) {
-        const message = {
-            tag: this.messageTag,
-            type: "SEND",
-            id: getRandomId(),
-            payload: { recipients },
-        };
-        try {
-            const response = await this.sendMessage(message);
-            return response.payload.txid;
-        }
-        catch (error) {
-            throw new Error(`Send failed: ${error}`);
-        }
-    }
-    async getDelegatorManager() {
-        if (!this.hasDelegator) {
-            return undefined;
-        }
-        const wallet = this;
-        const messageTag = this.messageTag;
-        const manager = {
-            async delegate(vtxos, destination, delegateAt) {
-                const message = {
-                    tag: messageTag,
-                    type: "DELEGATE",
-                    id: getRandomId(),
-                    payload: {
-                        vtxoOutpoints: vtxos.map((v) => ({
-                            txid: v.txid,
-                            vout: v.vout,
-                        })),
-                        destination,
-                        delegateAt: delegateAt?.getTime(),
-                    },
-                };
-                try {
-                    const response = await wallet.sendMessage(message);
-                    const payload = response.payload;
-                    return {
-                        delegated: payload.delegated,
-                        failed: payload.failed.map((f) => ({
-                            outpoints: f.outpoints,
-                            error: f.error,
-                        })),
-                    };
-                }
-                catch (error) {
-                    throw new Error(`Delegation failed: ${error}`);
-                }
-            },
-            async getDelegateInfo() {
-                const message = {
-                    type: "GET_DELEGATE_INFO",
-                    id: getRandomId(),
-                    tag: messageTag,
-                };
-                try {
-                    const response = await wallet.sendMessage(message);
-                    return response.payload.info;
-                }
-                catch (e) {
-                    throw new Error("Failed to get delegate info");
-                }
-            },
-        };
-        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;
-    }
-}