@arkade-os/sdk 0.4.19 → 0.4.21

package/dist/esm/providers/indexer.js

@@ -1,6 +1,6 @@
 import { hex } from "@scure/base";
 import { isFetchTimeoutError } from './ark.js';
-import { eventSourceIterator } from './utils.js';
+import { eventSourceIterator, isEventSourceError } from './utils.js';
 import { MetadataList } from '../extension/asset/index.js';
 export var IndexerTxType;
 (function (IndexerTxType) {
@@ -153,58 +153,75 @@ export class RestIndexerProvider {
         }
         return data;
     }
-    async *getSubscription(subscriptionId, abortSignal) {
+    getSubscription(subscriptionId, abortSignal) {
         const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
-        while (!abortSignal?.aborted) {
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
+        const gen = (async function* () {
+            const abortHandler = closeIterator;
+            abortSignal?.addEventListener("abort", abortHandler);
             try {
-                const eventSource = new EventSource(url);
-                // Set up abort handling
-                const abortHandler = () => {
-                    eventSource.close();
-                };
-                abortSignal?.addEventListener("abort", abortHandler);
-                try {
-                    for await (const event of eventSourceIterator(eventSource)) {
-                        if (abortSignal?.aborted)
-                            break;
-                        try {
-                            const data = JSON.parse(event.data);
-                            if (data.event) {
-                                yield {
-                                    txid: data.event.txid,
-                                    scripts: data.event.scripts || [],
-                                    newVtxos: (data.event.newVtxos || []).map(convertVtxo),
-                                    spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
-                                    sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
-                                    tx: data.event.tx,
-                                    checkpointTxs: data.event.checkpointTxs,
-                                };
+                while (!abortSignal?.aborted) {
+                    try {
+                        const currentIterator = eventSourceIterator(new EventSource(url));
+                        iterator = currentIterator;
+                        for await (const event of currentIterator) {
+                            if (abortSignal?.aborted)
+                                break;
+                            try {
+                                const data = JSON.parse(event.data);
+                                if (data.event) {
+                                    yield {
+                                        txid: data.event.txid,
+                                        scripts: data.event.scripts || [],
+                                        newVtxos: (data.event.newVtxos || []).map(convertVtxo),
+                                        spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                                        sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                                        tx: data.event.tx,
+                                        checkpointTxs: data.event.checkpointTxs,
+                                    };
+                                }
+                            }
+                            catch (err) {
+                                console.error("Failed to parse subscription event:", err);
+                                throw err;
                             }
                         }
-                        catch (err) {
-                            console.error("Failed to parse subscription event:", err);
-                            throw err;
+                    }
+                    catch (error) {
+                        if (abortSignal?.aborted ||
+                            (error instanceof Error &&
+                                error.name === "AbortError")) {
+                            break;
+                        }
+                        // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                        if (isFetchTimeoutError(error)) {
+                            console.debug("Timeout error ignored");
+                            continue;
+                        }
+                        if (isEventSourceError(error)) {
+                            throw error;
                         }
+                        console.error("Subscription error:", error);
+                        throw error;
+                    }
+                    finally {
+                        closeIterator();
+                        iterator = null;
                     }
-                }
-                finally {
-                    abortSignal?.removeEventListener("abort", abortHandler);
-                    eventSource.close();
                 }
             }
-            catch (error) {
-                if (error instanceof Error && error.name === "AbortError") {
-                    break;
-                }
-                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
-                if (isFetchTimeoutError(error)) {
-                    console.debug("Timeout error ignored");
-                    continue;
-                }
-                console.error("Subscription error:", error);
-                throw error;
+            finally {
+                abortSignal?.removeEventListener("abort", abortHandler);
+                closeIterator();
             }
-        }
+        })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            closeIterator();
+            return origReturn(value);
+        };
+        return gen;
     }
     async getVirtualTxs(txids, opts) {
         let url = `${this.serverUrl}/v1/indexer/virtualTx/${txids.join(",")}`;

package/dist/esm/providers/utils.js

@@ -1,29 +1,67 @@
+function createAbortError() {
+    const error = new Error("EventSource closed");
+    error.name = "AbortError";
+    return error;
+}
 /**
- * Creates an async iterator over EventSource messages that attaches listeners
- * eagerly (at call time) rather than lazily (at first .next() call).
- * This ensures events are buffered immediately, preventing race conditions
- * where events arrive before iteration begins.
+ * Creates a close-aware EventSource async iterator.
+ *
+ * Listeners attach eagerly so events are buffered before the first next() call.
+ * close() closes the EventSource, removes listeners, and wakes any pending
+ * next() even when the browser does not emit an error from EventSource.close().
  */
 export function eventSourceIterator(eventSource) {
     const messageQueue = [];
     const errorQueue = [];
     let messageResolve = null;
     let errorResolve = null;
+    let closed = false;
+    let cleanedUp = false;
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        eventSource.removeEventListener("message", messageHandler);
+        eventSource.removeEventListener("error", errorHandler);
+    };
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        messageQueue.length = 0;
+        errorQueue.length = 0;
+        eventSource.close();
+        cleanup();
+        if (errorResolve) {
+            const reject = errorResolve;
+            messageResolve = null;
+            errorResolve = null;
+            reject(createAbortError());
+        }
+    };
     const messageHandler = (event) => {
+        if (closed)
+            return;
         if (messageResolve) {
-            messageResolve(event);
+            const resolve = messageResolve;
             messageResolve = null;
+            errorResolve = null;
+            resolve(event);
         }
         else {
             messageQueue.push(event);
         }
     };
     const errorHandler = () => {
+        if (closed)
+            return;
         const error = new Error("EventSource error");
         error.name = "EventSourceError";
         if (errorResolve) {
-            errorResolve(error);
+            const reject = errorResolve;
+            messageResolve = null;
             errorResolve = null;
+            reject(error);
         }
         else {
             errorQueue.push(error);
@@ -33,9 +71,9 @@ export function eventSourceIterator(eventSource) {
     // even before the caller starts iterating
     eventSource.addEventListener("message", messageHandler);
     eventSource.addEventListener("error", errorHandler);
-    return (async function* () {
+    const gen = (async function* () {
         try {
-            while (true) {
+            while (!closed) {
                 // if we have queued messages, yield the first one, remove it from the queue
                 if (messageQueue.length > 0) {
                     yield messageQueue.shift();
@@ -54,15 +92,26 @@ export function eventSourceIterator(eventSource) {
                     messageResolve = null;
                     errorResolve = null;
                 });
-                if (result) {
+                if (!closed && result) {
                     yield result;
                 }
             }
         }
         finally {
-            // clean up
-            eventSource.removeEventListener("message", messageHandler);
-            eventSource.removeEventListener("error", errorHandler);
+            closed = true;
+            cleanup();
+            eventSource.close();
         }
     })();
+    const origReturn = gen.return.bind(gen);
+    const managed = gen;
+    managed.close = close;
+    managed.return = (value) => {
+        close();
+        return origReturn(value);
+    };
+    return managed;
+}
+export function isEventSourceError(error) {
+    return error instanceof Error && error.name === "EventSourceError";
 }

package/dist/esm/wallet/ramps.js

@@ -139,7 +139,7 @@ export class Ramps {
                 weight: 0,
                 birth: vtxo.createdAt,
                 expiry: vtxo.virtualStatus.batchExpiry
-                    ? new Date(vtxo.virtualStatus.batchExpiry * 1000)
+                    ? new Date(vtxo.virtualStatus.batchExpiry)
                     : undefined,
             });
             if (inputFee.satoshis >= vtxo.value) {

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

@@ -97,6 +97,16 @@ export class WalletMessageHandler {
             tag: this.messageTag,
         };
     }
+    // Flows that surrender control to the Ark server and the other participants
+    // in a batch round: quiet gaps between protocol events can easily exceed
+    // the bus-level messageTimeoutMs. Liveness is covered out-of-band by the
+    // page-side PING / MESSAGE_BUS_NOT_INITIALIZED path triggered by concurrent
+    // short requests (GET_STATUS, GET_BALANCE, ...).
+    isLongRunning(message) {
+        return (message.type === "SETTLE" ||
+            message.type === "RECOVER_VTXOS" ||
+            message.type === "RENEW_VTXOS");
+    }
     async handleMessage(message) {
         const id = message.id;
         if (message.type === "INIT_WALLET") {

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

@@ -1,4 +1,5 @@
 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';
@@ -33,7 +34,10 @@ export const DEFAULT_MESSAGE_TIMEOUTS = {
     GET_EXPIRED_BOARDING_UTXOS: 20000,
     GET_RECOVERABLE_BALANCE: 20000,
     RELOAD_WALLET: 20000,
-    // Transactions — need more headroom
+    // 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,
@@ -78,9 +82,12 @@ function getRequestDedupKey(request) {
     const { id, tag, ...rest } = request;
     return JSON.stringify(rest);
 }
-const isPrivateKeyIdentity = (identity) => {
-    return typeof identity.toHex === "function";
-};
+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;
@@ -196,55 +203,54 @@ export class ServiceWorkerReadonlyWallet {
         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 initConfig = {
+        const initWalletPayload = {
             key: { publicKey },
             arkServerUrl: options.arkServerUrl,
             arkServerPublicKey: options.arkServerPublicKey,
             delegatorUrl: options.delegatorUrl,
         };
-        // Bootstrap the MessageBus in the service worker
-        await initializeMessageBus(options.serviceWorker, {
-            wallet: initConfig.key,
+        // 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: initConfig.arkServerUrl,
-                publicKey: initConfig.arkServerPublicKey,
+                url: options.arkServerUrl,
+                publicKey: options.arkServerPublicKey,
             },
-            delegatorUrl: initConfig.delegatorUrl,
+            delegatorUrl: options.delegatorUrl,
             indexerUrl: options.indexerUrl,
             esploraUrl: options.esploraUrl,
-            timeoutMs: options.messageBusTimeoutMs,
             watcherConfig: options.watcherConfig,
-        }, options.messageBusTimeoutMs);
+            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: initConfig,
+            payload: initWalletPayload,
         };
         await wallet.sendMessage(initMessage);
-        wallet.initConfig = {
-            wallet: initConfig.key,
-            arkServer: {
-                url: initConfig.arkServerUrl,
-                publicKey: initConfig.arkServerPublicKey,
-            },
-            delegatorUrl: initConfig.delegatorUrl,
-            indexerUrl: options.indexerUrl,
-            esploraUrl: options.esploraUrl,
-            watcherConfig: options.watcherConfig,
-        };
-        wallet.initWalletPayload = initConfig;
+        // 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;
-        if (options.messageTimeouts) {
-            wallet.messageTimeouts = {
-                ...DEFAULT_MESSAGE_TIMEOUTS,
-                ...options.messageTimeouts,
-            };
-        }
+        wallet.messageTimeouts = messageTimeouts;
         return wallet;
     }
     /**
@@ -303,24 +309,16 @@ export class ServiceWorkerReadonlyWallet {
     }
     // 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. The timeout resets
-    // on every intermediate event so long-running but progressing operations
-    // don't time out prematurely.
-    sendMessageStreaming(request, onEvent, isComplete, timeoutMs) {
+    // 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 resetTimeout = () => {
-                clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                    cleanup();
-                    reject(new ServiceWorkerTimeoutError(`Service worker message timed out (${request.type})`));
-                }, timeoutMs);
-            };
             const cleanup = () => {
-                clearTimeout(timeoutId);
                 navigator.serviceWorker.removeEventListener("message", messageHandler);
             };
-            let timeoutId;
-            resetTimeout();
             const messageHandler = (event) => {
                 const response = event.data;
                 if (request.id !== response.id)
@@ -335,7 +333,6 @@ export class ServiceWorkerReadonlyWallet {
                     resolve(response);
                 }
                 else {
-                    resetTimeout();
                     onEvent(response);
                 }
             };
@@ -425,11 +422,10 @@ export class ServiceWorkerReadonlyWallet {
                 await this.reinitialize();
             }
         }
-        const timeoutMs = this.getTimeoutForRequest(request);
         const maxRetries = 2;
         for (let attempt = 0;; attempt++) {
             try {
-                return await this.sendMessageStreaming(request, onEvent, isComplete, timeoutMs);
+                return await this.sendMessageStreaming(request, onEvent, isComplete);
             }
             catch (error) {
                 if (!isMessageBusNotInitializedError(error) ||
@@ -440,19 +436,68 @@ export class ServiceWorkerReadonlyWallet {
             }
         }
     }
+    /**
+     * 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 () => {
-            if (!this.initConfig || !this.initWalletPayload) {
-                throw new Error("Cannot re-initialize: missing configuration");
-            }
-            await initializeMessageBus(this.serviceWorker, this.initConfig, this.messageBusTimeoutMs);
+            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: this.initWalletPayload,
+                payload,
             };
             await this.sendMessageDirect(initMessage, this.getTimeoutForRequest(initMessage));
         })().finally(() => {
@@ -814,71 +859,72 @@ export class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
     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();
-        // Extract identity and check if it can expose private key
-        const identity = isPrivateKeyIdentity(options.identity)
-            ? options.identity
-            : null;
-        if (!identity) {
-            throw new Error("ServiceWorkerWallet.create() requires a Identity that can expose a single private key");
+        if (!isSigningCapable(options.identity)) {
+            throw new Error("ServiceWorkerWallet.create() requires a signing Identity; got a ReadonlyIdentity");
         }
-        // Extract private key for service worker initialization
-        const privateKey = identity.toHex();
+        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);
-        const initConfig = {
-            key: { privateKey },
+        // 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: options.arkServerUrl,
             arkServerPublicKey: options.arkServerPublicKey,
             delegatorUrl: options.delegatorUrl,
         };
-        await initializeMessageBus(options.serviceWorker, {
-            wallet: initConfig.key,
+        // 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: initConfig.arkServerUrl,
-                publicKey: initConfig.arkServerPublicKey,
+                url: options.arkServerUrl,
+                publicKey: options.arkServerPublicKey,
             },
-            delegatorUrl: initConfig.delegatorUrl,
+            delegatorUrl: options.delegatorUrl,
             indexerUrl: options.indexerUrl,
             esploraUrl: options.esploraUrl,
-            timeoutMs: options.messageBusTimeoutMs,
             settlementConfig: options.settlementConfig,
             watcherConfig: options.watcherConfig,
-        }, options.messageBusTimeoutMs);
+            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: initConfig,
+            payload: initWalletPayload,
         };
         // Initialize the service worker
         await wallet.sendMessage(initMessage);
-        wallet.initConfig = {
-            wallet: initConfig.key,
-            arkServer: {
-                url: initConfig.arkServerUrl,
-                publicKey: initConfig.arkServerPublicKey,
-            },
-            delegatorUrl: initConfig.delegatorUrl,
-            indexerUrl: options.indexerUrl,
-            esploraUrl: options.esploraUrl,
-            settlementConfig: options.settlementConfig,
-            watcherConfig: options.watcherConfig,
-        };
-        wallet.initWalletPayload = initConfig;
+        // 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;
-        if (options.messageTimeouts) {
-            wallet.messageTimeouts = {
-                ...DEFAULT_MESSAGE_TIMEOUTS,
-                ...options.messageTimeouts,
-            };
-        }
+        wallet.messageTimeouts = messageTimeouts;
         return wallet;
     }
     /**