@apibara/indexer 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/internal/testing.d.mts

@@ -0,0 +1,40 @@
+import { a as IndexerPlugin, b as IndexerConfig, c as Indexer } from '../shared/indexer.8939ecc8.mjs';
+import { MockStreamResponse, MockFilter, MockBlock } from '@apibara/protocol/testing';
+import '@apibara/protocol';
+import 'hookable';
+
+type MockMessagesOptions = {
+    invalidate?: {
+        invalidateFromIndex: number;
+        invalidateTriggerIndex: number;
+    };
+    finalize?: {
+        finalizeToIndex: number;
+        finalizeTriggerIndex: number;
+    };
+};
+declare function generateMockMessages(count?: number, options?: MockMessagesOptions): MockStreamResponse[];
+declare function getMockIndexer({ plugins, override, }?: {
+    plugins?: ReadonlyArray<IndexerPlugin<MockFilter, MockBlock>>;
+    override?: Partial<IndexerConfig<MockFilter, MockBlock>>;
+}): Indexer<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+type MockRet = {
+    data: string;
+};
+/**
+ * A mock sink used for testing. The indexer function can write to the output array.
+ * The indexer context is optionally written to the metadata object.
+ */
+declare function mockSink<TFilter, TBlock>({ output, metadata, }: {
+    output: unknown[];
+    metadata?: Record<string, unknown>;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useMockSink(): {
+    output: unknown[];
+};
+
+export { type MockMessagesOptions, type MockRet, generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/internal/testing.d.ts

@@ -0,0 +1,40 @@
+import { a as IndexerPlugin, b as IndexerConfig, c as Indexer } from '../shared/indexer.8939ecc8.js';
+import { MockStreamResponse, MockFilter, MockBlock } from '@apibara/protocol/testing';
+import '@apibara/protocol';
+import 'hookable';
+
+type MockMessagesOptions = {
+    invalidate?: {
+        invalidateFromIndex: number;
+        invalidateTriggerIndex: number;
+    };
+    finalize?: {
+        finalizeToIndex: number;
+        finalizeTriggerIndex: number;
+    };
+};
+declare function generateMockMessages(count?: number, options?: MockMessagesOptions): MockStreamResponse[];
+declare function getMockIndexer({ plugins, override, }?: {
+    plugins?: ReadonlyArray<IndexerPlugin<MockFilter, MockBlock>>;
+    override?: Partial<IndexerConfig<MockFilter, MockBlock>>;
+}): Indexer<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+type MockRet = {
+    data: string;
+};
+/**
+ * A mock sink used for testing. The indexer function can write to the output array.
+ * The indexer context is optionally written to the metadata object.
+ */
+declare function mockSink<TFilter, TBlock>({ output, metadata, }: {
+    output: unknown[];
+    metadata?: Record<string, unknown>;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useMockSink(): {
+    output: unknown[];
+};
+
+export { type MockMessagesOptions, type MockRet, generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/internal/testing.mjs

@@ -0,0 +1,104 @@
+import { isCursor } from '@apibara/protocol';
+import { MockStream } from '@apibara/protocol/testing';
+import { u as useIndexerContext } from '../shared/indexer.a55ad619.mjs';
+import { createIndexer, defineIndexer } from '../index.mjs';
+import { d as defineIndexerPlugin } from '../shared/indexer.9b21ddd2.mjs';
+import 'consola';
+import 'node:async_hooks';
+import 'unctx';
+import 'hookable';
+import 'node:assert';
+import '@opentelemetry/api';
+
+function generateMockMessages(count = 10, options) {
+  const invalidateAt = options?.invalidate;
+  const finalizeAt = options?.finalize;
+  const messages = [];
+  for (let i = 0; i < count; i++) {
+    if (invalidateAt && i === invalidateAt.invalidateTriggerIndex) {
+      messages.push({
+        _tag: "invalidate",
+        invalidate: {
+          cursor: {
+            orderKey: BigInt(5e6 + invalidateAt.invalidateFromIndex)
+          }
+        }
+      });
+    } else if (finalizeAt && i === finalizeAt.finalizeTriggerIndex) {
+      messages.push({
+        _tag: "finalize",
+        finalize: {
+          cursor: {
+            orderKey: BigInt(5e6 + finalizeAt.finalizeToIndex)
+          }
+        }
+      });
+    } else {
+      messages.push({
+        _tag: "data",
+        data: {
+          cursor: { orderKey: BigInt(5e6 + i - 1) },
+          finality: "accepted",
+          data: [{ data: `${5e6 + i}` }],
+          endCursor: { orderKey: BigInt(5e6 + i) }
+        }
+      });
+    }
+  }
+  return messages;
+}
+function getMockIndexer({
+  plugins,
+  override
+} = {}) {
+  return createIndexer(
+    defineIndexer(MockStream)({
+      streamUrl: "https://sepolia.ethereum.a5a.ch",
+      finality: "accepted",
+      filter: {},
+      async transform({ block: { data }, context }) {
+      },
+      plugins,
+      ...override
+    })
+  );
+}
+function mockSink({
+  output,
+  metadata
+}) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (metadata?.lastCursor && isCursor(metadata.lastCursor)) {
+        request.startingCursor = metadata.lastCursor;
+      }
+      if (metadata?.lastFilter) {
+        request.filter[1] = metadata.lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        if (metadata) {
+          metadata.lastCursor = endCursor;
+          metadata.lastFilter = request.filter[1];
+        }
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        context.output = output;
+        await next();
+        context.output = null;
+        if (metadata) {
+          metadata.lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
+}
+function useMockSink() {
+  const context = useIndexerContext();
+  return { output: context.output };
+}
+
+export { generateMockMessages, getMockIndexer, mockSink, useMockSink };

package/dist/plugins/index.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const config = require('../shared/indexer.601ceab0.cjs');
+const logger = require('../shared/indexer.2416906c.cjs');
+const protocol = require('@apibara/protocol');
+require('consola');
+require('../shared/indexer.077335f3.cjs');
+require('node:async_hooks');
+require('unctx');
+
+function inMemoryPersistence() {
+  return config.defineIndexerPlugin((indexer) => {
+    let lastCursor;
+    let lastFilter;
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (lastCursor) {
+        request.startingCursor = lastCursor;
+      }
+      if (lastFilter) {
+        request.filter[1] = lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        lastCursor = endCursor;
+        lastFilter = request.filter[1];
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        await next();
+        if (context.endCursor && protocol.isCursor(context.endCursor)) {
+          lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
+}
+
+exports.defineIndexerPlugin = config.defineIndexerPlugin;
+exports.logger = logger.logger;
+exports.useLogger = logger.useLogger;
+exports.inMemoryPersistence = inMemoryPersistence;

package/dist/plugins/index.d.cts

@@ -0,0 +1,18 @@
+import { a as IndexerPlugin } from '../shared/indexer.8939ecc8.cjs';
+export { d as defineIndexerPlugin } from '../shared/indexer.8939ecc8.cjs';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.d.mts

@@ -0,0 +1,18 @@
+import { a as IndexerPlugin } from '../shared/indexer.8939ecc8.mjs';
+export { d as defineIndexerPlugin } from '../shared/indexer.8939ecc8.mjs';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.d.ts

@@ -0,0 +1,18 @@
+import { a as IndexerPlugin } from '../shared/indexer.8939ecc8.js';
+export { d as defineIndexerPlugin } from '../shared/indexer.8939ecc8.js';
+import { ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaInstance, ConsolaReporter } from 'consola';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function logger<TFilter, TBlock, TTxnParams>({ logger, }?: {
+    logger?: ConsolaReporter;
+}): IndexerPlugin<TFilter, TBlock>;
+declare function useLogger(): ConsolaInstance;
+
+/**
+ * A plugin that persists the last cursor and filter to memory.
+ */
+declare function inMemoryPersistence<TFilter, TBlock>(): IndexerPlugin<TFilter, TBlock>;
+
+export { IndexerPlugin, inMemoryPersistence, logger, useLogger };

package/dist/plugins/index.mjs

@@ -0,0 +1,38 @@
+import { d as defineIndexerPlugin } from '../shared/indexer.9b21ddd2.mjs';
+export { l as logger, u as useLogger } from '../shared/indexer.ff25c953.mjs';
+import { isCursor } from '@apibara/protocol';
+import 'consola';
+import '../shared/indexer.a55ad619.mjs';
+import 'node:async_hooks';
+import 'unctx';
+
+function inMemoryPersistence() {
+  return defineIndexerPlugin((indexer) => {
+    let lastCursor;
+    let lastFilter;
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      if (lastCursor) {
+        request.startingCursor = lastCursor;
+      }
+      if (lastFilter) {
+        request.filter[1] = lastFilter;
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        lastCursor = endCursor;
+        lastFilter = request.filter[1];
+      }
+    });
+    indexer.hooks.hook("handler:middleware", ({ use }) => {
+      use(async (context, next) => {
+        await next();
+        if (context.endCursor && isCursor(context.endCursor)) {
+          lastCursor = context.endCursor;
+        }
+      });
+    });
+  });
+}
+
+export { defineIndexerPlugin, inMemoryPersistence };

package/dist/shared/indexer.077335f3.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const node_async_hooks = require('node:async_hooks');
+const unctx = require('unctx');
+
+const indexerAsyncContext = unctx.getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage: node_async_hooks.AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+exports.indexerAsyncContext = indexerAsyncContext;
+exports.useIndexerContext = useIndexerContext;

package/dist/shared/indexer.2416906c.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const consola = require('consola');
+const context = require('./indexer.077335f3.cjs');
+const config = require('./indexer.601ceab0.cjs');
+
+function logger({
+  logger: logger2
+} = {}) {
+  return config.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      const ctx = context.useIndexerContext();
+      if (logger2) {
+        ctx.logger = consola.consola.create({ reporters: [logger2] });
+      } else {
+        ctx.logger = consola.consola.create({});
+      }
+    });
+  });
+}
+function useLogger() {
+  const ctx = context.useIndexerContext();
+  if (!ctx?.logger)
+    throw new Error("Logger plugin is not available in context");
+  return ctx.logger;
+}
+
+exports.logger = logger;
+exports.useLogger = useLogger;

package/dist/shared/indexer.601ceab0.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+exports.defineIndexerPlugin = defineIndexerPlugin;

package/dist/shared/indexer.8939ecc8.d.cts

@@ -0,0 +1,91 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock> extends IndexerConfig<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerPlugin as a, type IndexerConfig as b, type Indexer as c, defineIndexerPlugin as d, type IndexerHooks as e, defineIndexer as f, createIndexer as g, type RunOptions as h, run as i, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.8939ecc8.d.mts

@@ -0,0 +1,91 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock> extends IndexerConfig<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerPlugin as a, type IndexerConfig as b, type Indexer as c, defineIndexerPlugin as d, type IndexerHooks as e, defineIndexer as f, createIndexer as g, type RunOptions as h, run as i, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.8939ecc8.d.ts

@@ -0,0 +1,91 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, StreamDataResponse, Invalidate, Finalize, Heartbeat, SystemMessage, DataFinality, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+
+interface IndexerContext extends Record<string, any> {
+}
+declare function useIndexerContext(): IndexerContext;
+
+type NextFunction = () => Promise<void>;
+type MiddlewareFunction<C> = (context: C, next: NextFunction) => Promise<void>;
+
+type IndexerPlugin<TFilter, TBlock> = (indexer: Indexer<TFilter, TBlock>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock>(def: IndexerPlugin<TFilter, TBlock>): IndexerPlugin<TFilter, TBlock>;
+
+type UseMiddlewareFunction = (fn: MiddlewareFunction<IndexerContext>) => void;
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": ({ request, }: {
+        request: StreamDataRequest<TFilter>;
+    }) => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:middleware": ({ use }: {
+        use: UseMiddlewareFunction;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+    "message:invalidate": ({ message }: {
+        message: Invalidate;
+    }) => void;
+    "message:finalize": ({ message }: {
+        message: Finalize;
+    }) => void;
+    "message:heartbeat": ({ message }: {
+        message: Heartbeat;
+    }) => void;
+    "message:systemMessage": ({ message }: {
+        message: SystemMessage;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock> extends IndexerConfig<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): (config: IndexerConfig<TFilter, TBlock>) => IndexerWithStreamConfig<TFilter, TBlock>;
+interface Indexer<TFilter, TBlock> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock>): Indexer<TFilter, TBlock>;
+interface ReconnectOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    maxWait?: number;
+}
+declare function runWithReconnect<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, options?: ReconnectOptions): Promise<void>;
+interface RunOptions {
+    onConnect?: () => void | Promise<void>;
+}
+declare function run<TFilter, TBlock>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, runOptions?: RunOptions): Promise<void>;
+
+export { type IndexerWithStreamConfig as I, type ReconnectOptions as R, type UseMiddlewareFunction as U, type IndexerPlugin as a, type IndexerConfig as b, type Indexer as c, defineIndexerPlugin as d, type IndexerHooks as e, defineIndexer as f, createIndexer as g, type RunOptions as h, run as i, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.9b21ddd2.mjs

@@ -0,0 +1,5 @@
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+export { defineIndexerPlugin as d };

package/dist/shared/indexer.a55ad619.mjs

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getContext } from 'unctx';
+
+const indexerAsyncContext = getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+export { indexerAsyncContext as i, useIndexerContext as u };