@apibara/plugin-mongo 2.0.0-beta.28 → 2.0.0-beta.30

package/dist/index.cjs

@@ -30,13 +30,108 @@ async function finalize(db, session, cursor, collections) {
   for (const collection of collections) {
     await db.collection(collection).deleteMany(
       {
-        "_cursor.to": { $lt: orderKeyValue }
+        "_cursor.to": { $lte: orderKeyValue }
       },
       { session }
     );
   }
 }
 
+const checkpointCollectionName = "checkpoints";
+const filterCollectionName = "filters";
+async function initializePersistentState(db, session) {
+  const checkpoint = await db.createCollection(
+    checkpointCollectionName,
+    { session }
+  );
+  const filter = await db.createCollection(filterCollectionName, {
+    session
+  });
+  await checkpoint.createIndex({ id: 1 }, { session });
+  await filter.createIndex({ id: 1, fromBlock: 1 }, { session });
+}
+async function persistState(props) {
+  const { db, session, endCursor, filter, indexerName } = props;
+  if (endCursor) {
+    await db.collection(checkpointCollectionName).updateOne(
+      { id: indexerName },
+      {
+        $set: {
+          orderKey: Number(endCursor.orderKey),
+          uniqueKey: endCursor.uniqueKey
+        }
+      },
+      { upsert: true, session }
+    );
+    if (filter) {
+      await db.collection(filterCollectionName).updateMany(
+        { id: indexerName, toBlock: null },
+        { $set: { toBlock: Number(endCursor.orderKey) } },
+        { session }
+      );
+      await db.collection(filterCollectionName).updateOne(
+        {
+          id: indexerName,
+          fromBlock: Number(endCursor.orderKey)
+        },
+        {
+          $set: {
+            filter,
+            fromBlock: Number(endCursor.orderKey),
+            toBlock: null
+          }
+        },
+        { upsert: true, session }
+      );
+    }
+  }
+}
+async function getState(props) {
+  const { db, session, indexerName } = props;
+  let cursor;
+  let filter;
+  const checkpointRow = await db.collection(checkpointCollectionName).findOne({ id: indexerName }, { session });
+  if (checkpointRow) {
+    cursor = {
+      orderKey: BigInt(checkpointRow.orderKey),
+      uniqueKey: checkpointRow.uniqueKey
+    };
+  }
+  const filterRow = await db.collection(filterCollectionName).findOne(
+    {
+      id: indexerName,
+      toBlock: null
+    },
+    { session }
+  );
+  if (filterRow) {
+    filter = filterRow.filter;
+  }
+  return { cursor, filter };
+}
+async function invalidateState(props) {
+  const { db, session, cursor, indexerName } = props;
+  await db.collection(filterCollectionName).deleteMany(
+    { id: indexerName, fromBlock: { $gt: Number(cursor.orderKey) } },
+    { session }
+  );
+  await db.collection(filterCollectionName).updateMany(
+    { id: indexerName, toBlock: { $gt: Number(cursor.orderKey) } },
+    { $set: { toBlock: null } },
+    { session }
+  );
+}
+async function finalizeState(props) {
+  const { db, session, cursor, indexerName } = props;
+  await db.collection(filterCollectionName).deleteMany(
+    {
+      id: indexerName,
+      toBlock: { $lte: Number(cursor.orderKey) }
+    },
+    { session }
+  );
+}
+
 class MongoStorage {
   constructor(db, session, endCursor) {
     this.db = db;
@@ -236,9 +331,67 @@ function mongoStorage({
   dbName,
   dbOptions,
   collections,
-  persistState: enablePersistence = true
+  persistState: enablePersistence = true,
+  indexerName = "default"
 }) {
   return plugins.defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", async () => {
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (enablePersistence) {
+          await initializePersistentState(db, session);
+        }
+      });
+    });
+    indexer.hooks.hook("connect:before", async ({ request }) => {
+      if (!enablePersistence) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        const { cursor, filter } = await getState({
+          db,
+          session,
+          indexerName
+        });
+        if (cursor) {
+          request.startingCursor = cursor;
+        }
+        if (filter) {
+          request.filter[1] = filter;
+        }
+      });
+    });
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      const cursor = request.startingCursor;
+      if (!cursor) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
+      });
+    });
+    indexer.hooks.hook("connect:factory", async ({ request, endCursor }) => {
+      if (!enablePersistence) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (endCursor && request.filter[1]) {
+          await persistState({
+            db,
+            endCursor,
+            session,
+            filter: request.filter[1],
+            indexerName
+          });
+        }
+      });
+    });
     indexer.hooks.hook("message:finalize", async ({ message }) => {
       const { cursor } = message.finalize;
       if (!cursor) {
@@ -247,6 +400,9 @@ function mongoStorage({
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await finalize(db, session, cursor, collections);
+        if (enablePersistence) {
+          await finalizeState({ db, session, cursor, indexerName });
+        }
       });
     });
     indexer.hooks.hook("message:invalidate", async ({ message }) => {
@@ -257,16 +413,9 @@ function mongoStorage({
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await invalidate(db, session, cursor, collections);
-      });
-    });
-    indexer.hooks.hook("connect:after", async ({ request }) => {
-      const cursor = request.startingCursor;
-      if (!cursor) {
-        return;
-      }
-      await withTransaction(client, async (session) => {
-        const db = client.db(dbName, dbOptions);
-        await invalidate(db, session, cursor, collections);
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
       });
     });
     indexer.hooks.hook("handler:middleware", async ({ use }) => {
@@ -280,6 +429,9 @@ function mongoStorage({
           context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
           await next();
           delete context[MONGO_PROPERTY];
+          if (enablePersistence) {
+            await persistState({ db, endCursor, session, indexerName });
+          }
         });
       });
     });

package/dist/index.d.cts

@@ -31,7 +31,19 @@ interface MongoStorageOptions {
     dbOptions?: DbOptions;
     collections: string[];
     persistState?: boolean;
+    indexerName?: string;
 }
-declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+/**
+ * Creates a plugin that uses MongoDB as the storage layer.
+ *
+ * Supports storing the indexer's state and provides a simple Key-Value store.
+ * @param options.client - The MongoDB client instance.
+ * @param options.dbName - The name of the database.
+ * @param options.dbOptions - The database options.
+ * @param options.collections - The collections to use.
+ * @param options.persistState - Whether to persist the indexer's state. Defaults to true.
+ * @param options.indexerName - The name of the indexer. Defaults value is 'default'.
+ */
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, indexerName, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.d.mts

@@ -31,7 +31,19 @@ interface MongoStorageOptions {
     dbOptions?: DbOptions;
     collections: string[];
     persistState?: boolean;
+    indexerName?: string;
 }
-declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+/**
+ * Creates a plugin that uses MongoDB as the storage layer.
+ *
+ * Supports storing the indexer's state and provides a simple Key-Value store.
+ * @param options.client - The MongoDB client instance.
+ * @param options.dbName - The name of the database.
+ * @param options.dbOptions - The database options.
+ * @param options.collections - The collections to use.
+ * @param options.persistState - Whether to persist the indexer's state. Defaults to true.
+ * @param options.indexerName - The name of the indexer. Defaults value is 'default'.
+ */
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, indexerName, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.d.ts

@@ -31,7 +31,19 @@ interface MongoStorageOptions {
     dbOptions?: DbOptions;
     collections: string[];
     persistState?: boolean;
+    indexerName?: string;
 }
-declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
+/**
+ * Creates a plugin that uses MongoDB as the storage layer.
+ *
+ * Supports storing the indexer's state and provides a simple Key-Value store.
+ * @param options.client - The MongoDB client instance.
+ * @param options.dbName - The name of the database.
+ * @param options.dbOptions - The database options.
+ * @param options.collections - The collections to use.
+ * @param options.persistState - Whether to persist the indexer's state. Defaults to true.
+ * @param options.indexerName - The name of the indexer. Defaults value is 'default'.
+ */
+declare function mongoStorage<TFilter, TBlock>({ client, dbName, dbOptions, collections, persistState: enablePersistence, indexerName, }: MongoStorageOptions): _apibara_indexer_plugins.IndexerPlugin<TFilter, TBlock>;
 
 export { MongoCollection, MongoStorage, type MongoStorageOptions, mongoStorage, useMongoStorage };

package/dist/index.mjs

@@ -28,13 +28,108 @@ async function finalize(db, session, cursor, collections) {
   for (const collection of collections) {
     await db.collection(collection).deleteMany(
       {
-        "_cursor.to": { $lt: orderKeyValue }
+        "_cursor.to": { $lte: orderKeyValue }
       },
       { session }
     );
   }
 }
 
+const checkpointCollectionName = "checkpoints";
+const filterCollectionName = "filters";
+async function initializePersistentState(db, session) {
+  const checkpoint = await db.createCollection(
+    checkpointCollectionName,
+    { session }
+  );
+  const filter = await db.createCollection(filterCollectionName, {
+    session
+  });
+  await checkpoint.createIndex({ id: 1 }, { session });
+  await filter.createIndex({ id: 1, fromBlock: 1 }, { session });
+}
+async function persistState(props) {
+  const { db, session, endCursor, filter, indexerName } = props;
+  if (endCursor) {
+    await db.collection(checkpointCollectionName).updateOne(
+      { id: indexerName },
+      {
+        $set: {
+          orderKey: Number(endCursor.orderKey),
+          uniqueKey: endCursor.uniqueKey
+        }
+      },
+      { upsert: true, session }
+    );
+    if (filter) {
+      await db.collection(filterCollectionName).updateMany(
+        { id: indexerName, toBlock: null },
+        { $set: { toBlock: Number(endCursor.orderKey) } },
+        { session }
+      );
+      await db.collection(filterCollectionName).updateOne(
+        {
+          id: indexerName,
+          fromBlock: Number(endCursor.orderKey)
+        },
+        {
+          $set: {
+            filter,
+            fromBlock: Number(endCursor.orderKey),
+            toBlock: null
+          }
+        },
+        { upsert: true, session }
+      );
+    }
+  }
+}
+async function getState(props) {
+  const { db, session, indexerName } = props;
+  let cursor;
+  let filter;
+  const checkpointRow = await db.collection(checkpointCollectionName).findOne({ id: indexerName }, { session });
+  if (checkpointRow) {
+    cursor = {
+      orderKey: BigInt(checkpointRow.orderKey),
+      uniqueKey: checkpointRow.uniqueKey
+    };
+  }
+  const filterRow = await db.collection(filterCollectionName).findOne(
+    {
+      id: indexerName,
+      toBlock: null
+    },
+    { session }
+  );
+  if (filterRow) {
+    filter = filterRow.filter;
+  }
+  return { cursor, filter };
+}
+async function invalidateState(props) {
+  const { db, session, cursor, indexerName } = props;
+  await db.collection(filterCollectionName).deleteMany(
+    { id: indexerName, fromBlock: { $gt: Number(cursor.orderKey) } },
+    { session }
+  );
+  await db.collection(filterCollectionName).updateMany(
+    { id: indexerName, toBlock: { $gt: Number(cursor.orderKey) } },
+    { $set: { toBlock: null } },
+    { session }
+  );
+}
+async function finalizeState(props) {
+  const { db, session, cursor, indexerName } = props;
+  await db.collection(filterCollectionName).deleteMany(
+    {
+      id: indexerName,
+      toBlock: { $lte: Number(cursor.orderKey) }
+    },
+    { session }
+  );
+}
+
 class MongoStorage {
   constructor(db, session, endCursor) {
     this.db = db;
@@ -234,9 +329,67 @@ function mongoStorage({
   dbName,
   dbOptions,
   collections,
-  persistState: enablePersistence = true
+  persistState: enablePersistence = true,
+  indexerName = "default"
 }) {
   return defineIndexerPlugin((indexer) => {
+    indexer.hooks.hook("run:before", async () => {
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (enablePersistence) {
+          await initializePersistentState(db, session);
+        }
+      });
+    });
+    indexer.hooks.hook("connect:before", async ({ request }) => {
+      if (!enablePersistence) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        const { cursor, filter } = await getState({
+          db,
+          session,
+          indexerName
+        });
+        if (cursor) {
+          request.startingCursor = cursor;
+        }
+        if (filter) {
+          request.filter[1] = filter;
+        }
+      });
+    });
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      const cursor = request.startingCursor;
+      if (!cursor) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await invalidate(db, session, cursor, collections);
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
+      });
+    });
+    indexer.hooks.hook("connect:factory", async ({ request, endCursor }) => {
+      if (!enablePersistence) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (endCursor && request.filter[1]) {
+          await persistState({
+            db,
+            endCursor,
+            session,
+            filter: request.filter[1],
+            indexerName
+          });
+        }
+      });
+    });
     indexer.hooks.hook("message:finalize", async ({ message }) => {
       const { cursor } = message.finalize;
       if (!cursor) {
@@ -245,6 +398,9 @@ function mongoStorage({
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await finalize(db, session, cursor, collections);
+        if (enablePersistence) {
+          await finalizeState({ db, session, cursor, indexerName });
+        }
       });
     });
     indexer.hooks.hook("message:invalidate", async ({ message }) => {
@@ -255,16 +411,9 @@ function mongoStorage({
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await invalidate(db, session, cursor, collections);
-      });
-    });
-    indexer.hooks.hook("connect:after", async ({ request }) => {
-      const cursor = request.startingCursor;
-      if (!cursor) {
-        return;
-      }
-      await withTransaction(client, async (session) => {
-        const db = client.db(dbName, dbOptions);
-        await invalidate(db, session, cursor, collections);
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
       });
     });
     indexer.hooks.hook("handler:middleware", async ({ use }) => {
@@ -278,6 +427,9 @@ function mongoStorage({
           context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
           await next();
           delete context[MONGO_PROPERTY];
+          if (enablePersistence) {
+            await persistState({ db, endCursor, session, indexerName });
+          }
         });
       });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/plugin-mongo",
-  "version": "2.0.0-beta.28",
+  "version": "2.0.0-beta.30",
   "type": "module",
   "files": [
     "dist",
@@ -35,7 +35,7 @@
     "mongodb": "^6.12.0"
   },
   "dependencies": {
-    "@apibara/indexer": "2.0.0-beta.28",
-    "@apibara/protocol": "2.0.0-beta.28"
+    "@apibara/indexer": "2.0.0-beta.30",
+    "@apibara/protocol": "2.0.0-beta.30"
   }
 }

package/src/index.ts

@@ -3,6 +3,13 @@ import { defineIndexerPlugin } from "@apibara/indexer/plugins";
 import type { DbOptions, MongoClient } from "mongodb";
 
 import { finalize, invalidate } from "./mongo";
+import {
+  finalizeState,
+  getState,
+  initializePersistentState,
+  invalidateState,
+  persistState,
+} from "./persistence";
 import { MongoStorage } from "./storage";
 import { MongoStorageError, withTransaction } from "./utils";
 
@@ -28,53 +35,127 @@ export interface MongoStorageOptions {
   dbOptions?: DbOptions;
   collections: string[];
   persistState?: boolean;
+  indexerName?: string;
 }
-
+/**
+ * Creates a plugin that uses MongoDB as the storage layer.
+ *
+ * Supports storing the indexer's state and provides a simple Key-Value store.
+ * @param options.client - The MongoDB client instance.
+ * @param options.dbName - The name of the database.
+ * @param options.dbOptions - The database options.
+ * @param options.collections - The collections to use.
+ * @param options.persistState - Whether to persist the indexer's state. Defaults to true.
+ * @param options.indexerName - The name of the indexer. Defaults value is 'default'.
+ */
 export function mongoStorage<TFilter, TBlock>({
   client,
   dbName,
   dbOptions,
   collections,
   persistState: enablePersistence = true,
+  indexerName = "default",
 }: MongoStorageOptions) {
   return defineIndexerPlugin<TFilter, TBlock>((indexer) => {
-    indexer.hooks.hook("message:finalize", async ({ message }) => {
-      const { cursor } = message.finalize;
+    indexer.hooks.hook("run:before", async () => {
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (enablePersistence) {
+          await initializePersistentState(db, session);
+        }
+      });
+    });
 
-      if (!cursor) {
-        throw new MongoStorageError("finalized cursor is undefined");
+    indexer.hooks.hook("connect:before", async ({ request }) => {
+      if (!enablePersistence) {
+        return;
       }
 
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
-        await finalize(db, session, cursor, collections);
+        const { cursor, filter } = await getState<TFilter>({
+          db,
+          session,
+          indexerName,
+        });
+
+        if (cursor) {
+          request.startingCursor = cursor;
+        }
+
+        if (filter) {
+          request.filter[1] = filter;
+        }
       });
     });
 
-    indexer.hooks.hook("message:invalidate", async ({ message }) => {
-      const { cursor } = message.invalidate;
+    indexer.hooks.hook("connect:after", async ({ request }) => {
+      // On restart, we need to invalidate data for blocks that were processed but not persisted.
+      const cursor = request.startingCursor;
 
       if (!cursor) {
-        throw new MongoStorageError("invalidate cursor is undefined");
+        return;
       }
 
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await invalidate(db, session, cursor, collections);
+
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
       });
     });
 
-    indexer.hooks.hook("connect:after", async ({ request }) => {
-      // On restart, we need to invalidate data for blocks that were processed but not persisted.
-      const cursor = request.startingCursor;
+    indexer.hooks.hook("connect:factory", async ({ request, endCursor }) => {
+      if (!enablePersistence) {
+        return;
+      }
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        if (endCursor && request.filter[1]) {
+          await persistState({
+            db,
+            endCursor,
+            session,
+            filter: request.filter[1],
+            indexerName,
+          });
+        }
+      });
+    });
+
+    indexer.hooks.hook("message:finalize", async ({ message }) => {
+      const { cursor } = message.finalize;
 
       if (!cursor) {
-        return;
+        throw new MongoStorageError("finalized cursor is undefined");
+      }
+
+      await withTransaction(client, async (session) => {
+        const db = client.db(dbName, dbOptions);
+        await finalize(db, session, cursor, collections);
+
+        if (enablePersistence) {
+          await finalizeState({ db, session, cursor, indexerName });
+        }
+      });
+    });
+
+    indexer.hooks.hook("message:invalidate", async ({ message }) => {
+      const { cursor } = message.invalidate;
+
+      if (!cursor) {
+        throw new MongoStorageError("invalidate cursor is undefined");
       }
 
       await withTransaction(client, async (session) => {
         const db = client.db(dbName, dbOptions);
         await invalidate(db, session, cursor, collections);
+
+        if (enablePersistence) {
+          await invalidateState({ db, session, cursor, indexerName });
+        }
       });
     });
 
@@ -91,11 +172,10 @@ export function mongoStorage<TFilter, TBlock>({
           context[MONGO_PROPERTY] = new MongoStorage(db, session, endCursor);
 
           await next();
-
           delete context[MONGO_PROPERTY];
 
           if (enablePersistence) {
-            // TODO: persist state
+            await persistState({ db, endCursor, session, indexerName });
           }
         });
       });

package/src/mongo.ts

@@ -43,7 +43,7 @@ export async function finalize(
     // Delete documents where the upper bound of _cursor is less than the finalize cursor
     await db.collection(collection).deleteMany(
       {
-        "_cursor.to": { $lt: orderKeyValue },
+        "_cursor.to": { $lte: orderKeyValue },
       },
       { session },
     );

package/src/persistence.ts

@@ -0,0 +1,163 @@
+import type { Cursor } from "@apibara/protocol";
+import type { ClientSession, Db } from "mongodb";
+
+export type CheckpointSchema = {
+  id: string;
+  orderKey: number;
+  uniqueKey?: `0x${string}`;
+};
+
+export type FilterSchema = {
+  id: string;
+  filter: Record<string, unknown>;
+  fromBlock: number;
+  toBlock: number | null;
+};
+
+export const checkpointCollectionName = "checkpoints";
+export const filterCollectionName = "filters";
+
+export async function initializePersistentState(
+  db: Db,
+  session: ClientSession,
+) {
+  const checkpoint = await db.createCollection<CheckpointSchema>(
+    checkpointCollectionName,
+    { session },
+  );
+  const filter = await db.createCollection<FilterSchema>(filterCollectionName, {
+    session,
+  });
+
+  await checkpoint.createIndex({ id: 1 }, { session });
+  await filter.createIndex({ id: 1, fromBlock: 1 }, { session });
+}
+
+export async function persistState<TFilter>(props: {
+  db: Db;
+  session: ClientSession;
+  endCursor: Cursor;
+  filter?: TFilter;
+  indexerName: string;
+}) {
+  const { db, session, endCursor, filter, indexerName } = props;
+
+  if (endCursor) {
+    await db.collection<CheckpointSchema>(checkpointCollectionName).updateOne(
+      { id: indexerName },
+      {
+        $set: {
+          orderKey: Number(endCursor.orderKey),
+          uniqueKey: endCursor.uniqueKey,
+        },
+      },
+      { upsert: true, session },
+    );
+
+    if (filter) {
+      // Update existing filter's to_block
+      await db
+        .collection<FilterSchema>(filterCollectionName)
+        .updateMany(
+          { id: indexerName, toBlock: null },
+          { $set: { toBlock: Number(endCursor.orderKey) } },
+          { session },
+        );
+
+      // Insert new filter
+      await db.collection<FilterSchema>(filterCollectionName).updateOne(
+        {
+          id: indexerName,
+          fromBlock: Number(endCursor.orderKey),
+        },
+        {
+          $set: {
+            filter: filter as Record<string, unknown>,
+            fromBlock: Number(endCursor.orderKey),
+            toBlock: null,
+          },
+        },
+        { upsert: true, session },
+      );
+    }
+  }
+}
+
+export async function getState<TFilter>(props: {
+  db: Db;
+  session: ClientSession;
+  indexerName: string;
+}): Promise<{ cursor?: Cursor; filter?: TFilter }> {
+  const { db, session, indexerName } = props;
+
+  let cursor: Cursor | undefined;
+  let filter: TFilter | undefined;
+
+  const checkpointRow = await db
+    .collection<CheckpointSchema>(checkpointCollectionName)
+    .findOne({ id: indexerName }, { session });
+
+  if (checkpointRow) {
+    cursor = {
+      orderKey: BigInt(checkpointRow.orderKey),
+      uniqueKey: checkpointRow.uniqueKey,
+    };
+  }
+
+  const filterRow = await db
+    .collection<FilterSchema>(filterCollectionName)
+    .findOne(
+      {
+        id: indexerName,
+        toBlock: null,
+      },
+      { session },
+    );
+
+  if (filterRow) {
+    filter = filterRow.filter as TFilter;
+  }
+
+  return { cursor, filter };
+}
+
+export async function invalidateState(props: {
+  db: Db;
+  session: ClientSession;
+  cursor: Cursor;
+  indexerName: string;
+}) {
+  const { db, session, cursor, indexerName } = props;
+
+  await db
+    .collection<FilterSchema>(filterCollectionName)
+    .deleteMany(
+      { id: indexerName, fromBlock: { $gt: Number(cursor.orderKey) } },
+      { session },
+    );
+
+  await db
+    .collection<FilterSchema>(filterCollectionName)
+    .updateMany(
+      { id: indexerName, toBlock: { $gt: Number(cursor.orderKey) } },
+      { $set: { toBlock: null } },
+      { session },
+    );
+}
+
+export async function finalizeState(props: {
+  db: Db;
+  session: ClientSession;
+  cursor: Cursor;
+  indexerName: string;
+}) {
+  const { db, session, cursor, indexerName } = props;
+
+  await db.collection<FilterSchema>(filterCollectionName).deleteMany(
+    {
+      id: indexerName,
+      toBlock: { $lte: Number(cursor.orderKey) },
+    },
+    { session },
+  );
+}