@arkade-os/sdk 0.4.20 → 0.4.21

package/dist/cjs/contracts/contractWatcher.js

@@ -254,13 +254,18 @@ class ContractWatcher {
     }
     /**
      * Connect to the subscription.
+     *
+     * @param skipUpdate - Skip the leading `updateSubscription` call when
+     *   the caller has already established `subscriptionId`.
      */
-    async connect() {
+    async connect(skipUpdate = false) {
         if (!this.isWatching)
             return;
         this.connectionState = "connecting";
         try {
-            await this.updateSubscription();
+            if (!skipUpdate) {
+                await this.updateSubscription();
+            }
             // Poll immediately after connection to sync state
             await this.pollAllContracts();
             this.connectionState = "connected";
@@ -391,11 +396,30 @@ class ContractWatcher {
         }
     }
     async tryUpdateSubscription() {
+        const hadSubscription = this.subscriptionId !== undefined;
         try {
             await this.updateSubscription();
         }
         catch (error) {
             // nothing, the connection will be retried later
+            return;
+        }
+        // Cold start: `startWatching` may have run with zero scripts,
+        // leaving `listenLoop` parked behind the reconnect timer. Kick
+        // `connect` now so streaming resumes without waiting on the
+        // backoff. `skipUpdate` avoids re-issuing `subscribeForScripts`.
+        const justGotSubscription = !hadSubscription && this.subscriptionId !== undefined;
+        const listenerParked = this.connectionState === "disconnected" ||
+            this.connectionState === "reconnecting";
+        if (this.isWatching && justGotSubscription && listenerParked) {
+            if (this.reconnectTimeoutId) {
+                clearTimeout(this.reconnectTimeoutId);
+                this.reconnectTimeoutId = undefined;
+            }
+            this.reconnectAttempts = 0;
+            this.connect(true).catch((error) => {
+                console.warn("ContractWatcher cold-start connect failed:", error);
+            });
         }
     }
     /**

package/dist/cjs/providers/ark.js

@@ -236,18 +236,19 @@ class RestArkProvider {
         // leak the underlying SSE connection. `return()` is overridden below
         // so that closing the generator also closes the connection even when
         // the body is currently suspended at an await point.
-        let eventSource = null;
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const gen = (async function* () {
-            const abortHandler = () => eventSource?.close();
+            const abortHandler = closeIterator;
             signal?.addEventListener("abort", abortHandler);
             try {
                 while (!signal?.aborted) {
-                    eventSource = new EventSource(url + queryParams);
-                    const iterator = (0, utils_1.eventSourceIterator)(eventSource);
+                    const currentIterator = (0, utils_1.eventSourceIterator)(new EventSource(url + queryParams));
+                    iterator = currentIterator;
                     try {
-                        for await (const event of iterator) {
+                        for await (const event of currentIterator) {
                             if (signal?.aborted)
                                 break;
                             try {
@@ -281,71 +282,87 @@ class RestArkProvider {
                         throw error;
                     }
                     finally {
-                        eventSource.close();
+                        currentIterator.close();
+                        iterator = null;
                     }
                 }
             }
             finally {
                 signal?.removeEventListener("abort", abortHandler);
-                eventSource?.close();
+                closeIterator();
             }
         })();
         const origReturn = gen.return.bind(gen);
         gen.return = (value) => {
-            eventSource?.close();
+            closeIterator();
             return origReturn(value);
         };
         return gen;
     }
-    async *getTransactionsStream(signal) {
+    getTransactionsStream(signal) {
         const url = `${this.serverUrl}/v1/txs`;
-        while (!signal?.aborted) {
+        let iterator = null;
+        const closeIterator = () => iterator?.close();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const gen = (async function* () {
+            const abortHandler = closeIterator;
+            signal?.addEventListener("abort", abortHandler);
             try {
-                const eventSource = new EventSource(url);
-                // Set up abort handling
-                const abortHandler = () => {
-                    eventSource.close();
-                };
-                signal?.addEventListener("abort", abortHandler);
-                try {
-                    for await (const event of (0, utils_1.eventSourceIterator)(eventSource)) {
-                        if (signal?.aborted)
-                            break;
-                        try {
-                            const data = JSON.parse(event.data);
-                            const txNotification = this.parseTransactionNotification(data);
-                            if (txNotification) {
-                                yield txNotification;
+                while (!signal?.aborted) {
+                    try {
+                        const currentIterator = (0, utils_1.eventSourceIterator)(new EventSource(url));
+                        iterator = currentIterator;
+                        for await (const event of currentIterator) {
+                            if (signal?.aborted)
+                                break;
+                            try {
+                                const data = JSON.parse(event.data);
+                                const txNotification = self.parseTransactionNotification(data);
+                                if (txNotification) {
+                                    yield txNotification;
+                                }
+                            }
+                            catch (err) {
+                                console.error("Failed to parse transaction notification:", err);
+                                throw err;
                             }
                         }
-                        catch (err) {
-                            console.error("Failed to parse transaction notification:", err);
-                            throw err;
+                    }
+                    catch (error) {
+                        if (signal?.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 ((0, utils_1.isEventSourceError)(error)) {
+                            throw error;
+                        }
+                        console.error("Transaction stream error:", error);
+                        throw error;
+                    }
+                    finally {
+                        closeIterator();
+                        iterator = null;
                     }
-                }
-                finally {
-                    signal?.removeEventListener("abort", abortHandler);
-                    eventSource.close();
                 }
             }
-            catch (error) {
-                if (signal?.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 ((0, utils_1.isEventSourceError)(error)) {
-                    throw error;
-                }
-                console.error("Transaction stream error:", error);
-                throw error;
+            finally {
+                signal?.removeEventListener("abort", abortHandler);
+                closeIterator();
             }
-        }
+        })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            closeIterator();
+            return origReturn(value);
+        };
+        return gen;
     }
     async getPendingTxs(intent) {
         const url = `${this.serverUrl}/v1/tx/pending`;

package/dist/cjs/providers/indexer.js

@@ -156,62 +156,75 @@ 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 (0, utils_1.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 = (0, utils_1.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 ((0, ark_1.isFetchTimeoutError)(error)) {
+                            console.debug("Timeout error ignored");
+                            continue;
+                        }
+                        if ((0, utils_1.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 (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 ((0, ark_1.isFetchTimeoutError)(error)) {
-                    console.debug("Timeout error ignored");
-                    continue;
-                }
-                if ((0, utils_1.isEventSourceError)(error)) {
-                    throw error;
-                }
-                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/cjs/providers/utils.js

@@ -2,32 +2,70 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eventSourceIterator = eventSourceIterator;
 exports.isEventSourceError = isEventSourceError;
+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().
  */
 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);
@@ -37,9 +75,9 @@ 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();
@@ -58,17 +96,25 @@ 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;
 }
 function isEventSourceError(error) {
     return error instanceof Error && error.name === "EventSourceError";