@apibara/indexer 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/shared/indexer.fedcd831.d.cts

@@ -0,0 +1,100 @@
+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;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    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;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = 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 Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.fedcd831.d.mts

@@ -0,0 +1,100 @@
+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;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    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;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = 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 Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.fedcd831.d.ts

@@ -0,0 +1,100 @@
+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;
+}
+type IndexerStartingCursor = {
+    startingCursor?: never;
+    startingBlock: bigint;
+} | {
+    startingCursor: Cursor;
+    startingBlock?: never;
+} | {
+    startingCursor?: never;
+    startingBlock?: never;
+};
+type IndexerConfig<TFilter, TBlock> = {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    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;
+} & IndexerStartingCursor;
+type IndexerWithStreamConfig<TFilter, TBlock> = 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 Indexer as a, type IndexerPlugin as b, type IndexerConfig as c, defineIndexerPlugin as d, type IndexerHooks as e, type IndexerStartingCursor as f, defineIndexer as g, createIndexer as h, type RunOptions as i, run as j, runWithReconnect as r, useIndexerContext as u };

package/dist/shared/indexer.ff25c953.mjs

@@ -0,0 +1,26 @@
+import { consola } from 'consola';
+import { u as useIndexerContext } from './indexer.a55ad619.mjs';
+import { d as defineIndexerPlugin } from './indexer.9b21ddd2.mjs';
+
+function logger({
+  logger: logger2
+} = {}) {
+  return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", () => {
+      const ctx = useIndexerContext();
+      if (logger2) {
+        ctx.logger = consola.create({ reporters: [logger2] });
+      } else {
+        ctx.logger = consola.create({});
+      }
+    });
+  });
+}
+function useLogger() {
+  const ctx = useIndexerContext();
+  if (!ctx?.logger)
+    throw new Error("Logger plugin is not available in context");
+  return ctx.logger;
+}
+
+export { logger as l, useLogger as u };

package/dist/testing/index.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+const protocol = require('@apibara/protocol');
+const ci = require('ci-info');
+const index = require('../index.cjs');
+const internal_plugins = require('../internal/plugins.cjs');
+const logger = require('../shared/indexer.2416906c.cjs');
+const vcr_index = require('../vcr/index.cjs');
+require('consola');
+require('hookable');
+require('node:assert');
+require('../shared/indexer.077335f3.cjs');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+require('../shared/indexer.601ceab0.cjs');
+require('node:fs/promises');
+require('node:path');
+require('node:fs');
+require('@apibara/protocol/testing');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ci__default = /*#__PURE__*/_interopDefaultCompat(ci);
+
+function createVcr() {
+  return {
+    async run(cassetteName, indexerConfig, range) {
+      const vcrConfig = {
+        cassetteDir: "cassettes"
+      };
+      const cassetteOptions = {
+        name: cassetteName,
+        startingCursor: {
+          orderKey: range.fromBlock
+        },
+        endingCursor: {
+          orderKey: range.toBlock
+        }
+      };
+      indexerConfig.plugins = [
+        internal_plugins.internalContext({
+          indexerName: cassetteName,
+          availableIndexers: [cassetteName]
+        }),
+        logger.logger(),
+        ...indexerConfig.plugins ?? []
+      ];
+      const indexer = index.createIndexer(indexerConfig);
+      if (!vcr_index.isCassetteAvailable(vcrConfig, cassetteName)) {
+        if (ci__default.isCI) {
+          throw new Error("Cannot record cassette in CI");
+        }
+        const client = protocol.createClient(
+          indexer.streamConfig,
+          indexer.options.streamUrl
+        );
+        await vcr_index.record(vcrConfig, client, indexer, cassetteOptions);
+      } else {
+        await vcr_index.replay(vcrConfig, indexer, cassetteName);
+      }
+    }
+  };
+}
+
+exports.createVcr = createVcr;

package/dist/testing/index.d.cts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.cjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.d.mts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.mjs';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.d.ts

@@ -0,0 +1,12 @@
+import { I as IndexerWithStreamConfig } from '../shared/indexer.fedcd831.js';
+import '@apibara/protocol';
+import 'hookable';
+
+declare function createVcr(): {
+    run<TFilter, TBlock>(cassetteName: string, indexerConfig: IndexerWithStreamConfig<TFilter, TBlock>, range: {
+        fromBlock: bigint;
+        toBlock: bigint;
+    }): Promise<void>;
+};
+
+export { createVcr };

package/dist/testing/index.mjs

@@ -0,0 +1,60 @@
+import { createClient } from '@apibara/protocol';
+import ci from 'ci-info';
+import { createIndexer } from '../index.mjs';
+import { internalContext } from '../internal/plugins.mjs';
+import { l as logger } from '../shared/indexer.ff25c953.mjs';
+import { isCassetteAvailable, record, replay } from '../vcr/index.mjs';
+import 'consola';
+import 'hookable';
+import 'node:assert';
+import '../shared/indexer.a55ad619.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+import '../shared/indexer.9b21ddd2.mjs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:fs';
+import '@apibara/protocol/testing';
+
+function createVcr() {
+  return {
+    async run(cassetteName, indexerConfig, range) {
+      const vcrConfig = {
+        cassetteDir: "cassettes"
+      };
+      const cassetteOptions = {
+        name: cassetteName,
+        startingCursor: {
+          orderKey: range.fromBlock
+        },
+        endingCursor: {
+          orderKey: range.toBlock
+        }
+      };
+      indexerConfig.plugins = [
+        internalContext({
+          indexerName: cassetteName,
+          availableIndexers: [cassetteName]
+        }),
+        logger(),
+        ...indexerConfig.plugins ?? []
+      ];
+      const indexer = createIndexer(indexerConfig);
+      if (!isCassetteAvailable(vcrConfig, cassetteName)) {
+        if (ci.isCI) {
+          throw new Error("Cannot record cassette in CI");
+        }
+        const client = createClient(
+          indexer.streamConfig,
+          indexer.options.streamUrl
+        );
+        await record(vcrConfig, client, indexer, cassetteOptions);
+      } else {
+        await replay(vcrConfig, indexer, cassetteName);
+      }
+    }
+  };
+}
+
+export { createVcr };

package/dist/vcr/index.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs$1 = require('node:fs/promises');
+const path = require('node:path');
+const index = require('../index.cjs');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const testing = require('@apibara/protocol/testing');
+require('@apibara/protocol');
+require('consola');
+require('hookable');
+require('../shared/indexer.077335f3.cjs');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const assert__default = /*#__PURE__*/_interopDefaultCompat(assert);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function deserialize(str) {
+  return JSON.parse(
+    str,
+    (_, value) => typeof value === "string" && value.match(/^\d+n$/) ? BigInt(value.slice(0, -1)) : value
+  );
+}
+function serialize(obj) {
+  return JSON.stringify(
+    obj,
+    (_, value) => typeof value === "bigint" ? `${value.toString()}n` : value,
+    "	"
+  );
+}
+function isCassetteAvailable(vcrConfig, cassetteName) {
+  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  return fs__default.existsSync(filePath);
+}
+
+async function record(vcrConfig, client, indexer, cassetteOptions) {
+  const messages = [];
+  indexer.hooks.addHooks({
+    "connect:before"({ options, request }) {
+      request.startingCursor = cassetteOptions.startingCursor;
+      options.endingCursor = cassetteOptions.endingCursor;
+    },
+    message({ message }) {
+      messages.push(message);
+    },
+    async "run:after"() {
+      const output = {
+        filter: indexer.options.filter,
+        messages
+      };
+      await fs__default$1.mkdir(vcrConfig.cassetteDir, { recursive: true });
+      const filePath = path__default.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs__default$1.writeFile(filePath, serialize(output), { flag: "w" });
+    }
+  });
+  await index.run(client, indexer);
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  await index.run(client, indexer);
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path__default.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs__default.readFileSync(filePath, "utf8");
+  const cassetteData = deserialize(data);
+  const { filter, messages } = cassetteData;
+  return new testing.MockClient((request, options) => {
+    assert__default.deepStrictEqual(
+      request.filter,
+      [filter],
+      "Indexer and cassette filter mismatch. Hint: delete the cassette and run again."
+    );
+    return messages;
+  });
+}
+
+exports.deserialize = deserialize;
+exports.isCassetteAvailable = isCassetteAvailable;
+exports.loadCassette = loadCassette;
+exports.record = record;
+exports.replay = replay;
+exports.serialize = serialize;

package/dist/vcr/index.d.cts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.cjs';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.mts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.mjs';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };

package/dist/vcr/index.d.ts

@@ -0,0 +1,27 @@
+import { Cursor, StreamDataResponse, Client } from '@apibara/protocol';
+import { a as Indexer } from '../shared/indexer.fedcd831.js';
+import 'hookable';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function deserialize(str: string): any;
+declare function serialize(obj: Record<string, unknown>): string;
+declare function isCassetteAvailable(vcrConfig: VcrConfig, cassetteName: string): boolean;
+
+type CassetteDataType<TFilter, TBlock> = {
+    filter: TFilter;
+    messages: StreamDataResponse<TBlock>[];
+};
+declare function record<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock>, cassetteName: string): Promise<void>;
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteDataType, type CassetteOptions, type VcrConfig, deserialize, isCassetteAvailable, loadCassette, record, replay, serialize };