@arkade-os/sdk 0.4.18 → 0.4.20

package/dist/esm/providers/ark.js

@@ -1,5 +1,5 @@
 import { hex } from "@scure/base";
-import { eventSourceIterator } from './utils.js';
+import { eventSourceIterator, isEventSourceError } from './utils.js';
 import { maybeArkError } from './errors.js';
 import { Intent } from '../intent/index.js';
 export var SettlementEventType;
@@ -227,28 +227,21 @@ export class RestArkProvider {
         const queryParams = topics.length > 0
             ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
             : "";
-        // Create first EventSource eagerly so events are buffered
-        // before the caller starts iterating, preventing race conditions
-        // where the server emits events before iteration begins.
-        const eagerEventSource = new EventSource(url + queryParams);
-        const eagerIterator = eventSourceIterator(eagerEventSource);
+        // The EventSource is allocated inside the generator body so that
+        // abandoning the returned iterator before iteration starts does not
+        // 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;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
-        return (async function* () {
-            let firstIteration = true;
-            while (!signal?.aborted) {
-                const eventSource = firstIteration
-                    ? eagerEventSource
-                    : new EventSource(url + queryParams);
-                const iterator = firstIteration
-                    ? eagerIterator
-                    : eventSourceIterator(eventSource);
-                firstIteration = false;
-                try {
-                    const abortHandler = () => {
-                        eventSource.close();
-                    };
-                    signal?.addEventListener("abort", abortHandler);
+        const gen = (async function* () {
+            const abortHandler = () => eventSource?.close();
+            signal?.addEventListener("abort", abortHandler);
+            try {
+                while (!signal?.aborted) {
+                    eventSource = new EventSource(url + queryParams);
+                    const iterator = eventSourceIterator(eventSource);
                     try {
                         for await (const event of iterator) {
                             if (signal?.aborted)
@@ -266,25 +259,39 @@ export class RestArkProvider {
                             }
                         }
                     }
+                    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 (isEventSourceError(error)) {
+                            throw error;
+                        }
+                        console.error("Event stream error:", error);
+                        throw error;
+                    }
                     finally {
-                        signal?.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("Event stream error:", error);
-                    throw error;
-                }
+            }
+            finally {
+                signal?.removeEventListener("abort", abortHandler);
+                eventSource?.close();
             }
         })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            eventSource?.close();
+            return origReturn(value);
+        };
+        return gen;
     }
     async *getTransactionsStream(signal) {
         const url = `${this.serverUrl}/v1/txs`;
@@ -319,7 +326,8 @@ export class RestArkProvider {
                 }
             }
             catch (error) {
-                if (error instanceof Error && error.name === "AbortError") {
+                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
@@ -327,6 +335,9 @@ export class RestArkProvider {
                     console.debug("Timeout error ignored");
                     continue;
                 }
+                if (isEventSourceError(error)) {
+                    throw error;
+                }
                 console.error("Transaction stream error:", error);
                 throw error;
             }