@arkade-os/sdk 0.4.0-next.3 → 0.4.0-next.5

package/dist/cjs/wallet/serviceWorker/wallet-message-handler.js

@@ -289,6 +289,10 @@ class WalletMessageHandler {
                         payload: { txid },
                     });
                 }
+                case "DELEGATE": {
+                    const response = await this.handleDelegate(message);
+                    return this.tagged({ id, ...response });
+                }
                 default:
                     console.error("Unknown message type", message);
                     throw new Error("Unknown message");
@@ -502,6 +506,34 @@ class WalletMessageHandler {
             payload: { tx: signature },
         };
     }
+    async handleDelegate(message) {
+        const wallet = this.requireWallet();
+        if (!wallet.delegatorManager) {
+            throw new Error("Delegator not configured");
+        }
+        const { vtxoOutpoints, destination, delegateAt } = message.payload;
+        const allVtxos = await wallet.getVtxos();
+        const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
+        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const result = await wallet.delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
+        return {
+            tag: this.messageTag,
+            type: "DELEGATE_SUCCESS",
+            payload: {
+                delegated: result.delegated.map((o) => ({
+                    txid: o.txid,
+                    vout: o.vout,
+                })),
+                failed: result.failed.map((f) => ({
+                    outpoints: f.outpoints.map((o) => ({
+                        txid: o.txid,
+                        vout: o.vout,
+                    })),
+                    error: String(f.error),
+                })),
+            },
+        };
+    }
     async handleGetVtxos(message) {
         if (!this.readonlyWallet) {
             throw new Error("Wallet handler not initialized");

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

@@ -124,6 +124,7 @@ class ServiceWorkerReadonlyWallet {
                 url: initConfig.arkServerUrl,
                 publicKey: initConfig.arkServerPublicKey,
             },
+            delegatorUrl: initConfig.delegatorUrl,
             timeoutMs: options.messageBusTimeoutMs,
         }, options.messageBusTimeoutMs);
         // Initialize the wallet handler
@@ -540,6 +541,7 @@ class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
                 url: initConfig.arkServerUrl,
                 publicKey: initConfig.arkServerPublicKey,
             },
+            delegatorUrl: initConfig.delegatorUrl,
             timeoutMs: options.messageBusTimeoutMs,
         }, options.messageBusTimeoutMs);
         // Initialize the service worker with the config
@@ -654,5 +656,24 @@ class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
             throw new Error(`Send failed: ${error}`);
         }
     }
+    async delegate(vtxoOutpoints, destination, delegateAt) {
+        const message = {
+            tag: this.messageTag,
+            type: "DELEGATE",
+            id: (0, utils_2.getRandomId)(),
+            payload: {
+                vtxoOutpoints,
+                destination,
+                delegateAt: delegateAt?.getTime(),
+            },
+        };
+        try {
+            const response = await this.sendMessage(message);
+            return response.payload;
+        }
+        catch (error) {
+            throw new Error(`Delegation failed: ${error}`);
+        }
+    }
 }
 exports.ServiceWorkerWallet = ServiceWorkerWallet;

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

@@ -4,15 +4,111 @@ exports.__resetServiceWorkerManager = void 0;
 exports.setupServiceWorkerOnce = setupServiceWorkerOnce;
 exports.getActiveServiceWorker = getActiveServiceWorker;
 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 registerOnce(path) {
+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)
+            .register(path, { updateViaCache })
             .then(async (registration) => {
             try {
                 await registration.update();
@@ -29,18 +125,23 @@ function registerOnce(path) {
         });
         registrations.set(path, registrationPromise);
     }
-    return registrations.get(path);
+    return registrations.get(path).then((registration) => {
+        attachUpdateHandlers(registration, options);
+        return registration;
+    });
 }
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * 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 path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-async function setupServiceWorkerOnce(path) {
+async function setupServiceWorkerOnce(pathOrOptions) {
     ensureServiceWorkerSupport();
-    return registerOnce(path);
+    const options = normalizeOptions(pathOrOptions);
+    return registerOnce(options);
 }
 /**
  * Returns an active service worker instance, optionally ensuring a specific
@@ -51,9 +152,8 @@ async function setupServiceWorkerOnce(path) {
  */
 async function getActiveServiceWorker(path) {
     ensureServiceWorkerSupport();
-    // Avoid mixing registrations when a specific script path is provided.
     const registration = path
-        ? await registerOnce(path)
+        ? await registerOnce(normalizeOptions(path))
         : await navigator.serviceWorker.ready;
     let serviceWorker = registration.active ||
         registration.waiting ||
@@ -78,5 +178,6 @@ async function getActiveServiceWorker(path) {
  */
 const __resetServiceWorkerManager = () => {
     registrations.clear();
+    handshakes = new WeakSet();
 };
 exports.__resetServiceWorkerManager = __resetServiceWorkerManager;

package/dist/cjs/worker/messageBus.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageBus = void 0;
 const service_worker_manager_1 = require("./browser/service-worker-manager");
 const ark_1 = require("../providers/ark");
+const delegator_1 = require("../providers/delegator");
 const identity_1 = require("../identity");
 const wallet_1 = require("../wallet/wallet");
 const base_1 = require("@scure/base");
@@ -139,6 +140,9 @@ class MessageBus {
             walletRepository: this.walletRepository,
             contractRepository: this.contractRepository,
         };
+        const delegatorProvider = config.delegatorUrl
+            ? new delegator_1.RestDelegatorProvider(config.delegatorUrl)
+            : undefined;
         if ("privateKey" in config.wallet) {
             const identity = identity_1.SingleKey.fromHex(config.wallet.privateKey);
             const wallet = await wallet_1.Wallet.create({
@@ -146,6 +150,7 @@ class MessageBus {
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
                 storage,
+                delegatorProvider,
             });
             return { wallet, arkProvider, readonlyWallet: wallet };
         }
@@ -156,6 +161,7 @@ class MessageBus {
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
                 storage,
+                delegatorProvider,
             });
             return { readonlyWallet, arkProvider };
         }

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -286,6 +286,10 @@ export class WalletMessageHandler {
                         payload: { txid },
                     });
                 }
+                case "DELEGATE": {
+                    const response = await this.handleDelegate(message);
+                    return this.tagged({ id, ...response });
+                }
                 default:
                     console.error("Unknown message type", message);
                     throw new Error("Unknown message");
@@ -499,6 +503,34 @@ export class WalletMessageHandler {
             payload: { tx: signature },
         };
     }
+    async handleDelegate(message) {
+        const wallet = this.requireWallet();
+        if (!wallet.delegatorManager) {
+            throw new Error("Delegator not configured");
+        }
+        const { vtxoOutpoints, destination, delegateAt } = message.payload;
+        const allVtxos = await wallet.getVtxos();
+        const outpointSet = new Set(vtxoOutpoints.map((o) => `${o.txid}:${o.vout}`));
+        const filtered = allVtxos.filter((v) => outpointSet.has(`${v.txid}:${v.vout}`));
+        const result = await wallet.delegatorManager.delegate(filtered, destination, delegateAt !== undefined ? new Date(delegateAt) : undefined);
+        return {
+            tag: this.messageTag,
+            type: "DELEGATE_SUCCESS",
+            payload: {
+                delegated: result.delegated.map((o) => ({
+                    txid: o.txid,
+                    vout: o.vout,
+                })),
+                failed: result.failed.map((f) => ({
+                    outpoints: f.outpoints.map((o) => ({
+                        txid: o.txid,
+                        vout: o.vout,
+                    })),
+                    error: String(f.error),
+                })),
+            },
+        };
+    }
     async handleGetVtxos(message) {
         if (!this.readonlyWallet) {
             throw new Error("Wallet handler not initialized");

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

@@ -121,6 +121,7 @@ export class ServiceWorkerReadonlyWallet {
                 url: initConfig.arkServerUrl,
                 publicKey: initConfig.arkServerPublicKey,
             },
+            delegatorUrl: initConfig.delegatorUrl,
             timeoutMs: options.messageBusTimeoutMs,
         }, options.messageBusTimeoutMs);
         // Initialize the wallet handler
@@ -536,6 +537,7 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
                 url: initConfig.arkServerUrl,
                 publicKey: initConfig.arkServerPublicKey,
             },
+            delegatorUrl: initConfig.delegatorUrl,
             timeoutMs: options.messageBusTimeoutMs,
         }, options.messageBusTimeoutMs);
         // Initialize the service worker with the config
@@ -650,4 +652,23 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
             throw new Error(`Send failed: ${error}`);
         }
     }
+    async delegate(vtxoOutpoints, destination, delegateAt) {
+        const message = {
+            tag: this.messageTag,
+            type: "DELEGATE",
+            id: getRandomId(),
+            payload: {
+                vtxoOutpoints,
+                destination,
+                delegateAt: delegateAt?.getTime(),
+            },
+        };
+        try {
+            const response = await this.sendMessage(message);
+            return response.payload;
+        }
+        catch (error) {
+            throw new Error(`Delegation failed: ${error}`);
+        }
+    }
 }

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

@@ -1,13 +1,109 @@
 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 registerOnce(path) {
+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)
+            .register(path, { updateViaCache })
             .then(async (registration) => {
             try {
                 await registration.update();
@@ -24,18 +120,23 @@ function registerOnce(path) {
         });
         registrations.set(path, registrationPromise);
     }
-    return registrations.get(path);
+    return registrations.get(path).then((registration) => {
+        attachUpdateHandlers(registration, options);
+        return registration;
+    });
 }
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * 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 path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-export async function setupServiceWorkerOnce(path) {
+export async function setupServiceWorkerOnce(pathOrOptions) {
     ensureServiceWorkerSupport();
-    return registerOnce(path);
+    const options = normalizeOptions(pathOrOptions);
+    return registerOnce(options);
 }
 /**
  * Returns an active service worker instance, optionally ensuring a specific
@@ -46,9 +147,8 @@ export async function setupServiceWorkerOnce(path) {
  */
 export async function getActiveServiceWorker(path) {
     ensureServiceWorkerSupport();
-    // Avoid mixing registrations when a specific script path is provided.
     const registration = path
-        ? await registerOnce(path)
+        ? await registerOnce(normalizeOptions(path))
         : await navigator.serviceWorker.ready;
     let serviceWorker = registration.active ||
         registration.waiting ||
@@ -73,4 +173,5 @@ export async function getActiveServiceWorker(path) {
  */
 export const __resetServiceWorkerManager = () => {
     registrations.clear();
+    handshakes = new WeakSet();
 };

package/dist/esm/worker/messageBus.js

@@ -1,6 +1,7 @@
 /// <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 { ReadonlySingleKey, SingleKey } from '../identity/index.js';
 import { ReadonlyWallet, Wallet } from '../wallet/wallet.js';
 import { hex } from "@scure/base";
@@ -136,6 +137,9 @@ export class MessageBus {
             walletRepository: this.walletRepository,
             contractRepository: this.contractRepository,
         };
+        const delegatorProvider = config.delegatorUrl
+            ? new RestDelegatorProvider(config.delegatorUrl)
+            : undefined;
         if ("privateKey" in config.wallet) {
             const identity = SingleKey.fromHex(config.wallet.privateKey);
             const wallet = await Wallet.create({
@@ -143,6 +147,7 @@ export class MessageBus {
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
                 storage,
+                delegatorProvider,
             });
             return { wallet, arkProvider, readonlyWallet: wallet };
         }
@@ -153,6 +158,7 @@ export class MessageBus {
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
                 storage,
+                delegatorProvider,
             });
             return { readonlyWallet, arkProvider };
         }

package/dist/types/wallet/serviceWorker/wallet-message-handler.d.ts

@@ -318,8 +318,35 @@ export type ResponseBurn = ResponseEnvelope & {
         txid: string;
     };
 };
-export type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestSendBitcoin | RequestGetAddress | RequestGetBoardingAddress | RequestGetBalance | RequestGetVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn;
-export type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseSendBitcoin | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetBalance | ResponseGetVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn);
+export type RequestDelegate = RequestEnvelope & {
+    type: "DELEGATE";
+    payload: {
+        vtxoOutpoints: {
+            txid: string;
+            vout: number;
+        }[];
+        destination: string;
+        delegateAt?: number;
+    };
+};
+export type ResponseDelegate = ResponseEnvelope & {
+    type: "DELEGATE_SUCCESS";
+    payload: {
+        delegated: {
+            txid: string;
+            vout: number;
+        }[];
+        failed: {
+            outpoints: {
+                txid: string;
+                vout: number;
+            }[];
+            error: string;
+        }[];
+    };
+};
+export type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestSendBitcoin | RequestGetAddress | RequestGetBoardingAddress | RequestGetBalance | RequestGetVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn | RequestDelegate;
+export type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseSendBitcoin | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetBalance | ResponseGetVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn | ResponseDelegate);
 export declare class WalletMessageHandler implements MessageHandler<WalletUpdaterRequest, WalletUpdaterResponse> {
     readonly messageTag: string;
     private wallet;
@@ -360,6 +387,7 @@ export declare class WalletMessageHandler implements MessageHandler<WalletUpdate
     private handleSettle;
     private handleSendBitcoin;
     private handleSignTransaction;
+    private handleDelegate;
     private handleGetVtxos;
     private clear;
     private ensureContractEventBroadcasting;

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 { ResponseGetStatus, WalletUpdaterRequest, WalletUpdaterResponse, ResponseDelegate } from "./wallet-message-handler";
 import type { IContractManager } from "../../contracts/contractManager";
 type PrivateKeyIdentity = Identity & {
     toHex(): string;
@@ -134,5 +134,9 @@ export declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet imp
     sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, callback?: (event: SettlementEvent) => void): Promise<string>;
     send(...recipients: Recipient[]): Promise<string>;
+    delegate(vtxoOutpoints: {
+        txid: string;
+        vout: number;
+    }[], destination: string, delegateAt?: Date): Promise<ResponseDelegate["payload"]>;
 }
 export {};

package/dist/types/worker/browser/service-worker-manager.d.ts

@@ -1,11 +1,21 @@
+type SetupServiceWorkerOptions = {
+    path: string;
+    updateViaCache?: ServiceWorkerUpdateViaCache;
+    autoReload?: boolean;
+    onNeedRefresh?: () => void;
+    onUpdated?: () => void;
+    debug?: boolean;
+    activationTimeoutMs?: number;
+};
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * 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 path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-export declare function setupServiceWorkerOnce(path: string): Promise<ServiceWorkerRegistration>;
+export declare function setupServiceWorkerOnce(pathOrOptions: string | SetupServiceWorkerOptions): Promise<ServiceWorkerRegistration>;
 /**
  * Returns an active service worker instance, optionally ensuring a specific
  * script path is registered before resolving.
@@ -19,3 +29,4 @@ export declare function getActiveServiceWorker(path?: string): Promise<ServiceWo
  * Intended for tests to reset state between runs.
  */
 export declare const __resetServiceWorkerManager: () => void;
+export {};

package/dist/types/worker/messageBus.d.ts

@@ -68,6 +68,7 @@ type Initialize = {
             url: string;
             publicKey?: string;
         };
+        delegatorUrl?: string;
     };
 };
 export declare class MessageBus {

package/package.json

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