@apibara/indexer 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/plugins/persistence.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+const helper = require('../shared/indexer.318d3617.cjs');
+require('node:fs/promises');
+require('node:path');
+require('klona/full');
+require('consola');
+require('hookable');
+require('node:assert');
+require('node:fs');
+require('@apibara/protocol/testing');
+const plugins_index = require('./index.cjs');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function sqlitePersistence({
+  database
+}) {
+  return plugins_index.defineIndexerPlugin((indexer) => {
+    let store;
+    indexer.hooks.hook("run:before", () => {
+      SqlitePersistence.initialize(database);
+      store = new SqlitePersistence(database);
+    });
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      const { cursor, filter } = store.get();
+      if (cursor) {
+        request.startingCursor = cursor;
+      }
+      if (filter) {
+        request.filter[1] = filter;
+      }
+    });
+    indexer.hooks.hook("transaction:commit", ({ endCursor }) => {
+      if (endCursor) {
+        store.put({ cursor: endCursor });
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        store.put({ cursor: endCursor, filter: request.filter[1] });
+      }
+    });
+  });
+}
+class SqlitePersistence {
+  constructor(_db) {
+    this._db = _db;
+    /** Sqlite Queries Prepare Statements */
+    __publicField(this, "_getCheckpointQuery");
+    __publicField(this, "_putCheckpointQuery");
+    __publicField(this, "_delCheckpointQuery");
+    __publicField(this, "_getFilterQuery");
+    __publicField(this, "_updateFilterToBlockQuery");
+    __publicField(this, "_insertFilterQuery");
+    __publicField(this, "_delFilterQuery");
+    this._getCheckpointQuery = this._db.prepare(statements.getCheckpoint);
+    this._putCheckpointQuery = this._db.prepare(statements.putCheckpoint);
+    this._delCheckpointQuery = this._db.prepare(statements.delCheckpoint);
+    this._getFilterQuery = this._db.prepare(statements.getFilter);
+    this._updateFilterToBlockQuery = this._db.prepare(
+      statements.updateFilterToBlock
+    );
+    this._insertFilterQuery = this._db.prepare(statements.insertFilter);
+    this._delFilterQuery = this._db.prepare(statements.delFilter);
+  }
+  static initialize(db) {
+    db.prepare(statements.createCheckpointsTable).run();
+    db.prepare(statements.createFiltersTable).run();
+  }
+  get() {
+    const cursor = this._getCheckpoint();
+    const filter = this._getFilter();
+    return { cursor, filter };
+  }
+  put({ cursor, filter }) {
+    if (cursor) {
+      this._putCheckpoint(cursor);
+      if (filter) {
+        this._putFilter(filter, cursor);
+      }
+    }
+  }
+  del() {
+    this._delCheckpoint();
+    this._delFilter();
+  }
+  // --- CHECKPOINTS TABLE METHODS ---
+  _getCheckpoint() {
+    const row = this._getCheckpointQuery.get("default");
+    if (!row)
+      return void 0;
+    return { orderKey: BigInt(row.order_key), uniqueKey: row.unique_key };
+  }
+  _putCheckpoint(cursor) {
+    this._putCheckpointQuery.run(
+      "default",
+      Number(cursor.orderKey),
+      cursor.uniqueKey
+    );
+  }
+  _delCheckpoint() {
+    this._delCheckpointQuery.run("default");
+  }
+  // --- FILTERS TABLE METHODS ---
+  _getFilter() {
+    const row = this._getFilterQuery.get("default");
+    if (!row)
+      return void 0;
+    return helper.deserialize(row.filter);
+  }
+  _putFilter(filter, endCursor) {
+    this._updateFilterToBlockQuery.run(Number(endCursor.orderKey), "default");
+    this._insertFilterQuery.run(
+      "default",
+      helper.serialize(filter),
+      Number(endCursor.orderKey)
+    );
+  }
+  _delFilter() {
+    this._delFilterQuery.run("default");
+  }
+}
+const statements = {
+  beginTxn: "BEGIN TRANSACTION",
+  commitTxn: "COMMIT TRANSACTION",
+  rollbackTxn: "ROLLBACK TRANSACTION",
+  createCheckpointsTable: `
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT NOT NULL PRIMARY KEY,
+      order_key INTEGER NOT NULL,
+      unique_key TEXT
+    );`,
+  createFiltersTable: `
+    CREATE TABLE IF NOT EXISTS filters (
+      id TEXT NOT NULL,
+      filter BLOB NOT NULL,
+      from_block INTEGER NOT NULL,
+      to_block INTEGER,
+      PRIMARY KEY (id, from_block)
+    );`,
+  getCheckpoint: `
+    SELECT *
+    FROM checkpoints
+    WHERE id = ?`,
+  putCheckpoint: `
+    INSERT INTO checkpoints (id, order_key, unique_key)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      order_key = excluded.order_key,
+      unique_key = excluded.unique_key`,
+  delCheckpoint: `
+    DELETE FROM checkpoints
+    WHERE id = ?`,
+  getFilter: `
+    SELECT *
+    FROM filters
+    WHERE id = ? AND to_block IS NULL`,
+  updateFilterToBlock: `
+    UPDATE filters
+    SET to_block = ?
+    WHERE id = ? AND to_block IS NULL`,
+  insertFilter: `
+    INSERT INTO filters (id, filter, from_block)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id, from_block) DO UPDATE SET
+      filter = excluded.filter,
+      from_block = excluded.from_block`,
+  delFilter: `
+    DELETE FROM filters
+    WHERE id = ?`
+};
+
+exports.SqlitePersistence = SqlitePersistence;
+exports.sqlitePersistence = sqlitePersistence;

package/dist/plugins/persistence.d.cts

@@ -0,0 +1,50 @@
+import { I as IndexerPlugin } from '../shared/indexer.c7ed6b83.cjs';
+import { Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+import '../shared/indexer.b9c8f0d8.cjs';
+
+declare function sqlitePersistence<TFilter, TBlock, TTxnParams>({ database, }: {
+    database: Database;
+}): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+declare class SqlitePersistence<TFilter> {
+    private _db;
+    /** Sqlite Queries Prepare Statements */
+    private _getCheckpointQuery;
+    private _putCheckpointQuery;
+    private _delCheckpointQuery;
+    private _getFilterQuery;
+    private _updateFilterToBlockQuery;
+    private _insertFilterQuery;
+    private _delFilterQuery;
+    constructor(_db: Database);
+    static initialize(db: Database): void;
+    get(): {
+        cursor?: Cursor;
+        filter?: TFilter;
+    };
+    put({ cursor, filter }: {
+        cursor?: Cursor;
+        filter?: TFilter;
+    }): void;
+    del(): void;
+    private _getCheckpoint;
+    private _putCheckpoint;
+    private _delCheckpoint;
+    private _getFilter;
+    private _putFilter;
+    private _delFilter;
+}
+type CheckpointRow = {
+    id: string;
+    order_key: number;
+    unique_key?: `0x${string}`;
+};
+type FilterRow = {
+    id: string;
+    filter: string;
+    from_block: number;
+    to_block?: number;
+};
+
+export { type CheckpointRow, type FilterRow, SqlitePersistence, sqlitePersistence };

package/dist/plugins/persistence.d.mts

@@ -0,0 +1,50 @@
+import { I as IndexerPlugin } from '../shared/indexer.e8bd138d.mjs';
+import { Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+import '../shared/indexer.b9c8f0d8.mjs';
+
+declare function sqlitePersistence<TFilter, TBlock, TTxnParams>({ database, }: {
+    database: Database;
+}): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+declare class SqlitePersistence<TFilter> {
+    private _db;
+    /** Sqlite Queries Prepare Statements */
+    private _getCheckpointQuery;
+    private _putCheckpointQuery;
+    private _delCheckpointQuery;
+    private _getFilterQuery;
+    private _updateFilterToBlockQuery;
+    private _insertFilterQuery;
+    private _delFilterQuery;
+    constructor(_db: Database);
+    static initialize(db: Database): void;
+    get(): {
+        cursor?: Cursor;
+        filter?: TFilter;
+    };
+    put({ cursor, filter }: {
+        cursor?: Cursor;
+        filter?: TFilter;
+    }): void;
+    del(): void;
+    private _getCheckpoint;
+    private _putCheckpoint;
+    private _delCheckpoint;
+    private _getFilter;
+    private _putFilter;
+    private _delFilter;
+}
+type CheckpointRow = {
+    id: string;
+    order_key: number;
+    unique_key?: `0x${string}`;
+};
+type FilterRow = {
+    id: string;
+    filter: string;
+    from_block: number;
+    to_block?: number;
+};
+
+export { type CheckpointRow, type FilterRow, SqlitePersistence, sqlitePersistence };

package/dist/plugins/persistence.d.ts

@@ -0,0 +1,50 @@
+import { I as IndexerPlugin } from '../shared/indexer.f761abcd.js';
+import { Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+import '../shared/indexer.b9c8f0d8.js';
+
+declare function sqlitePersistence<TFilter, TBlock, TTxnParams>({ database, }: {
+    database: Database;
+}): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+declare class SqlitePersistence<TFilter> {
+    private _db;
+    /** Sqlite Queries Prepare Statements */
+    private _getCheckpointQuery;
+    private _putCheckpointQuery;
+    private _delCheckpointQuery;
+    private _getFilterQuery;
+    private _updateFilterToBlockQuery;
+    private _insertFilterQuery;
+    private _delFilterQuery;
+    constructor(_db: Database);
+    static initialize(db: Database): void;
+    get(): {
+        cursor?: Cursor;
+        filter?: TFilter;
+    };
+    put({ cursor, filter }: {
+        cursor?: Cursor;
+        filter?: TFilter;
+    }): void;
+    del(): void;
+    private _getCheckpoint;
+    private _putCheckpoint;
+    private _delCheckpoint;
+    private _getFilter;
+    private _putFilter;
+    private _delFilter;
+}
+type CheckpointRow = {
+    id: string;
+    order_key: number;
+    unique_key?: `0x${string}`;
+};
+type FilterRow = {
+    id: string;
+    filter: string;
+    from_block: number;
+    to_block?: number;
+};
+
+export { type CheckpointRow, type FilterRow, SqlitePersistence, sqlitePersistence };

package/dist/plugins/persistence.mjs

@@ -0,0 +1,179 @@
+import { d as deserialize, s as serialize } from '../shared/indexer.2c23c9cd.mjs';
+import 'node:fs/promises';
+import 'node:path';
+import 'klona/full';
+import 'consola';
+import 'hookable';
+import 'node:assert';
+import 'node:fs';
+import '@apibara/protocol/testing';
+import { defineIndexerPlugin } from './index.mjs';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function sqlitePersistence({
+  database
+}) {
+  return defineIndexerPlugin((indexer) => {
+    let store;
+    indexer.hooks.hook("run:before", () => {
+      SqlitePersistence.initialize(database);
+      store = new SqlitePersistence(database);
+    });
+    indexer.hooks.hook("connect:before", ({ request }) => {
+      const { cursor, filter } = store.get();
+      if (cursor) {
+        request.startingCursor = cursor;
+      }
+      if (filter) {
+        request.filter[1] = filter;
+      }
+    });
+    indexer.hooks.hook("transaction:commit", ({ endCursor }) => {
+      if (endCursor) {
+        store.put({ cursor: endCursor });
+      }
+    });
+    indexer.hooks.hook("connect:factory", ({ request, endCursor }) => {
+      if (request.filter[1]) {
+        store.put({ cursor: endCursor, filter: request.filter[1] });
+      }
+    });
+  });
+}
+class SqlitePersistence {
+  constructor(_db) {
+    this._db = _db;
+    /** Sqlite Queries Prepare Statements */
+    __publicField(this, "_getCheckpointQuery");
+    __publicField(this, "_putCheckpointQuery");
+    __publicField(this, "_delCheckpointQuery");
+    __publicField(this, "_getFilterQuery");
+    __publicField(this, "_updateFilterToBlockQuery");
+    __publicField(this, "_insertFilterQuery");
+    __publicField(this, "_delFilterQuery");
+    this._getCheckpointQuery = this._db.prepare(statements.getCheckpoint);
+    this._putCheckpointQuery = this._db.prepare(statements.putCheckpoint);
+    this._delCheckpointQuery = this._db.prepare(statements.delCheckpoint);
+    this._getFilterQuery = this._db.prepare(statements.getFilter);
+    this._updateFilterToBlockQuery = this._db.prepare(
+      statements.updateFilterToBlock
+    );
+    this._insertFilterQuery = this._db.prepare(statements.insertFilter);
+    this._delFilterQuery = this._db.prepare(statements.delFilter);
+  }
+  static initialize(db) {
+    db.prepare(statements.createCheckpointsTable).run();
+    db.prepare(statements.createFiltersTable).run();
+  }
+  get() {
+    const cursor = this._getCheckpoint();
+    const filter = this._getFilter();
+    return { cursor, filter };
+  }
+  put({ cursor, filter }) {
+    if (cursor) {
+      this._putCheckpoint(cursor);
+      if (filter) {
+        this._putFilter(filter, cursor);
+      }
+    }
+  }
+  del() {
+    this._delCheckpoint();
+    this._delFilter();
+  }
+  // --- CHECKPOINTS TABLE METHODS ---
+  _getCheckpoint() {
+    const row = this._getCheckpointQuery.get("default");
+    if (!row)
+      return void 0;
+    return { orderKey: BigInt(row.order_key), uniqueKey: row.unique_key };
+  }
+  _putCheckpoint(cursor) {
+    this._putCheckpointQuery.run(
+      "default",
+      Number(cursor.orderKey),
+      cursor.uniqueKey
+    );
+  }
+  _delCheckpoint() {
+    this._delCheckpointQuery.run("default");
+  }
+  // --- FILTERS TABLE METHODS ---
+  _getFilter() {
+    const row = this._getFilterQuery.get("default");
+    if (!row)
+      return void 0;
+    return deserialize(row.filter);
+  }
+  _putFilter(filter, endCursor) {
+    this._updateFilterToBlockQuery.run(Number(endCursor.orderKey), "default");
+    this._insertFilterQuery.run(
+      "default",
+      serialize(filter),
+      Number(endCursor.orderKey)
+    );
+  }
+  _delFilter() {
+    this._delFilterQuery.run("default");
+  }
+}
+const statements = {
+  beginTxn: "BEGIN TRANSACTION",
+  commitTxn: "COMMIT TRANSACTION",
+  rollbackTxn: "ROLLBACK TRANSACTION",
+  createCheckpointsTable: `
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT NOT NULL PRIMARY KEY,
+      order_key INTEGER NOT NULL,
+      unique_key TEXT
+    );`,
+  createFiltersTable: `
+    CREATE TABLE IF NOT EXISTS filters (
+      id TEXT NOT NULL,
+      filter BLOB NOT NULL,
+      from_block INTEGER NOT NULL,
+      to_block INTEGER,
+      PRIMARY KEY (id, from_block)
+    );`,
+  getCheckpoint: `
+    SELECT *
+    FROM checkpoints
+    WHERE id = ?`,
+  putCheckpoint: `
+    INSERT INTO checkpoints (id, order_key, unique_key)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      order_key = excluded.order_key,
+      unique_key = excluded.unique_key`,
+  delCheckpoint: `
+    DELETE FROM checkpoints
+    WHERE id = ?`,
+  getFilter: `
+    SELECT *
+    FROM filters
+    WHERE id = ? AND to_block IS NULL`,
+  updateFilterToBlock: `
+    UPDATE filters
+    SET to_block = ?
+    WHERE id = ? AND to_block IS NULL`,
+  insertFilter: `
+    INSERT INTO filters (id, filter, from_block)
+    VALUES (?, ?, ?)
+    ON CONFLICT(id, from_block) DO UPDATE SET
+      filter = excluded.filter,
+      from_block = excluded.from_block`,
+  delFilter: `
+    DELETE FROM filters
+    WHERE id = ?`
+};
+
+export { SqlitePersistence, sqlitePersistence };

package/dist/shared/indexer.2c23c9cd.mjs

@@ -0,0 +1,35 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getContext } from 'unctx';
+import { trace } from '@opentelemetry/api';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const indexerAsyncContext = getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+const tracer = trace.getTracer("@apibara/indexer");
+
+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.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  return fs.existsSync(filePath);
+}
+
+export { indexerAsyncContext as a, deserialize as d, isCassetteAvailable as i, serialize as s, tracer as t, useIndexerContext as u };

package/dist/shared/indexer.318d3617.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const node_async_hooks = require('node:async_hooks');
+const unctx = require('unctx');
+const api = require('@opentelemetry/api');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const indexerAsyncContext = unctx.getContext("indexer", {
+  asyncContext: true,
+  AsyncLocalStorage: node_async_hooks.AsyncLocalStorage
+});
+function useIndexerContext() {
+  return indexerAsyncContext.use();
+}
+
+const tracer = api.trace.getTracer("@apibara/indexer");
+
+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);
+}
+
+exports.deserialize = deserialize;
+exports.indexerAsyncContext = indexerAsyncContext;
+exports.isCassetteAvailable = isCassetteAvailable;
+exports.serialize = serialize;
+exports.tracer = tracer;
+exports.useIndexerContext = useIndexerContext;

package/dist/shared/{indexer.28bd9576.mjs → indexer.36530330.mjs}

@@ -1,25 +1,13 @@
-import fs$1 from 'node:fs/promises';
+import { a as indexerAsyncContext, u as useIndexerContext, t as tracer, s as serialize, d as deserialize } from './indexer.2c23c9cd.mjs';
+import fs from 'node:fs/promises';
 import path from 'node:path';
-import consola from 'consola';
 import { klona } from 'klona/full';
-import assert from 'node:assert';
-import fs from 'node:fs';
-import { MockClient } from '@apibara/protocol/testing';
+import consola from 'consola';
 import { createHooks, createDebugger } from 'hookable';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { getContext } from 'unctx';
-import { trace } from '@opentelemetry/api';
+import assert from 'node:assert';
 import { d as defaultSink, S as Sink } from './indexer.93d6b2eb.mjs';
-
-const indexerAsyncContext = getContext("indexer", {
-  asyncContext: true,
-  AsyncLocalStorage
-});
-function useIndexerContext() {
-  return indexerAsyncContext.use();
-}
-
-const tracer = trace.getTracer("@apibara/indexer");
+import fs$1 from 'node:fs';
+import { MockClient } from '@apibara/protocol/testing';
 
 function defineIndexer(streamConfig) {
   return (config) => ({
@@ -170,24 +158,6 @@ async function run(client, indexer) {
   });
 }
 
-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.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  return fs.existsSync(filePath);
-}
-
 async function record(vcrConfig, client, indexerArg, cassetteOptions) {
   const indexer = klona(indexerArg);
   const messages = [];
@@ -208,7 +178,7 @@ async function record(vcrConfig, client, indexerArg, cassetteOptions) {
         vcrConfig.cassetteDir,
         `${cassetteOptions.name}.json`
       );
-      await fs$1.writeFile(filePath, serialize(output), { flag: "w" });
+      await fs.writeFile(filePath, serialize(output), { flag: "w" });
     }
   });
   await run(client, indexer);
@@ -263,7 +233,7 @@ async function replay(vcrConfig, indexer, cassetteName) {
 }
 function loadCassette(vcrConfig, cassetteName) {
   const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
-  const data = fs.readFileSync(filePath, "utf8");
+  const data = fs$1.readFileSync(filePath, "utf8");
   const cassetteData = deserialize(data);
   const { filter, messages } = cassetteData;
   return new MockClient((request, options) => {
@@ -276,4 +246,4 @@ function loadCassette(vcrConfig, cassetteName) {
   });
 }
 
-export { VcrSink as V, deserialize as a, record as b, createIndexer as c, defineIndexer as d, replay as e, isCassetteAvailable as i, loadCassette as l, run as r, serialize as s, useIndexerContext as u, vcr as v };
+export { VcrSink as V, record as a, replay as b, createIndexer as c, defineIndexer as d, loadCassette as l, run as r, vcr as v };

package/dist/shared/indexer.500fd281.d.cts

@@ -0,0 +1,23 @@
+import { Cursor, Client } from '@apibara/protocol';
+import { f as Indexer } from './indexer.c7ed6b83.cjs';
+import { b as SinkData } from './indexer.b9c8f0d8.cjs';
+
+type VcrConfig = {
+    cassetteDir: string;
+};
+type CassetteOptions = {
+    name: string;
+    startingCursor: Cursor;
+    endingCursor: Cursor;
+};
+
+declare function replay<TFilter, TBlock, TTxnParams>(vcrConfig: VcrConfig, indexer: Indexer<TFilter, TBlock, TTxnParams>, cassetteName: string): Promise<VcrReplayResult>;
+type VcrReplayResult = {
+    outputs: Array<{
+        endCursor?: Cursor;
+        data: SinkData[];
+    }>;
+};
+declare function loadCassette<TFilter, TBlock>(vcrConfig: VcrConfig, cassetteName: string): Client<TFilter, TBlock>;
+
+export { type CassetteOptions as C, type VcrConfig as V, type VcrReplayResult as a, loadCassette as l, replay as r };