@secondlayer/sdk 16.2.1 → 16.3.0

package/dist/subgraphs/index.d.ts

@@ -963,6 +963,8 @@ type StreamsEventsStreamBitcoinParams = StreamsEventsStreamCommon & {
 	address?: string;
 };
 type StreamsEventsStreamParams = StreamsEventsStreamStacksParams | StreamsEventsStreamBitcoinParams;
+/** Where a `subscribe` connection is in its lifecycle. */
+type StreamsSubscriptionState = "connecting" | "open" | "reconnecting" | "closed";
 type StreamsEventsSubscribeCommon = {
 	/** Resume strictly after this cursor; omit to live-tail from the tip. */
 	fromCursor?: string | null;
@@ -976,6 +978,13 @@ type StreamsEventsSubscribeCommon = {
 	*/
 	onError?: (err: unknown) => void;
 	/**
+	* Lifecycle observer. `connecting` before each connection attempt, `open`
+	* once the server answers, `reconnecting` while backing off after a drop
+	* or error, `closed` once, when the subscription ends (unsubscribed,
+	* aborted, or stopped by an error a retry cannot fix).
+	*/
+	onState?: (state: StreamsSubscriptionState) => void;
+	/**
 	* First reconnect pause in ms (default 1000). Doubles per consecutive
 	* failure up to 30 s with jitter, resets once a frame arrives, and never
 	* undercuts a `Retry-After`.
@@ -2472,6 +2481,9 @@ type IndexSbtcWithdrawal = {
 	btc_block_height: number | null;
 	/** When the sweep crossed the confirmation threshold (ISO), null otherwise. */
 	confirmed_at: string | null;
+	/** Monotonic stamp taken when the sweep became confirmed; resume a scan
+	*  from it with `confirmed_after_seq`. Null while unsettled. */
+	settlement_seq: number | null;
 	requested_at?: string | null;
 	resolved_at?: string | null;
 };

package/dist/subgraphs/index.js

@@ -244,6 +244,22 @@ function resolveAccountKey(accountKey) {
     return;
   return process.env?.SECONDLAYER_API_KEY || undefined;
 }
+function resolveAccountUrl() {
+  const env = typeof process !== "undefined" ? process.env : undefined;
+  return (env?.SL_CREDITS_API_URL || env?.ARCHIVE_OPS_API_URL || HOSTED_API_URL).replace(/\/+$/, "");
+}
+var ACCOUNT_CREDENTIAL_RE = /^s[ks]-sl_/;
+function resolveIdentity(target, options = {}) {
+  const url = target === "account" ? resolveAccountUrl() : resolveBaseUrl();
+  const envKey = target === "account" ? resolveAccountKey() : typeof process !== "undefined" ? process.env?.[INSTANCE_TOKEN_ENV] || undefined : undefined;
+  if (envKey && (target === "instance" || ACCOUNT_CREDENTIAL_RE.test(envKey))) {
+    return { source: "env", token: envKey, url };
+  }
+  if (options.session) {
+    return { source: "session", token: options.session, url };
+  }
+  return { source: "none", token: undefined, url };
+}
 function seg(value) {
   return encodeURIComponent(String(value));
 }
@@ -486,8 +502,14 @@ function subscribeStreamsEvents(opts) {
   const baseDelayMs = opts.reconnectDelayMs ?? params.reconnectDelayMs ?? 1000;
   const staleAfterMs = opts.staleAfterMs ?? params.staleAfterMs ?? SUBSCRIBE_DEFAULT_STALE_AFTER_MS;
   let attempt = 0;
+  const emit = (state) => {
+    try {
+      params.onState?.(state);
+    } catch {}
+  };
   const run = async () => {
     while (!controller.signal.aborted) {
+      emit("connecting");
       try {
         const url = `${opts.baseUrl}/v1/streams/events/stream${buildQuery({
           chain: params.chain === "bitcoin" ? "bitcoin" : undefined,
@@ -509,6 +531,7 @@ function subscribeStreamsEvents(opts) {
           fetchImpl: opts.fetchImpl,
           staleAfterMs,
           mapError: mapStreamsError,
+          onOpen: () => emit("open"),
           onFrame: async (frame) => {
             attempt = 0;
             if (frame.event === "ping" || !frame.data)
@@ -537,6 +560,8 @@ function subscribeStreamsEvents(opts) {
             cursor = parsed.event.cursor ?? cursor;
           }
         });
+        if (!controller.signal.aborted)
+          emit("reconnecting");
         await sleep(reconnectDelay(attempt, baseDelayMs, undefined, opts.random), controller.signal);
         attempt += 1;
       } catch (err) {
@@ -545,13 +570,14 @@ function subscribeStreamsEvents(opts) {
         params.onError?.(err);
         if (isTerminal(err))
           throw err;
+        emit("reconnecting");
         const retryAfterSeconds = err.retryAfterSeconds;
         await sleep(reconnectDelay(attempt, baseDelayMs, retryAfterSeconds, opts.random), controller.signal);
         attempt += 1;
       }
     }
   };
-  const done = run();
+  const done = run().finally(() => emit("closed"));
   done.catch(() => {});
   const unsubscribe = () => controller.abort();
   return Object.assign(unsubscribe, { done });
@@ -569,6 +595,7 @@ async function readSse(opts) {
   if (!res.body) {
     throw new StreamsServerError("Streams SSE response has no body.", 0);
   }
+  opts.onOpen?.();
   for await (const frame of parseSseFrames(res.body, opts.signal, opts.staleAfterMs)) {
     await opts.onFrame(frame);
   }
@@ -1470,13 +1497,70 @@ async function consumeStreamsEvents(opts) {
   }
   return { cursor, pages, emptyPolls };
 }
+async function* pullFromLoop(start, external) {
+  const controller = new AbortController;
+  if (external) {
+    if (external.aborted)
+      controller.abort();
+    else
+      external.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
+  }
+  const state = {
+    delivered: null,
+    held: null,
+    finished: false,
+    failure: null,
+    wake: null
+  };
+  const notify = () => {
+    const resolve = state.wake;
+    state.wake = null;
+    resolve?.();
+  };
+  const loop = start((value) => new Promise((release) => {
+    state.delivered = { value, release };
+    notify();
+  }), controller.signal).then(() => {
+    state.finished = true;
+  }, (error) => {
+    state.failure = { error };
+    state.finished = true;
+  }).finally(notify);
+  try {
+    while (true) {
+      if (state.delivered) {
+        const { value, release } = state.delivered;
+        state.delivered = null;
+        state.held = release;
+        yield value;
+        state.held = null;
+        release();
+        continue;
+      }
+      if (state.finished)
+        break;
+      await new Promise((resolve) => {
+        state.wake = resolve;
+        if (state.delivered || state.finished)
+          notify();
+      });
+    }
+    if (state.failure)
+      throw state.failure.error;
+  } finally {
+    controller.abort();
+    state.held?.();
+    state.delivered?.release();
+    await loop;
+  }
+}
 async function* iterateStreamsBatches(opts) {
-  const sleep = opts.sleep ?? defaultSleep;
-  let cursor = opts.fromCursor ?? null;
-  while (!opts.signal?.aborted) {
-    const envelope = await opts.fetchEvents({
-      cursor,
-      limit: opts.batchSize,
+  yield* pullFromLoop(async (deliver, signal) => {
+    const result = await consumeStreamsEvents({
+      fromCursor: opts.fromCursor,
+      batchSize: opts.batchSize,
       chain: opts.chain,
       types: opts.types,
       notTypes: opts.notTypes,
@@ -1486,38 +1570,41 @@ async function* iterateStreamsBatches(opts) {
       assetIdentifier: opts.assetIdentifier,
       rune: opts.rune,
       address: opts.address,
-      filters: opts.filters
+      filters: opts.filters,
+      fetchEvents: opts.fetchEvents,
+      sleep: opts.sleep,
+      emptyBackoffMs: opts.intervalMs,
+      signal,
+      onBatch: async (events, ctx) => {
+        if (events.length === 0 && ctx.reorgs.length === 0)
+          return;
+        await deliver({
+          events,
+          cursor: ctx.cursor,
+          tip: ctx.tip,
+          reorgs: [...ctx.reorgs]
+        });
+      }
     });
-    const checkpoint = envelope.next_cursor ?? cursor;
-    if (envelope.events.length > 0 || envelope.reorgs.length > 0) {
-      yield {
-        events: envelope.events,
-        cursor: checkpoint,
-        tip: envelope.tip,
-        reorgs: envelope.reorgs
-      };
-    }
-    const advanced = checkpoint !== null && checkpoint !== cursor;
-    cursor = checkpoint;
-    if (!advanced && envelope.events.length === 0) {
-      if (opts.signal?.aborted)
-        return;
-      await sleep(opts.intervalMs, opts.signal);
-    }
+    assertNotStalled(result, signal);
+  }, opts.signal);
+}
+function assertNotStalled(result, signal, bounds = {}) {
+  if (signal.aborted)
+    return;
+  if (bounds.maxPages !== undefined && (bounds.pages ?? 0) >= bounds.maxPages) {
+    return;
+  }
+  if (bounds.maxEmptyPolls !== undefined && result.emptyPolls >= bounds.maxEmptyPolls) {
+    return;
   }
+  throw new StreamsServerError(`Streams returned events at cursor ${result.cursor ?? "(start)"} but the cursor did not advance, so the stream stopped instead of re-reading the same page.`, 0, undefined, "CURSOR_STALLED");
 }
 async function* streamStreamsEvents(opts) {
-  const sleep = opts.sleep ?? defaultSleep;
-  const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
-  const maxPages = opts.maxPages ?? Number.POSITIVE_INFINITY;
-  const maxEmptyPolls = opts.maxEmptyPolls ?? Number.POSITIVE_INFINITY;
-  let cursor = opts.fromCursor ?? null;
-  let pages = 0;
-  let emptyPolls = 0;
-  while (pages < maxPages && emptyPolls < maxEmptyPolls && !opts.signal?.aborted) {
-    const envelope = await opts.fetchEvents({
-      cursor,
-      limit: opts.batchSize,
+  yield* pullFromLoop(async (deliver, signal) => {
+    const result = await consumeStreamsEvents({
+      fromCursor: opts.fromCursor,
+      batchSize: opts.batchSize,
       chain: opts.chain,
       types: opts.types,
       notTypes: opts.notTypes,
@@ -1527,29 +1614,27 @@ async function* streamStreamsEvents(opts) {
       assetIdentifier: opts.assetIdentifier,
       rune: opts.rune,
       address: opts.address,
-      filters: opts.filters
+      filters: opts.filters,
+      fetchEvents: opts.fetchEvents,
+      sleep: opts.sleep,
+      emptyBackoffMs: opts.emptyBackoffMs,
+      maxPages: opts.maxPages,
+      maxEmptyPolls: opts.maxEmptyPolls,
+      signal,
+      onBatch: async (events) => {
+        for (const event of events) {
+          if (signal.aborted)
+            return;
+          await deliver(event);
+        }
+      }
     });
-    pages++;
-    for (const event of envelope.events) {
-      if (opts.signal?.aborted)
-        return;
-      yield event;
-    }
-    const nextCursor = envelope.next_cursor;
-    if (nextCursor && nextCursor !== cursor) {
-      cursor = nextCursor;
-      emptyPolls = 0;
-      continue;
-    }
-    if (envelope.events.length === 0) {
-      emptyPolls++;
-      if (emptyPolls >= maxEmptyPolls || pages >= maxPages)
-        return;
-      await sleep(emptyBackoffMs, opts.signal);
-      continue;
-    }
-    return;
-  }
+    assertNotStalled(result, signal, {
+      maxPages: opts.maxPages,
+      maxEmptyPolls: opts.maxEmptyPolls,
+      pages: result.pages
+    });
+  }, opts.signal);
 }
 
 // src/index-api/consumer.ts
@@ -2311,6 +2396,33 @@ function createStreamsDumps(opts) {
   return { list, fileUrl, download };
 }
 
+// src/streams/timeout-fetch.ts
+var STREAMS_CONNECT_TIMEOUT_MS = 30000;
+function withConnectTimeout(fetchImpl, timeoutMs) {
+  if (!(timeoutMs > 0) || !Number.isFinite(timeoutMs))
+    return fetchImpl;
+  return async (input, init) => {
+    const callerSignal = init?.signal ?? undefined;
+    const timeout = new AbortController;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      timeout.abort();
+    }, timeoutMs);
+    const signal = callerSignal ? AbortSignal.any([callerSignal, timeout.signal]) : timeout.signal;
+    try {
+      return await fetchImpl(input, { ...init, signal });
+    } catch (err) {
+      if (timedOut && !callerSignal?.aborted) {
+        throw new StreamsServerError(`No response headers within ${timeoutMs}ms. Retryable.`, 0, undefined, "REQUEST_TIMEOUT");
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+
 // src/streams/client.ts
 function cursorTuple(cursor) {
   if (!cursor)
@@ -2356,7 +2468,7 @@ function createStreamsClient(options) {
     "x-sl-origin": origin,
     ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
   });
-  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const fetchImpl = withConnectTimeout(options.fetchImpl ?? ((input, init) => fetch(input, init)), options.connectTimeoutMs ?? STREAMS_CONNECT_TIMEOUT_MS);
   const verify = options.verify;
   const verifyMode = verify === false ? "off" : verify === undefined ? "lenient" : "strict";
   if (verify === true && baseUrl.startsWith("http:") && !isLoopbackUrl(baseUrl)) {
@@ -2846,5 +2958,5 @@ export {
   getSubgraph
 };
 
-//# debugId=4BBCD55406927B9364756E2164756E21
+//# debugId=82C9947AF210E6E964756E2164756E21
 //# sourceMappingURL=index.js.map