@thru/replay 0.1.36

package/dist/index.cjs

@@ -0,0 +1,1196 @@
+'use strict';
+
+var protobuf = require('@bufbuild/protobuf');
+var connect = require('@connectrpc/connect');
+var connectNode = require('@connectrpc/connect-node');
+var proto = require('@thru/proto');
+
+// src/chain-client.ts
+var ChainClient = class {
+  constructor(options) {
+    this.options = options;
+    const transport = options.transport ?? this.createTransport();
+    this.query = connect.createClient(proto.QueryService, transport);
+    this.streaming = connect.createClient(proto.StreamingService, transport);
+    this.callOptions = options.callOptions;
+  }
+  query;
+  streaming;
+  callOptions;
+  listBlocks(request) {
+    return this.query.listBlocks(protobuf.create(proto.ListBlocksRequestSchema, request), this.callOptions);
+  }
+  streamBlocks(request) {
+    return this.streaming.streamBlocks(protobuf.create(proto.StreamBlocksRequestSchema, request), this.callOptions);
+  }
+  listTransactions(request) {
+    return this.query.listTransactions(protobuf.create(proto.ListTransactionsRequestSchema, request), this.callOptions);
+  }
+  streamTransactions(request) {
+    return this.streaming.streamTransactions(protobuf.create(proto.StreamTransactionsRequestSchema, request), this.callOptions);
+  }
+  listEvents(request) {
+    return this.query.listEvents(protobuf.create(proto.ListEventsRequestSchema, request), this.callOptions);
+  }
+  streamEvents(request) {
+    return this.streaming.streamEvents(protobuf.create(proto.StreamEventsRequestSchema, request), this.callOptions);
+  }
+  createTransport() {
+    if (!this.options.baseUrl) {
+      throw new Error("ChainClient requires baseUrl when no transport is provided");
+    }
+    const headerInterceptor = this.createHeaderInterceptor();
+    const userInterceptors = this.options.interceptors ?? [];
+    const mergedInterceptors = [
+      ...userInterceptors,
+      ...headerInterceptor ? [headerInterceptor] : []
+    ];
+    return connectNode.createGrpcTransport({
+      baseUrl: this.options.baseUrl,
+      useBinaryFormat: this.options.useBinaryFormat ?? true,
+      interceptors: mergedInterceptors.length ? mergedInterceptors : void 0
+    });
+  }
+  createHeaderInterceptor() {
+    const headers = {};
+    if (this.options.apiKey) headers.Authorization = `Bearer ${this.options.apiKey}`;
+    if (this.options.userAgent) headers["User-Agent"] = this.options.userAgent;
+    if (!Object.keys(headers).length) return null;
+    return (next) => async (req) => {
+      for (const [key, value] of Object.entries(headers)) req.header.set(key, value);
+      return next(req);
+    };
+  }
+  streamAccountUpdates(request) {
+    return this.streaming.streamAccountUpdates(protobuf.create(proto.StreamAccountUpdatesRequestSchema, request), this.callOptions);
+  }
+  getHeight() {
+    return this.query.getHeight(protobuf.create(proto.GetHeightRequestSchema, {}), this.callOptions);
+  }
+};
+
+// src/async-queue.ts
+var AsyncQueue = class {
+  values = [];
+  pending = [];
+  closed = false;
+  failure;
+  push(value) {
+    if (this.closed) throw new Error("Cannot push into a closed queue");
+    if (this.failure) throw this.failure;
+    const waiter = this.pending.shift();
+    if (waiter) waiter.resolve({ value, done: false });
+    else this.values.push(value);
+  }
+  next() {
+    if (this.failure) return Promise.reject(this.failure);
+    if (this.values.length) {
+      const value = this.values.shift();
+      return Promise.resolve({ value, done: false });
+    }
+    if (this.closed) return Promise.resolve({ value: void 0, done: true });
+    return new Promise((resolve, reject) => {
+      this.pending.push({ resolve, reject });
+    });
+  }
+  close() {
+    this.closed = true;
+    while (this.pending.length) {
+      const waiter = this.pending.shift();
+      waiter?.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(err) {
+    this.failure = err ?? new Error("AsyncQueue failure");
+    while (this.pending.length) {
+      const waiter = this.pending.shift();
+      waiter?.reject(this.failure);
+    }
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => this.next()
+    };
+  }
+};
+
+// src/dedup-buffer.ts
+var DedupBuffer = class {
+  slotOf;
+  keyOf;
+  slots = [];
+  itemsBySlot = /* @__PURE__ */ new Map();
+  sizeValue = 0;
+  constructor(options) {
+    this.slotOf = options.slotOf;
+    this.keyOf = options.keyOf;
+  }
+  insert(item) {
+    const slot = this.slotOf(item);
+    const key = this.keyOf(item);
+    let bucket = this.itemsBySlot.get(slot);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      this.itemsBySlot.set(slot, bucket);
+      const idx = this.findInsertIndex(slot);
+      this.slots.splice(idx, 0, slot);
+    }
+    if (bucket.has(key)) return false;
+    bucket.set(key, item);
+    this.sizeValue += 1;
+    return true;
+  }
+  discardUpTo(cutoff) {
+    let removed = 0;
+    while (this.slots.length && this.slots[0] <= cutoff) {
+      const slot = this.slots.shift();
+      const bucket = this.itemsBySlot.get(slot);
+      if (!bucket) continue;
+      removed += bucket.size;
+      this.itemsBySlot.delete(slot);
+    }
+    this.sizeValue = Math.max(0, this.sizeValue - removed);
+    return removed;
+  }
+  drainAbove(cutoff) {
+    if (!this.slots.length) return [];
+    const drained = [];
+    const keep = [];
+    for (const slot of this.slots) {
+      if (slot > cutoff) {
+        const bucket = this.itemsBySlot.get(slot);
+        if (bucket) {
+          for (const item of bucket.values()) drained.push(item);
+          this.itemsBySlot.delete(slot);
+          this.sizeValue -= bucket.size;
+        }
+      } else {
+        keep.push(slot);
+      }
+    }
+    this.slots.length = 0;
+    this.slots.push(...keep);
+    return drained;
+  }
+  drainAll() {
+    if (!this.slots.length) return [];
+    const drained = [];
+    for (const slot of this.slots) {
+      const bucket = this.itemsBySlot.get(slot);
+      if (!bucket) continue;
+      for (const item of bucket.values()) drained.push(item);
+      this.sizeValue -= bucket.size;
+      this.itemsBySlot.delete(slot);
+    }
+    this.slots.length = 0;
+    return drained;
+  }
+  minSlot() {
+    return this.slots.length ? this.slots[0] : null;
+  }
+  get size() {
+    return this.sizeValue;
+  }
+  findInsertIndex(slot) {
+    let low = 0;
+    let high = this.slots.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (this.slots[mid] < slot) low = mid + 1;
+      else high = mid;
+    }
+    return low;
+  }
+};
+
+// src/logger.ts
+var noop = () => void 0;
+var NOOP_LOGGER = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop
+};
+function createConsoleLogger(prefix = "Replay") {
+  return {
+    debug: (message, meta) => console.debug(`[${prefix}] ${message}`, meta ?? ""),
+    info: (message, meta) => console.info(`[${prefix}] ${message}`, meta ?? ""),
+    warn: (message, meta) => console.warn(`[${prefix}] ${message}`, meta ?? ""),
+    error: (message, meta) => console.error(`[${prefix}] ${message}`, meta ?? "")
+  };
+}
+
+// src/live-pump.ts
+var LivePump = class {
+  queue = new AsyncQueue();
+  buffer;
+  slotOf;
+  keyOf;
+  source;
+  logger;
+  mode;
+  minSlotSeen = null;
+  maxSlotSeen = null;
+  minEmitSlot = null;
+  pumpPromise;
+  constructor(options) {
+    this.source = options.source;
+    this.slotOf = options.slotOf;
+    this.keyOf = options.keyOf ?? ((item) => options.slotOf(item).toString());
+    this.logger = options.logger ?? NOOP_LOGGER;
+    this.buffer = new DedupBuffer({ slotOf: this.slotOf, keyOf: this.keyOf });
+    this.mode = options.startInStreamingMode ? "streaming" : "buffering";
+    if (options.startInStreamingMode) this.minEmitSlot = options.initialEmitFloor ?? 0n;
+    this.pumpPromise = this.start();
+  }
+  minSlot() {
+    if (this.minSlotSeen !== null) return this.minSlotSeen;
+    return this.buffer.minSlot();
+  }
+  maxSlot() {
+    return this.maxSlotSeen;
+  }
+  bufferedSize() {
+    return this.buffer.size;
+  }
+  discardBufferedUpTo(cutoffSlot) {
+    if (this.mode === "streaming") return 0;
+    const discarded = this.buffer.discardUpTo(cutoffSlot);
+    if (discarded) {
+      this.logger.debug(
+        `discarded ${discarded} buffered items up to cutoff slot ${cutoffSlot}`
+      );
+    }
+    return discarded;
+  }
+  enableStreaming(cutoffSlot) {
+    if (this.mode === "streaming") return { drained: [], discarded: 0 };
+    const discarded = this.discardBufferedUpTo(cutoffSlot);
+    const drained = this.buffer.drainAbove(cutoffSlot);
+    this.mode = "streaming";
+    this.minEmitSlot = cutoffSlot;
+    return { drained, discarded };
+  }
+  updateEmitFloor(slot) {
+    this.minEmitSlot = slot;
+  }
+  async next() {
+    return this.queue.next();
+  }
+  async close() {
+    this.queue.close();
+    await this.pumpPromise;
+  }
+  async start() {
+    try {
+      for await (const item of this.source) {
+        const slot = this.slotOf(item);
+        if (this.minSlotSeen === null || slot < this.minSlotSeen) this.minSlotSeen = slot;
+        if (this.maxSlotSeen === null || slot > this.maxSlotSeen) this.maxSlotSeen = slot;
+        if (this.mode === "buffering") this.buffer.insert(item);
+        else {
+          if (this.minEmitSlot !== null && slot < this.minEmitSlot) continue;
+          this.queue.push(item);
+        }
+      }
+      this.queue.close();
+    } catch (err) {
+      this.queue.fail(err);
+    }
+  }
+};
+
+// src/replay-stream.ts
+var DEFAULT_METRICS = {
+  bufferedItems: 0,
+  emittedBackfill: 0,
+  emittedLive: 0,
+  discardedDuplicates: 0
+};
+function compareBigint(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+var RETRY_DELAY_MS = 1e3;
+var ReplayStream = class {
+  config;
+  logger;
+  metrics = { ...DEFAULT_METRICS };
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? NOOP_LOGGER;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  [Symbol.asyncIterator]() {
+    return this.run();
+  }
+  async *run() {
+    const {
+      startSlot,
+      fetchBackfill,
+      subscribeLive,
+      extractSlot,
+      extractKey,
+      safetyMargin,
+      resubscribeOnEnd
+    } = this.config;
+    const shouldResubscribeOnEnd = resubscribeOnEnd ?? true;
+    const keyOf = extractKey ?? ((item) => extractSlot(item).toString());
+    const createLivePump = (slot, startStreaming = false, emitFloor) => new LivePump({
+      source: subscribeLive(slot),
+      slotOf: extractSlot,
+      keyOf,
+      logger: this.logger,
+      startInStreamingMode: startStreaming,
+      initialEmitFloor: emitFloor
+    });
+    let livePump = createLivePump(startSlot);
+    let cursor;
+    let backfillDone = false;
+    let currentSlot = startSlot > 0n ? startSlot - 1n : 0n;
+    let lastEmittedSlot = null;
+    let lastSlotKeys = /* @__PURE__ */ new Set();
+    const seenItem = (slot, key) => {
+      if (lastEmittedSlot === null) return false;
+      if (slot < lastEmittedSlot) return true;
+      if (slot > lastEmittedSlot) return false;
+      return lastSlotKeys.has(key);
+    };
+    const recordEmission = (slot, key) => {
+      if (lastEmittedSlot === null || slot !== lastEmittedSlot) {
+        lastEmittedSlot = slot;
+        lastSlotKeys = /* @__PURE__ */ new Set([key]);
+      } else {
+        lastSlotKeys.add(key);
+      }
+    };
+    this.logger.info(
+      `replay entering BACKFILLING state (startSlot=${startSlot}, safetyMargin=${safetyMargin})`
+    );
+    while (!backfillDone) {
+      const page = await fetchBackfill({ startSlot, cursor });
+      if (!page.items.length && !page.cursor && !page.done) {
+        this.logger.warn("empty backfill page without cursor; retrying");
+        continue;
+      }
+      const sorted = [...page.items].sort(
+        (a, b) => compareBigint(extractSlot(a), extractSlot(b))
+      );
+      for (const item of sorted) {
+        const slot = extractSlot(item);
+        const key = keyOf(item);
+        if (slot < startSlot) continue;
+        if (seenItem(slot, key)) {
+          this.metrics.discardedDuplicates += 1;
+          continue;
+        }
+        currentSlot = slot;
+        recordEmission(slot, key);
+        this.metrics.emittedBackfill += 1;
+        yield item;
+      }
+      const duplicatesTrimmed = livePump.discardBufferedUpTo(currentSlot);
+      this.metrics.discardedDuplicates += duplicatesTrimmed;
+      cursor = page.cursor;
+      const maxStreamSlot = livePump.maxSlot();
+      if (maxStreamSlot !== null) {
+        const catchUpSlot = maxStreamSlot > safetyMargin ? maxStreamSlot - safetyMargin : 0n;
+        if (currentSlot >= catchUpSlot) {
+          this.logger.info(
+            `replay reached SWITCHING threshold (currentSlot=${currentSlot}, maxStreamSlot=${maxStreamSlot}, catchUpSlot=${catchUpSlot})`
+          );
+          backfillDone = true;
+        }
+      }
+      if (page.done || cursor === void 0) backfillDone = true;
+    }
+    this.logger.info(`replay entering SWITCHING state (currentSlot=${currentSlot})`);
+    const { drained, discarded } = livePump.enableStreaming(currentSlot);
+    this.metrics.bufferedItems = drained.length;
+    this.metrics.discardedDuplicates += discarded;
+    for (const item of drained) {
+      const slot = extractSlot(item);
+      const key = keyOf(item);
+      if (seenItem(slot, key)) {
+        this.metrics.discardedDuplicates += 1;
+        continue;
+      }
+      currentSlot = slot;
+      recordEmission(slot, key);
+      this.metrics.emittedLive += 1;
+      yield item;
+      livePump.updateEmitFloor(currentSlot);
+    }
+    if (!drained.length) livePump.updateEmitFloor(currentSlot);
+    this.logger.info("replay entering STREAMING state");
+    while (true) {
+      try {
+        const next = await livePump.next();
+        if (next.done) {
+          if (!shouldResubscribeOnEnd) break;
+          throw new Error("stream ended");
+        }
+        const slot = extractSlot(next.value);
+        const key = keyOf(next.value);
+        if (seenItem(slot, key)) {
+          this.metrics.discardedDuplicates += 1;
+          continue;
+        }
+        currentSlot = slot;
+        recordEmission(slot, key);
+        this.metrics.emittedLive += 1;
+        yield next.value;
+        livePump.updateEmitFloor(currentSlot);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        this.logger.warn(
+          `live stream disconnected (${errMsg}); reconnecting in ${RETRY_DELAY_MS}ms from slot ${currentSlot}`
+        );
+        await delay(RETRY_DELAY_MS);
+        await safeClose(livePump);
+        const resumeSlot = currentSlot > 0n ? currentSlot : 0n;
+        livePump = createLivePump(resumeSlot, true, currentSlot);
+      }
+    }
+  }
+};
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function safeClose(pump) {
+  try {
+    await pump.close();
+  } catch {
+  }
+}
+function combineFilters(base, user) {
+  if (!base && !user) return void 0;
+  if (!base) return user;
+  if (!user) return base;
+  const expressionParts = [];
+  if (base.expression) expressionParts.push(`(${base.expression})`);
+  if (user.expression) expressionParts.push(`(${user.expression})`);
+  return protobuf.create(proto.FilterSchema, {
+    expression: expressionParts.join(" && ") || void 0,
+    params: { ...base.params, ...user.params }
+  });
+}
+function slotLiteralFilter(fieldExpr, slot) {
+  return protobuf.create(proto.FilterSchema, {
+    expression: `${fieldExpr} >= uint(${slot.toString()})`
+  });
+}
+function backfillPage(items, page) {
+  const cursor = page?.nextPageToken ?? void 0;
+  return {
+    items,
+    cursor,
+    done: !cursor
+  };
+}
+async function* mapAsyncIterable(iterable, selector) {
+  for await (const value of iterable) {
+    const mapped = selector(value);
+    if (mapped !== void 0 && mapped !== null) yield mapped;
+  }
+}
+
+// src/replay/block-replay.ts
+var DEFAULT_PAGE_SIZE = 128;
+var DEFAULT_SAFETY_MARGIN = 32n;
+var PAGE_ORDER_ASC = "slot asc";
+function createBlockReplay(options) {
+  const safetyMargin = options.safetyMargin ?? DEFAULT_SAFETY_MARGIN;
+  const logger = options.logger ?? NOOP_LOGGER;
+  const fetchBackfill = async ({
+    startSlot,
+    cursor
+  }) => {
+    const page = protobuf.create(proto.PageRequestSchema, {
+      pageSize: options.pageSize ?? DEFAULT_PAGE_SIZE,
+      orderBy: PAGE_ORDER_ASC,
+      pageToken: cursor
+    });
+    const mergedFilter = combineFilters(slotLiteralFilter("block.header.slot", startSlot), options.filter);
+    logger.debug?.("block backfill request", {
+      startSlot: startSlot.toString(),
+      cursor,
+      pageSize: page.pageSize
+    });
+    let response;
+    try {
+      response = await options.client.listBlocks(
+        protobuf.create(proto.ListBlocksRequestSchema, {
+          filter: mergedFilter,
+          page,
+          view: options.view,
+          minConsensus: options.minConsensus
+        })
+      );
+    } catch (err) {
+      logger.error("block backfill request failed", {
+        startSlot: startSlot.toString(),
+        cursor,
+        err
+      });
+      throw err;
+    }
+    return backfillPage(response.blocks, response.page);
+  };
+  const subscribeLive = (startSlot) => {
+    const request = protobuf.create(proto.StreamBlocksRequestSchema, {
+      startSlot,
+      filter: options.filter,
+      view: options.view,
+      minConsensus: options.minConsensus
+    });
+    return mapAsyncIterable(
+      options.client.streamBlocks(request),
+      (resp) => resp.block
+    );
+  };
+  return new ReplayStream({
+    startSlot: options.startSlot,
+    safetyMargin,
+    fetchBackfill,
+    subscribeLive,
+    extractSlot: (block) => block.header?.slot ?? 0n,
+    logger: options.logger,
+    resubscribeOnEnd: options.resubscribeOnEnd
+  });
+}
+var DEFAULT_PAGE_SIZE2 = 256;
+var DEFAULT_SAFETY_MARGIN2 = 64n;
+var PAGE_ORDER_ASC2 = "slot asc";
+function createTransactionReplay(options) {
+  const safetyMargin = options.safetyMargin ?? DEFAULT_SAFETY_MARGIN2;
+  const fetchBackfill = async ({
+    startSlot,
+    cursor
+  }) => {
+    const page = protobuf.create(proto.PageRequestSchema, {
+      pageSize: options.pageSize ?? DEFAULT_PAGE_SIZE2,
+      orderBy: PAGE_ORDER_ASC2,
+      pageToken: cursor
+    });
+    const mergedFilter = combineFilters(slotLiteralFilter("transaction.slot", startSlot), options.filter);
+    const response = await options.client.listTransactions(
+      protobuf.create(proto.ListTransactionsRequestSchema, {
+        filter: mergedFilter,
+        page,
+        minConsensus: options.minConsensus,
+        returnEvents: options.returnEvents
+      })
+    );
+    return backfillPage(response.transactions, response.page);
+  };
+  const subscribeLive = (startSlot) => {
+    const mergedFilter = combineFilters(slotLiteralFilter("transaction.slot", startSlot), options.filter);
+    const request = protobuf.create(proto.StreamTransactionsRequestSchema, {
+      filter: mergedFilter,
+      minConsensus: options.minConsensus
+    });
+    return mapAsyncIterable(
+      options.client.streamTransactions(request),
+      (resp) => resp.transaction
+    );
+  };
+  return new ReplayStream({
+    startSlot: options.startSlot,
+    safetyMargin,
+    fetchBackfill,
+    subscribeLive,
+    extractSlot: (tx) => tx.slot ?? 0n,
+    extractKey: transactionKey,
+    logger: options.logger,
+    resubscribeOnEnd: options.resubscribeOnEnd
+  });
+}
+function transactionKey(tx) {
+  const signatureBytes = tx.signature?.value;
+  if (signatureBytes && signatureBytes.length) return bytesToHex(signatureBytes);
+  const slotPart = tx.slot?.toString() ?? "0";
+  const offsetPart = tx.blockOffset?.toString() ?? "0";
+  return `${slotPart}:${offsetPart}`;
+}
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+var DEFAULT_PAGE_SIZE3 = 512;
+var DEFAULT_SAFETY_MARGIN3 = 64n;
+var PAGE_ORDER_ASC3 = "slot asc";
+function createEventReplay(options) {
+  const safetyMargin = options.safetyMargin ?? DEFAULT_SAFETY_MARGIN3;
+  const fetchBackfill = async ({
+    startSlot,
+    cursor
+  }) => {
+    const page = protobuf.create(proto.PageRequestSchema, {
+      pageSize: options.pageSize ?? DEFAULT_PAGE_SIZE3,
+      orderBy: PAGE_ORDER_ASC3,
+      pageToken: cursor
+    });
+    const baseFilter = slotLiteralFilter("event.slot", startSlot);
+    const mergedFilter = combineFilters(baseFilter, options.filter);
+    const response = await options.client.listEvents(
+      protobuf.create(proto.ListEventsRequestSchema, {
+        filter: mergedFilter,
+        page
+      })
+    );
+    return backfillPage(response.events, response.page);
+  };
+  const subscribeLive = (startSlot) => {
+    const mergedFilter = combineFilters(slotLiteralFilter("event.slot", startSlot), options.filter);
+    const request = protobuf.create(proto.StreamEventsRequestSchema, {
+      filter: mergedFilter
+    });
+    return mapAsyncIterable(
+      options.client.streamEvents(request),
+      (resp) => streamResponseToEvent(resp)
+    );
+  };
+  return new ReplayStream({
+    startSlot: options.startSlot,
+    safetyMargin,
+    fetchBackfill,
+    subscribeLive,
+    extractSlot: (event) => event.slot ?? 0n,
+    extractKey: eventKey,
+    logger: options.logger,
+    resubscribeOnEnd: options.resubscribeOnEnd
+  });
+}
+function streamResponseToEvent(resp) {
+  return protobuf.create(proto.EventSchema, {
+    eventId: resp.eventId,
+    transactionSignature: resp.signature,
+    program: resp.program,
+    payload: resp.payload,
+    slot: resp.slot,
+    callIdx: resp.callIdx,
+    timestamp: resp.timestamp
+  });
+}
+function eventKey(event) {
+  if (event.eventId) return event.eventId;
+  const slotPart = event.slot?.toString() ?? "0";
+  return `${slotPart}:${event.callIdx ?? 0}`;
+}
+
+// src/page-assembler.ts
+var PAGE_SIZE = 4096;
+function addressToKey(address) {
+  return Array.from(address).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function calculatePageCount(dataSize) {
+  if (dataSize === 0) return 0;
+  return Math.ceil(dataSize / PAGE_SIZE);
+}
+var PageAssembler = class {
+  assemblyTimeout;
+  maxPendingPerAddress;
+  /**
+   * Pending updates keyed by address (hex) -> seq (string) -> PendingUpdate
+   */
+  pending = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.assemblyTimeout = options.assemblyTimeout ?? 3e4;
+    this.maxPendingPerAddress = options.maxPendingPerAddress ?? 10;
+  }
+  /**
+   * Process an account update and return assembled account if complete.
+   *
+   * @param address - Account address bytes
+   * @param update - Account update from streaming response
+   * @returns Assembled account if all pages received, null otherwise
+   */
+  processUpdate(address, update) {
+    const addressKey = addressToKey(address);
+    if (update.delete) {
+      return {
+        address,
+        slot: BigInt(update.slot.toString()),
+        seq: update.meta?.seq ? BigInt(update.meta.seq.toString()) : 0n,
+        meta: update.meta,
+        data: new Uint8Array(0),
+        isDelete: true
+      };
+    }
+    if (!update.meta) {
+      return null;
+    }
+    const seq = BigInt(update.meta.seq.toString());
+    const seqKey = seq.toString();
+    const slot = BigInt(update.slot.toString());
+    let addressPending = this.pending.get(addressKey);
+    if (!addressPending) {
+      addressPending = /* @__PURE__ */ new Map();
+      this.pending.set(addressKey, addressPending);
+    }
+    let pendingUpdate = addressPending.get(seqKey);
+    if (!pendingUpdate) {
+      const expectedPageCount = calculatePageCount(update.meta.dataSize);
+      pendingUpdate = {
+        slot,
+        seq,
+        meta: update.meta,
+        pages: /* @__PURE__ */ new Map(),
+        expectedPageCount,
+        receivedAt: Date.now()
+      };
+      addressPending.set(seqKey, pendingUpdate);
+      this.evictOldPending(addressPending);
+    }
+    if (update.page) {
+      pendingUpdate.pages.set(update.page.pageIdx, {
+        pageIdx: update.page.pageIdx,
+        pageData: update.page.pageData
+      });
+    }
+    if (pendingUpdate.pages.size >= pendingUpdate.expectedPageCount) {
+      addressPending.delete(seqKey);
+      if (addressPending.size === 0) {
+        this.pending.delete(addressKey);
+      }
+      const data = this.assemblePages(pendingUpdate);
+      return {
+        address,
+        slot: pendingUpdate.slot,
+        seq: pendingUpdate.seq,
+        meta: pendingUpdate.meta,
+        data,
+        isDelete: false
+      };
+    }
+    return null;
+  }
+  /**
+   * Assemble complete data from buffered pages
+   */
+  assemblePages(pending) {
+    const totalSize = pending.meta.dataSize;
+    if (totalSize === 0 || pending.expectedPageCount === 0) {
+      return new Uint8Array(0);
+    }
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (let i = 0; i < pending.expectedPageCount; i++) {
+      const page = pending.pages.get(i);
+      if (page) {
+        result.set(page.pageData, offset);
+        offset += page.pageData.length;
+      }
+    }
+    return result;
+  }
+  /**
+   * Evict old pending updates for an address if limit exceeded
+   */
+  evictOldPending(addressPending) {
+    if (addressPending.size <= this.maxPendingPerAddress) {
+      return;
+    }
+    const entries = Array.from(addressPending.entries());
+    entries.sort((a, b) => a[1].receivedAt - b[1].receivedAt);
+    const toEvict = entries.length - this.maxPendingPerAddress;
+    for (let i = 0; i < toEvict; i++) {
+      addressPending.delete(entries[i][0]);
+    }
+  }
+  /**
+   * Clean up expired pending assemblies.
+   * Call this periodically to prevent memory leaks.
+   */
+  cleanup() {
+    const now = Date.now();
+    let evicted = 0;
+    for (const [addressKey, addressPending] of this.pending.entries()) {
+      for (const [seqKey, pending] of addressPending.entries()) {
+        if (now - pending.receivedAt > this.assemblyTimeout) {
+          addressPending.delete(seqKey);
+          evicted++;
+        }
+      }
+      if (addressPending.size === 0) {
+        this.pending.delete(addressKey);
+      }
+    }
+    return evicted;
+  }
+  /**
+   * Get current pending count for debugging
+   */
+  getPendingCount() {
+    let count = 0;
+    for (const addressPending of this.pending.values()) {
+      count += addressPending.size;
+    }
+    return count;
+  }
+  /**
+   * Clear all pending assemblies
+   */
+  clear() {
+    this.pending.clear();
+  }
+};
+
+// src/account-replay.ts
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function snapshotToState(account) {
+  if (!account.address?.value || !account.meta) {
+    return null;
+  }
+  return {
+    address: account.address.value,
+    addressHex: bytesToHex2(account.address.value),
+    slot: account.versionContext?.slot ?? 0n,
+    seq: BigInt(account.meta.seq.toString()),
+    meta: account.meta,
+    data: account.data?.data ?? new Uint8Array(0),
+    isDelete: account.meta.flags?.isDeleted ?? false,
+    source: "snapshot"
+  };
+}
+function assembledToState(assembled) {
+  return {
+    address: assembled.address,
+    addressHex: bytesToHex2(assembled.address),
+    slot: assembled.slot,
+    seq: assembled.seq,
+    meta: assembled.meta,
+    data: assembled.data,
+    isDelete: assembled.isDelete,
+    source: "update"
+  };
+}
+async function* createAccountReplay(options) {
+  const {
+    client,
+    address,
+    view = proto.AccountView.FULL,
+    filter,
+    pageAssemblerOptions,
+    cleanupInterval = 1e4
+  } = options;
+  const assembler = new PageAssembler(pageAssemblerOptions);
+  let cleanupTimer = null;
+  try {
+    cleanupTimer = setInterval(() => {
+      assembler.cleanup();
+    }, cleanupInterval);
+    const filterParams = {
+      address: protobuf.create(proto.FilterParamValueSchema, { kind: { case: "bytesValue", value: new Uint8Array(address) } })
+    };
+    if (filter?.params) {
+      for (const [key, value] of Object.entries(filter.params)) {
+        filterParams[key] = protobuf.create(proto.FilterParamValueSchema, value);
+      }
+    }
+    const request = {
+      view,
+      filter: protobuf.create(proto.FilterSchema, {
+        expression: filter?.expression ? `(snapshot.address.value == params.address) && (${filter.expression})` : "snapshot.address.value == params.address",
+        params: filterParams
+      })
+    };
+    const stream = client.streamAccountUpdates(request);
+    for await (const response of stream) {
+      const event = processResponse(response, address, assembler);
+      if (event) {
+        yield event;
+      }
+    }
+  } finally {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+    }
+    assembler.clear();
+  }
+}
+function processResponse(response, address, assembler) {
+  switch (response.message.case) {
+    case "snapshot": {
+      const state = snapshotToState(response.message.value);
+      if (state) {
+        return { type: "account", account: state };
+      }
+      return null;
+    }
+    case "update": {
+      const assembled = assembler.processUpdate(address, response.message.value);
+      if (assembled) {
+        return { type: "account", account: assembledToState(assembled) };
+      }
+      return null;
+    }
+    case "finished": {
+      return {
+        type: "blockFinished",
+        block: { slot: BigInt(response.message.value.slot.toString()) }
+      };
+    }
+    default:
+      return null;
+  }
+}
+function processResponseMulti(response, assembler) {
+  switch (response.message.case) {
+    case "snapshot": {
+      const state = snapshotToState(response.message.value);
+      if (state) {
+        return { type: "account", account: state };
+      }
+      return null;
+    }
+    case "update": {
+      const update = response.message.value;
+      const address = update.address?.value;
+      if (!address) {
+        return null;
+      }
+      const assembled = assembler.processUpdate(address, update);
+      if (assembled) {
+        return { type: "account", account: assembledToState(assembled) };
+      }
+      return null;
+    }
+    case "finished": {
+      return {
+        type: "blockFinished",
+        block: { slot: BigInt(response.message.value.slot.toString()) }
+      };
+    }
+    default:
+      return null;
+  }
+}
+function buildOwnerFilter(owner, dataSizes, additionalFilter) {
+  let expression = "(has(snapshot.meta.owner) && snapshot.meta.owner.value == params.owner) || (has(account_update.meta.owner) && account_update.meta.owner.value == params.owner)";
+  if (dataSizes && dataSizes.length > 0) {
+    const sizeConditions = dataSizes.map((size) => `snapshot.meta.data_size == uint(${size}) || account_update.meta.data_size == uint(${size})`).join(" || ");
+    expression = `(${expression}) && (${sizeConditions})`;
+  }
+  if (additionalFilter?.expression) {
+    expression = `(${expression}) && (${additionalFilter.expression})`;
+  }
+  const params = {
+    owner: protobuf.create(proto.FilterParamValueSchema, { kind: { case: "bytesValue", value: new Uint8Array(owner) } })
+  };
+  if (additionalFilter?.params) {
+    for (const [key, value] of Object.entries(additionalFilter.params)) {
+      params[key] = protobuf.create(proto.FilterParamValueSchema, value);
+    }
+  }
+  return protobuf.create(proto.FilterSchema, { expression, params });
+}
+async function* createAccountsByOwnerReplay(options) {
+  const {
+    client,
+    owner,
+    view = proto.AccountView.FULL,
+    dataSizes,
+    filter,
+    pageAssemblerOptions,
+    cleanupInterval = 1e4
+  } = options;
+  const assembler = new PageAssembler(pageAssemblerOptions);
+  let cleanupTimer = null;
+  try {
+    cleanupTimer = setInterval(() => {
+      assembler.cleanup();
+    }, cleanupInterval);
+    const ownerFilter = buildOwnerFilter(owner, dataSizes, filter);
+    const request = {
+      view,
+      filter: ownerFilter
+    };
+    const stream = client.streamAccountUpdates(request);
+    for await (const response of stream) {
+      const event = processResponseMulti(response, assembler);
+      if (event) {
+        yield event;
+      }
+    }
+  } finally {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+    }
+    assembler.clear();
+  }
+}
+var AccountSeqTracker = class {
+  seqs = /* @__PURE__ */ new Map();
+  /**
+   * Get the current sequence number for an address
+   */
+  getSeq(addressHex) {
+    return this.seqs.get(addressHex);
+  }
+  /**
+   * Check if an update should be applied (seq > current)
+   */
+  shouldApply(addressHex, seq) {
+    const current = this.seqs.get(addressHex);
+    return current === void 0 || seq > current;
+  }
+  /**
+   * Update the sequence number for an address
+   * Only updates if new seq is greater than current
+   */
+  update(addressHex, seq) {
+    const current = this.seqs.get(addressHex);
+    if (current === void 0 || seq > current) {
+      this.seqs.set(addressHex, seq);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove tracking for an address
+   */
+  remove(addressHex) {
+    this.seqs.delete(addressHex);
+  }
+  /**
+   * Clear all tracking
+   */
+  clear() {
+    this.seqs.clear();
+  }
+  /**
+   * Get count of tracked addresses
+   */
+  size() {
+    return this.seqs.size;
+  }
+};
+var MultiAccountReplay = class {
+  client;
+  view;
+  seqTracker;
+  activeStreams = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.client = options.client;
+    this.view = options.view ?? proto.AccountView.FULL;
+    this.seqTracker = new AccountSeqTracker();
+  }
+  /**
+   * Add an account to stream updates for
+   */
+  async *addAccount(address) {
+    const addressHex = bytesToHex2(address);
+    if (this.activeStreams.has(addressHex)) {
+      return;
+    }
+    const controller = new AbortController();
+    this.activeStreams.set(addressHex, controller);
+    try {
+      for await (const event of createAccountReplay({
+        client: this.client,
+        address,
+        view: this.view
+      })) {
+        if (event.type === "account") {
+          if (this.seqTracker.shouldApply(event.account.addressHex, event.account.seq)) {
+            this.seqTracker.update(event.account.addressHex, event.account.seq);
+            yield event;
+          }
+        } else {
+          yield event;
+        }
+      }
+    } finally {
+      this.activeStreams.delete(addressHex);
+    }
+  }
+  /**
+   * Remove an account from streaming
+   */
+  removeAccount(address) {
+    const addressHex = bytesToHex2(address);
+    const controller = this.activeStreams.get(addressHex);
+    if (controller) {
+      controller.abort();
+      this.activeStreams.delete(addressHex);
+    }
+    this.seqTracker.remove(addressHex);
+  }
+  /**
+   * Get the current sequence number for an account
+   */
+  getSeq(addressHex) {
+    return this.seqTracker.getSeq(addressHex);
+  }
+  /**
+   * Stop all streams
+   */
+  stop() {
+    for (const controller of this.activeStreams.values()) {
+      controller.abort();
+    }
+    this.activeStreams.clear();
+    this.seqTracker.clear();
+  }
+};
+
+// src/sinks/console.ts
+var ConsoleSink = class {
+  constructor(prefix = "ReplaySink") {
+    this.prefix = prefix;
+  }
+  open(meta) {
+    const suffix = meta?.stream ? ` (${meta.stream})` : "";
+    console.info(`${this.prefix}${suffix} opened`, meta?.label ?? "");
+  }
+  write(item, ctx) {
+    const slotLabel = ctx.slot.toString();
+    console.info(
+      `${this.prefix} ${ctx.phase.toUpperCase()} slot=${slotLabel}`,
+      item
+    );
+  }
+  close(err) {
+    if (err) console.warn(`${this.prefix} closing with error`, err);
+    else console.info(`${this.prefix} closed`);
+  }
+};
+
+Object.defineProperty(exports, "AccountView", {
+  enumerable: true,
+  get: function () { return proto.AccountView; }
+});
+Object.defineProperty(exports, "FilterParamValueSchema", {
+  enumerable: true,
+  get: function () { return proto.FilterParamValueSchema; }
+});
+Object.defineProperty(exports, "FilterSchema", {
+  enumerable: true,
+  get: function () { return proto.FilterSchema; }
+});
+exports.AccountSeqTracker = AccountSeqTracker;
+exports.ChainClient = ChainClient;
+exports.ConsoleSink = ConsoleSink;
+exports.MultiAccountReplay = MultiAccountReplay;
+exports.NOOP_LOGGER = NOOP_LOGGER;
+exports.PAGE_SIZE = PAGE_SIZE;
+exports.PageAssembler = PageAssembler;
+exports.ReplayStream = ReplayStream;
+exports.createAccountReplay = createAccountReplay;
+exports.createAccountsByOwnerReplay = createAccountsByOwnerReplay;
+exports.createBlockReplay = createBlockReplay;
+exports.createConsoleLogger = createConsoleLogger;
+exports.createEventReplay = createEventReplay;
+exports.createTransactionReplay = createTransactionReplay;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map