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

package/dist/index.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+const replay = require('./shared/indexer.99ec3128.cjs');
+const sink = require('./shared/indexer.a8b7ab1f.cjs');
+require('node:fs/promises');
+require('node:path');
+require('consola');
+require('klona/full');
+require('node:assert');
+require('node:fs');
+require('@apibara/protocol/testing');
+require('hookable');
+require('node:async_hooks');
+require('unctx');
+require('@opentelemetry/api');
+
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+function useKVStore() {
+  const ctx = replay.useIndexerContext();
+  if (!ctx?.kv)
+    throw new Error("KV Plugin is not available in context!");
+  return ctx.kv;
+}
+
+function useSink({
+  context
+}) {
+  if (!context.sinkTransaction) {
+    throw new Error("Transaction context doesn't exist!");
+  }
+  return context.sinkTransaction;
+}
+
+exports.createIndexer = replay.createIndexer;
+exports.defineIndexer = replay.defineIndexer;
+exports.deserialize = replay.deserialize;
+exports.isCassetteAvailable = replay.isCassetteAvailable;
+exports.loadCassette = replay.loadCassette;
+exports.record = replay.record;
+exports.replay = replay.replay;
+exports.run = replay.run;
+exports.serialize = replay.serialize;
+exports.useIndexerContext = replay.useIndexerContext;
+exports.DefaultSink = sink.DefaultSink;
+exports.Sink = sink.Sink;
+exports.defaultSink = sink.defaultSink;
+exports.defineIndexerPlugin = defineIndexerPlugin;
+exports.useKVStore = useKVStore;
+exports.useSink = useSink;

package/dist/index.d.cts

@@ -0,0 +1,47 @@
+import { V as VcrConfig, I as Indexer, C as CassetteOptions, a as IndexerContext } from './shared/indexer.ff960804.cjs';
+export { c as IndexerConfig, b as IndexerHooks, g as IndexerPlugin, d as IndexerWithStreamConfig, j as VcrReplayResult, f as createIndexer, e as defineIndexer, h as defineIndexerPlugin, l as loadCassette, i as replay, r as run, u as useIndexerContext } from './shared/indexer.ff960804.cjs';
+export { D as DefaultSink, b as Sink, a as SinkCursorParams, S as SinkData, d as defaultSink } from './shared/indexer.d227f25c.cjs';
+import { StreamDataResponse, Client, DataFinality, Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+
+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>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare class KVStore {
+    private _db;
+    private _finality;
+    private _endCursor;
+    /** Sqlite Queries Prepare Statements */
+    private _beginTxnQuery;
+    private _commitTxnQuery;
+    private _rollbackTxnQuery;
+    private _getQuery;
+    private _updateToBlockQuery;
+    private _insertIntoKvsQuery;
+    private _delQuery;
+    constructor(_db: Database, _finality: DataFinality, _endCursor: Cursor);
+    static initialize(db: Database): void;
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    get<T>(key: string): T;
+    put<T>(key: string, value: T): void;
+    del(key: string): void;
+}
+
+type UseKVStoreResult = InstanceType<typeof KVStore>;
+declare function useKVStore(): UseKVStoreResult;
+
+declare function useSink<TTxnParams>({ context, }: {
+    context: IndexerContext<TTxnParams>;
+}): NonNullable<TTxnParams>;
+
+export { type CassetteDataType, CassetteOptions, Indexer, type UseKVStoreResult, VcrConfig, deserialize, isCassetteAvailable, record, serialize, useKVStore, useSink };

package/dist/index.d.mts

@@ -0,0 +1,47 @@
+import { V as VcrConfig, I as Indexer, C as CassetteOptions, a as IndexerContext } from './shared/indexer.9aa22867.mjs';
+export { c as IndexerConfig, b as IndexerHooks, g as IndexerPlugin, d as IndexerWithStreamConfig, j as VcrReplayResult, f as createIndexer, e as defineIndexer, h as defineIndexerPlugin, l as loadCassette, i as replay, r as run, u as useIndexerContext } from './shared/indexer.9aa22867.mjs';
+export { D as DefaultSink, b as Sink, a as SinkCursorParams, S as SinkData, d as defaultSink } from './shared/indexer.d227f25c.mjs';
+import { StreamDataResponse, Client, DataFinality, Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+
+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>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare class KVStore {
+    private _db;
+    private _finality;
+    private _endCursor;
+    /** Sqlite Queries Prepare Statements */
+    private _beginTxnQuery;
+    private _commitTxnQuery;
+    private _rollbackTxnQuery;
+    private _getQuery;
+    private _updateToBlockQuery;
+    private _insertIntoKvsQuery;
+    private _delQuery;
+    constructor(_db: Database, _finality: DataFinality, _endCursor: Cursor);
+    static initialize(db: Database): void;
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    get<T>(key: string): T;
+    put<T>(key: string, value: T): void;
+    del(key: string): void;
+}
+
+type UseKVStoreResult = InstanceType<typeof KVStore>;
+declare function useKVStore(): UseKVStoreResult;
+
+declare function useSink<TTxnParams>({ context, }: {
+    context: IndexerContext<TTxnParams>;
+}): NonNullable<TTxnParams>;
+
+export { type CassetteDataType, CassetteOptions, Indexer, type UseKVStoreResult, VcrConfig, deserialize, isCassetteAvailable, record, serialize, useKVStore, useSink };

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import { V as VcrConfig, I as Indexer, C as CassetteOptions, a as IndexerContext } from './shared/indexer.26fbe988.js';
+export { c as IndexerConfig, b as IndexerHooks, g as IndexerPlugin, d as IndexerWithStreamConfig, j as VcrReplayResult, f as createIndexer, e as defineIndexer, h as defineIndexerPlugin, l as loadCassette, i as replay, r as run, u as useIndexerContext } from './shared/indexer.26fbe988.js';
+export { D as DefaultSink, b as Sink, a as SinkCursorParams, S as SinkData, d as defaultSink } from './shared/indexer.d227f25c.js';
+import { StreamDataResponse, Client, DataFinality, Cursor } from '@apibara/protocol';
+import { Database } from 'better-sqlite3';
+import 'hookable';
+
+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>, indexerArg: Indexer<TFilter, TBlock, TTxnParams>, cassetteOptions: CassetteOptions): Promise<void>;
+
+declare class KVStore {
+    private _db;
+    private _finality;
+    private _endCursor;
+    /** Sqlite Queries Prepare Statements */
+    private _beginTxnQuery;
+    private _commitTxnQuery;
+    private _rollbackTxnQuery;
+    private _getQuery;
+    private _updateToBlockQuery;
+    private _insertIntoKvsQuery;
+    private _delQuery;
+    constructor(_db: Database, _finality: DataFinality, _endCursor: Cursor);
+    static initialize(db: Database): void;
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    get<T>(key: string): T;
+    put<T>(key: string, value: T): void;
+    del(key: string): void;
+}
+
+type UseKVStoreResult = InstanceType<typeof KVStore>;
+declare function useKVStore(): UseKVStoreResult;
+
+declare function useSink<TTxnParams>({ context, }: {
+    context: IndexerContext<TTxnParams>;
+}): NonNullable<TTxnParams>;
+
+export { type CassetteDataType, CassetteOptions, Indexer, type UseKVStoreResult, VcrConfig, deserialize, isCassetteAvailable, record, serialize, useKVStore, useSink };

package/dist/index.mjs

@@ -0,0 +1,36 @@
+import { u as useIndexerContext } from './shared/indexer.28bd9576.mjs';
+export { c as createIndexer, d as defineIndexer, a as deserialize, i as isCassetteAvailable, l as loadCassette, b as record, e as replay, r as run, s as serialize } from './shared/indexer.28bd9576.mjs';
+export { D as DefaultSink, S as Sink, d as defaultSink } from './shared/indexer.93d6b2eb.mjs';
+import 'node:fs/promises';
+import 'node:path';
+import 'consola';
+import 'klona/full';
+import 'node:assert';
+import 'node:fs';
+import '@apibara/protocol/testing';
+import 'hookable';
+import 'node:async_hooks';
+import 'unctx';
+import '@opentelemetry/api';
+
+function defineIndexerPlugin(def) {
+  return def;
+}
+
+function useKVStore() {
+  const ctx = useIndexerContext();
+  if (!ctx?.kv)
+    throw new Error("KV Plugin is not available in context!");
+  return ctx.kv;
+}
+
+function useSink({
+  context
+}) {
+  if (!context.sinkTransaction) {
+    throw new Error("Transaction context doesn't exist!");
+  }
+  return context.sinkTransaction;
+}
+
+export { defineIndexerPlugin, useIndexerContext, useKVStore, useSink };

package/dist/shared/indexer.26fbe988.d.ts

@@ -0,0 +1,100 @@
+import { StreamDataRequest, StreamDataOptions, Cursor, DataFinality, StreamDataResponse, StreamConfig, Client } from '@apibara/protocol';
+import { NestedHooks, Hookable } from 'hookable';
+import { b as Sink, S as SinkData } from './indexer.d227f25c.js';
+
+interface IndexerContext<TTxnParams = any> extends Record<string, any> {
+    sink?: Sink<TTxnParams>;
+    sinkTransaction?: TTxnParams;
+}
+declare function useIndexerContext<TTxnParams = any>(): IndexerContext<TTxnParams>;
+
+type IndexerPlugin<TFilter, TBlock, TTxnParams> = (indexer: Indexer<TFilter, TBlock, TTxnParams>) => void;
+declare function defineIndexerPlugin<TFilter, TBlock, TTxnParams>(def: IndexerPlugin<TFilter, TBlock, TTxnParams>): IndexerPlugin<TFilter, TBlock, TTxnParams>;
+
+interface IndexerHooks<TFilter, TBlock> {
+    "run:before": () => void;
+    "run:after": () => void;
+    "connect:before": ({ request, options, }: {
+        request: StreamDataRequest<TFilter>;
+        options: StreamDataOptions;
+    }) => void;
+    "connect:after": () => void;
+    "connect:factory": ({ request, endCursor, }: {
+        request: StreamDataRequest<TFilter>;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:before": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:after": ({ block, finality, endCursor, }: {
+        block: TBlock;
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "transaction:commit": ({ finality, endCursor, }: {
+        finality: DataFinality;
+        endCursor?: Cursor;
+    }) => void;
+    "handler:exception": ({ error }: {
+        error: Error;
+    }) => void;
+    message: ({ message }: {
+        message: StreamDataResponse<TBlock>;
+    }) => void;
+}
+interface IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamUrl: string;
+    filter: TFilter;
+    finality?: DataFinality;
+    startingCursor?: Cursor;
+    sink?: Sink<TTxnParams>;
+    factory?: ({ block, context, }: {
+        block: TBlock;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<{
+        filter?: TFilter;
+    }>;
+    transform: (args: {
+        block: TBlock;
+        cursor?: Cursor | undefined;
+        endCursor?: Cursor | undefined;
+        finality: DataFinality;
+        context: IndexerContext<TTxnParams>;
+    }) => Promise<void>;
+    hooks?: NestedHooks<IndexerHooks<TFilter, TBlock>>;
+    plugins?: ReadonlyArray<IndexerPlugin<TFilter, TBlock, TTxnParams>>;
+    debug?: boolean;
+}
+interface IndexerWithStreamConfig<TFilter, TBlock, TTxnParams> extends IndexerConfig<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+}
+declare function defineIndexer<TFilter, TBlock>(streamConfig: StreamConfig<TFilter, TBlock>): <TTxnParams>(config: IndexerConfig<TFilter, TBlock, TTxnParams>) => IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>;
+interface Indexer<TFilter, TBlock, TTxnParams> {
+    streamConfig: StreamConfig<TFilter, TBlock>;
+    options: IndexerConfig<TFilter, TBlock, TTxnParams>;
+    hooks: Hookable<IndexerHooks<TFilter, TBlock>>;
+}
+declare function createIndexer<TFilter, TBlock, TTxnParams>({ streamConfig, ...options }: IndexerWithStreamConfig<TFilter, TBlock, TTxnParams>): Indexer<TFilter, TBlock, TTxnParams>;
+declare function run<TFilter, TBlock, TTxnParams>(client: Client<TFilter, TBlock>, indexer: Indexer<TFilter, TBlock, TTxnParams>): Promise<void>;
+
+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 Indexer as I, type VcrConfig as V, type IndexerContext as a, type IndexerHooks as b, type IndexerConfig as c, type IndexerWithStreamConfig as d, defineIndexer as e, createIndexer as f, type IndexerPlugin as g, defineIndexerPlugin as h, replay as i, type VcrReplayResult as j, loadCassette as l, run as r, useIndexerContext as u };

package/dist/shared/indexer.28bd9576.mjs

@@ -0,0 +1,279 @@
+import fs$1 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 { createHooks, createDebugger } from 'hookable';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getContext } from 'unctx';
+import { trace } from '@opentelemetry/api';
+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");
+
+function defineIndexer(streamConfig) {
+  return (config) => ({
+    streamConfig,
+    ...config
+  });
+}
+function createIndexer({
+  streamConfig,
+  ...options
+}) {
+  const indexer = {
+    options,
+    streamConfig,
+    hooks: createHooks()
+  };
+  if (indexer.options.debug) {
+    createDebugger(indexer.hooks, { tag: "indexer" });
+  }
+  indexer.hooks.addHooks(indexer.options.hooks ?? {});
+  for (const plugin of indexer.options.plugins ?? []) {
+    plugin(indexer);
+  }
+  return indexer;
+}
+async function run(client, indexer) {
+  await indexerAsyncContext.callAsync({}, async () => {
+    const context = useIndexerContext();
+    const sink = indexer.options.sink ?? defaultSink();
+    context.sink = sink;
+    await indexer.hooks.callHook("run:before");
+    const isFactoryMode = indexer.options.factory !== void 0;
+    const request = indexer.streamConfig.Request.make({
+      filter: isFactoryMode ? [indexer.options.filter, {}] : [indexer.options.filter],
+      finality: indexer.options.finality,
+      startingCursor: indexer.options.startingCursor
+    });
+    const options = {};
+    await indexer.hooks.callHook("connect:before", { request, options });
+    let mainFilter;
+    if (isFactoryMode) {
+      mainFilter = request.filter[1];
+    }
+    let stream = client.streamData(request, options)[Symbol.asyncIterator]();
+    await indexer.hooks.callHook("connect:after");
+    while (true) {
+      const { value: message, done } = await stream.next();
+      if (done) {
+        break;
+      }
+      await indexer.hooks.callHook("message", { message });
+      switch (message._tag) {
+        case "data": {
+          await tracer.startActiveSpan("message data", async (span) => {
+            const blocks = message.data.data;
+            const { cursor, endCursor, finality } = message.data;
+            await sink.transaction(
+              { cursor, endCursor, finality },
+              async (txn) => {
+                context.sinkTransaction = txn;
+                let block;
+                if (isFactoryMode) {
+                  assert(indexer.options.factory !== void 0);
+                  const [factoryBlock, mainBlock] = blocks;
+                  block = mainBlock;
+                  if (factoryBlock !== null) {
+                    const { filter } = await indexer.options.factory({
+                      block: factoryBlock,
+                      context
+                    });
+                    if (filter) {
+                      mainFilter = indexer.streamConfig.mergeFilter(
+                        mainFilter,
+                        filter
+                      );
+                      const request2 = indexer.streamConfig.Request.make({
+                        filter: [indexer.options.filter, mainFilter],
+                        finality: indexer.options.finality,
+                        startingCursor: cursor
+                      });
+                      await indexer.hooks.callHook("connect:factory", {
+                        request: request2,
+                        endCursor
+                      });
+                      stream = client.streamData(request2, options)[Symbol.asyncIterator]();
+                      const { value: message2 } = await stream.next();
+                      assert(message2._tag === "data");
+                      const [_factoryBlock, _block] = message2.data.data;
+                      block = _block;
+                    }
+                  }
+                } else {
+                  block = blocks[0];
+                }
+                if (block) {
+                  await tracer.startActiveSpan("handler", async (span2) => {
+                    await indexer.hooks.callHook("handler:before", {
+                      block,
+                      endCursor,
+                      finality
+                    });
+                    try {
+                      await indexer.options.transform({
+                        block,
+                        cursor,
+                        endCursor,
+                        finality,
+                        context
+                      });
+                      await indexer.hooks.callHook("handler:after", {
+                        block,
+                        finality,
+                        endCursor
+                      });
+                    } catch (error) {
+                      assert(error instanceof Error);
+                      await indexer.hooks.callHook("handler:exception", {
+                        error
+                      });
+                      throw error;
+                    }
+                    span2.end();
+                  });
+                }
+              }
+            );
+            await indexer.hooks.callHook("transaction:commit", {
+              finality,
+              endCursor
+            });
+            span.end();
+          });
+          break;
+        }
+        case "invalidate": {
+          await tracer.startActiveSpan("message invalidate", async (span) => {
+            await sink.invalidate(message.invalidate.cursor);
+          });
+          break;
+        }
+        default: {
+          consola.warn("unexpected message", message);
+          throw new Error("not implemented");
+        }
+      }
+      await indexer.hooks.callHook("run:after");
+    }
+  });
+}
+
+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 = [];
+  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
+      };
+      const filePath = path.join(
+        vcrConfig.cassetteDir,
+        `${cassetteOptions.name}.json`
+      );
+      await fs$1.writeFile(filePath, serialize(output), { flag: "w" });
+    }
+  });
+  await run(client, indexer);
+}
+
+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;
+};
+const transactionHelper = (context) => {
+  return {
+    insert: (data) => {
+      context.buffer.push(...data);
+    }
+  };
+};
+class VcrSink extends Sink {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "result", []);
+  }
+  write({ data, endCursor }) {
+    if (data.length === 0)
+      return;
+    this.result.push({ data, endCursor });
+  }
+  async transaction({ cursor, endCursor, finality }, cb) {
+    const context = {
+      buffer: []
+    };
+    const writer = transactionHelper(context);
+    await cb({ writer });
+    this.write({ data: context.buffer, endCursor });
+  }
+  async invalidate(cursor) {
+    throw new Error("Not implemented");
+  }
+}
+function vcr() {
+  return new VcrSink();
+}
+
+async function replay(vcrConfig, indexer, cassetteName) {
+  const client = loadCassette(vcrConfig, cassetteName);
+  const sink = vcr();
+  await run(client, indexer);
+  return {
+    outputs: sink.result
+  };
+}
+function loadCassette(vcrConfig, cassetteName) {
+  const filePath = path.join(vcrConfig.cassetteDir, `${cassetteName}.json`);
+  const data = fs.readFileSync(filePath, "utf8");
+  const cassetteData = deserialize(data);
+  const { filter, messages } = cassetteData;
+  return new MockClient((request, options) => {
+    assert.deepStrictEqual(
+      request.filter,
+      filter,
+      "Request and Cassette filter mismatch"
+    );
+    return messages;
+  });
+}
+
+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 };

package/dist/shared/indexer.93d6b2eb.mjs

@@ -0,0 +1,17 @@
+import consola from 'consola';
+
+class Sink {
+}
+class DefaultSink extends Sink {
+  async transaction({ cursor, endCursor, finality }, cb) {
+    await cb({});
+  }
+  async invalidate(cursor) {
+    consola.info(`Invalidating cursor ${cursor?.orderKey}`);
+  }
+}
+function defaultSink() {
+  return new DefaultSink();
+}
+
+export { DefaultSink as D, Sink as S, defaultSink as d };