ponder 0.14.13 → 0.15.0

package/src/database/actions.ts

@@ -1,6 +1,19 @@
-import { getPrimaryKeyColumns } from "@/drizzle/index.js";
-import { getTableNames } from "@/drizzle/index.js";
+import {
+  getPartitionName,
+  getPrimaryKeyColumns,
+  getReorgProcedureName,
+  getReorgTableName,
+  getReorgTriggerName,
+} from "@/drizzle/index.js";
 import { getColumnCasing, getReorgTable } from "@/drizzle/kit/index.js";
+import {
+  getLiveQueryChannelName,
+  getLiveQueryNotifyProcedureName,
+  getLiveQueryNotifyTriggerName,
+  getLiveQueryProcedureName,
+  getLiveQueryTriggerName,
+  getViewsLiveQueryNotifyTriggerName,
+} from "@/drizzle/onchain.js";
 import type { Logger } from "@/internal/logger.js";
 import type {
   NamespaceBuild,
@@ -9,12 +22,16 @@ import type {
 } from "@/internal/types.js";
 import { MAX_CHECKPOINT_STRING, decodeCheckpoint } from "@/utils/checkpoint.js";
 import {
+  type SQL,
   type Table,
   type View,
+  and,
   eq,
   getTableColumns,
   getTableName,
   getViewName,
+  lte,
+  sql,
 } from "drizzle-orm";
 import { getTableConfig } from "drizzle-orm/pg-core";
 import { getPonderCheckpointTable } from "./index.js";
@@ -41,7 +58,7 @@ export const createIndexes = async (
 
 export const createTriggers = async (
   qb: QB,
-  { tables }: { tables: Table[] },
+  { tables, chainId }: { tables: Table[]; chainId?: number },
   context?: { logger?: Logger },
 ) => {
   await qb.transaction(
@@ -58,17 +75,17 @@ export const createTriggers = async (
           await tx.wrap({ label: "create_trigger" }, (tx) =>
             tx.execute(
               `
-  CREATE OR REPLACE FUNCTION "${schema}".${getTableNames(table).triggerFn}
+  CREATE OR REPLACE FUNCTION "${schema}".${getReorgProcedureName(table)}
   RETURNS TRIGGER AS $$
   BEGIN
   IF TG_OP = 'INSERT' THEN
-  INSERT INTO "${schema}"."${getTableName(getReorgTable(table))}" (${columnNames.join(",")}, operation, checkpoint)
+  INSERT INTO "${schema}"."${getReorgTableName(table)}" (${columnNames.join(",")}, operation, checkpoint)
   VALUES (${columnNames.map((name) => `NEW.${name}`).join(",")}, 0, '${MAX_CHECKPOINT_STRING}');
   ELSIF TG_OP = 'UPDATE' THEN
-  INSERT INTO "${schema}"."${getTableName(getReorgTable(table))}" (${columnNames.join(",")}, operation, checkpoint)
+  INSERT INTO "${schema}"."${getReorgTableName(table)}" (${columnNames.join(",")}, operation, checkpoint)
   VALUES (${columnNames.map((name) => `OLD.${name}`).join(",")}, 1, '${MAX_CHECKPOINT_STRING}');
   ELSIF TG_OP = 'DELETE' THEN
-  INSERT INTO "${schema}"."${getTableName(getReorgTable(table))}" (${columnNames.join(",")}, operation, checkpoint)
+  INSERT INTO "${schema}"."${getReorgTableName(table)}" (${columnNames.join(",")}, operation, checkpoint)
   VALUES (${columnNames.map((name) => `OLD.${name}`).join(",")}, 2, '${MAX_CHECKPOINT_STRING}');
   END IF;
   RETURN NULL;
@@ -80,9 +97,9 @@ export const createTriggers = async (
           await tx.wrap({ label: "create_trigger" }, (tx) =>
             tx.execute(
               `
-  CREATE OR REPLACE TRIGGER "${getTableNames(table).trigger}"
-  AFTER INSERT OR UPDATE OR DELETE ON "${schema}"."${getTableName(table)}"
-  FOR EACH ROW EXECUTE FUNCTION "${schema}".${getTableNames(table).triggerFn};
+  CREATE OR REPLACE TRIGGER "${getReorgTriggerName()}"
+  AFTER INSERT OR UPDATE OR DELETE ON "${schema}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"
+  FOR EACH ROW EXECUTE FUNCTION "${schema}".${getReorgProcedureName(table)};
   `,
             ),
           );
@@ -96,7 +113,7 @@ export const createTriggers = async (
 
 export const dropTriggers = async (
   qb: QB,
-  { tables }: { tables: Table[] },
+  { tables, chainId }: { tables: Table[]; chainId?: number },
   context?: { logger?: Logger },
 ) => {
   await qb.transaction(
@@ -107,7 +124,7 @@ export const dropTriggers = async (
 
           await tx.wrap({ label: "drop_trigger" }, (tx) =>
             tx.execute(
-              `DROP TRIGGER IF EXISTS "${getTableNames(table).trigger}" ON "${schema}"."${getTableName(table)}"`,
+              `DROP TRIGGER IF EXISTS "${getReorgTriggerName()}" ON "${schema}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"`,
             ),
           );
         }),
@@ -118,6 +135,155 @@ export const dropTriggers = async (
   );
 };
 
+export const createLiveQueryTriggers = async (
+  qb: QB,
+  {
+    namespaceBuild,
+    tables,
+    chainId,
+  }: { namespaceBuild: NamespaceBuild; tables: Table[]; chainId?: number },
+  context?: { logger?: Logger },
+) => {
+  await qb.transaction(
+    async (tx) => {
+      const notifyProcedure = getLiveQueryNotifyProcedureName();
+      const notifyTrigger = getLiveQueryNotifyTriggerName();
+
+      await tx.wrap((tx) =>
+        tx.execute(
+          `
+CREATE OR REPLACE TRIGGER "${notifyTrigger}"
+AFTER INSERT OR UPDATE OR DELETE
+ON "${namespaceBuild.schema}"._ponder_checkpoint
+FOR EACH STATEMENT
+EXECUTE PROCEDURE "${namespaceBuild.schema}".${notifyProcedure};`,
+        ),
+      );
+
+      const trigger = getLiveQueryTriggerName();
+      const procedure = getLiveQueryProcedureName();
+
+      for (const table of tables) {
+        const schema = getTableConfig(table).schema ?? "public";
+
+        await tx.wrap((tx) =>
+          tx.execute(
+            `
+CREATE OR REPLACE TRIGGER "${trigger}"
+AFTER INSERT OR UPDATE OR DELETE
+ON "${schema}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"
+FOR EACH STATEMENT
+EXECUTE PROCEDURE "${schema}".${procedure};`,
+          ),
+        );
+      }
+    },
+    undefined,
+    context,
+  );
+};
+
+export const dropLiveQueryTriggers = async (
+  qb: QB,
+  {
+    namespaceBuild,
+    tables,
+    chainId,
+  }: { namespaceBuild: NamespaceBuild; tables: Table[]; chainId?: number },
+  context?: { logger?: Logger },
+) => {
+  await qb.transaction(
+    async (tx) => {
+      const notifyTrigger = getLiveQueryNotifyTriggerName();
+      await tx.wrap((tx) =>
+        tx.execute(
+          `DROP TRIGGER IF EXISTS "${notifyTrigger}" ON "${namespaceBuild.schema}"._ponder_checkpoint;`,
+        ),
+      );
+
+      const trigger = getLiveQueryTriggerName();
+      for (const table of tables) {
+        const schema = getTableConfig(table).schema ?? "public";
+
+        await tx.wrap((tx) =>
+          tx.execute(
+            `DROP TRIGGER IF EXISTS "${trigger}" ON "${schema}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}";`,
+          ),
+        );
+      }
+    },
+    undefined,
+    context,
+  );
+};
+
+export const createLiveQueryProcedures = async (
+  qb: QB,
+  { namespaceBuild }: { namespaceBuild: NamespaceBuild },
+  context?: { logger?: Logger },
+) => {
+  await qb.transaction(
+    async (tx) => {
+      const schema = namespaceBuild.schema;
+      const procedure = getLiveQueryProcedureName();
+
+      await tx.wrap(
+        (tx) =>
+          tx.execute(
+            `
+CREATE OR REPLACE FUNCTION "${schema}".${procedure}
+RETURNS TRIGGER LANGUAGE plpgsql
+AS $$
+BEGIN
+  INSERT INTO live_query_tables (table_name)
+  VALUES (TG_TABLE_NAME)
+  ON CONFLICT (table_name) DO NOTHING;
+  RETURN NULL;
+END;
+$$;`,
+          ),
+        context,
+      );
+
+      const notifyProcedure = getLiveQueryNotifyProcedureName();
+      const channel = getLiveQueryChannelName(namespaceBuild.schema);
+
+      await tx.wrap(
+        (tx) =>
+          tx.execute(`
+CREATE OR REPLACE FUNCTION "${schema}".${notifyProcedure}
+RETURNS TRIGGER LANGUAGE plpgsql
+AS $$
+  DECLARE
+    table_names json;
+    table_exists boolean := false;
+  BEGIN
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.tables
+      WHERE table_name = 'live_query_tables'
+      AND table_type = 'LOCAL TEMPORARY'
+    ) INTO table_exists;
+
+    IF table_exists THEN
+      SELECT json_agg(table_name) INTO table_names
+      FROM live_query_tables;
+
+      table_names := COALESCE(table_names, '[]'::json);
+      PERFORM pg_notify('${channel}', table_names::text);
+    END IF;
+
+    RETURN NULL;
+  END;
+$$;`),
+        context,
+      );
+    },
+    undefined,
+    context,
+  );
+};
+
 export const createViews = async (
   qb: QB,
   {
@@ -191,30 +357,51 @@ export const createViews = async (
         ),
       );
 
-      const trigger = `status_${namespaceBuild.viewsSchema}_trigger`;
-      const notification = "status_notify()";
-      const channel = `${namespaceBuild.viewsSchema}_status_channel`;
+      const notifyProcedure = getLiveQueryNotifyProcedureName();
+      const channel = getLiveQueryChannelName(namespaceBuild.viewsSchema!);
 
       await tx.wrap((tx) =>
         tx.execute(`
-CREATE OR REPLACE FUNCTION "${namespaceBuild.viewsSchema}".${notification}
-RETURNS TRIGGER
-LANGUAGE plpgsql
+CREATE OR REPLACE FUNCTION "${namespaceBuild.viewsSchema}".${notifyProcedure}
+RETURNS TRIGGER LANGUAGE plpgsql
 AS $$
-BEGIN
-NOTIFY "${channel}";
-RETURN NULL;
-END;
+  DECLARE
+    table_names json;
+    table_exists boolean := false;
+  BEGIN
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.tables
+      WHERE table_name = 'live_query_tables'
+      AND table_type = 'LOCAL TEMPORARY'
+    ) INTO table_exists;
+
+    IF table_exists THEN
+      SELECT json_agg(table_name) INTO table_names
+      FROM live_query_tables;
+
+      table_names := COALESCE(table_names, '[]'::json);
+      PERFORM pg_notify('${channel}', table_names::text);
+    END IF;
+
+    RETURN NULL;
+  END;
 $$;`),
       );
 
+      const trigger = getViewsLiveQueryNotifyTriggerName(
+        namespaceBuild.viewsSchema,
+      );
+
       await tx.wrap((tx) =>
-        tx.execute(`
+        tx.execute(
+          `
 CREATE OR REPLACE TRIGGER "${trigger}"
 AFTER INSERT OR UPDATE OR DELETE
-ON "${namespaceBuild.schema}"._ponder_checkpoint
+ON "${namespaceBuild.schema!}"._ponder_checkpoint
 FOR EACH STATEMENT
-EXECUTE PROCEDURE "${namespaceBuild.viewsSchema}".${notification};`),
+EXECUTE PROCEDURE "${namespaceBuild.viewsSchema}".${notifyProcedure};`,
+        ),
       );
     },
     undefined,
@@ -222,16 +409,65 @@ EXECUTE PROCEDURE "${namespaceBuild.viewsSchema}".${notification};`),
   );
 };
 
-export const revert = async (
+export const revertOmnichain = async (
+  qb: QB,
+  {
+    checkpoint,
+    tables,
+  }: {
+    checkpoint: string;
+    tables: Table[];
+  },
+  context?: { logger?: Logger },
+): Promise<number[]> => {
+  if (tables.length === 0) return [];
+
+  return qb.transaction(
+    { label: "revert" },
+    async (tx) => {
+      const counts: number[] = [];
+
+      for (const table of tables) {
+        const primaryKeyColumns = getPrimaryKeyColumns(table);
+        const schema = getTableConfig(table).schema ?? "public";
+
+        const result = await tx.wrap((tx) =>
+          tx.execute(`
+WITH reverted1 AS (
+  DELETE FROM "${schema}"."${getReorgTableName(table)}"
+  WHERE checkpoint > '${checkpoint}' RETURNING * 
+), reverted2 AS (
+  SELECT ${primaryKeyColumns.map(({ sql }) => `"${sql}"`).join(", ")}, MIN(operation_id) AS operation_id FROM reverted1
+  GROUP BY ${primaryKeyColumns.map(({ sql }) => `"${sql}"`).join(", ")}
+), reverted3 AS (
+  SELECT ${Object.values(getTableColumns(table))
+    .map((column) => `reverted1."${getColumnCasing(column, "snake_case")}"`)
+    .join(", ")}, reverted1.operation FROM reverted2
+  INNER JOIN reverted1
+  ON ${primaryKeyColumns.map(({ sql }) => `reverted2."${sql}" = reverted1."${sql}"`).join("AND ")}
+  AND reverted2.operation_id = reverted1.operation_id
+), ${getRevertSql({ table })};`),
+        );
+
+        // @ts-ignore
+        counts.push(result.rows[0]!.count);
+      }
+
+      return counts;
+    },
+    undefined,
+    context,
+  );
+};
+
+export const revertMultichain = async (
   qb: QB,
   {
     checkpoint,
     tables,
-    preBuild,
   }: {
     checkpoint: string;
     tables: Table[];
-    preBuild: Pick<PreBuild, "ordering">;
   },
   context?: { logger?: Logger },
 ): Promise<number[]> => {
@@ -241,33 +477,33 @@ export const revert = async (
     { label: "revert" },
     async (tx) => {
       const counts: number[] = [];
-      if (preBuild.ordering === "multichain") {
-        const minOperationId = await tx
-          .wrap((tx) =>
-            tx.execute(`
+
+      const minOperationId = await tx
+        .wrap((tx) =>
+          tx.execute(`
 SELECT MIN(operation_id) AS operation_id FROM (
 ${tables
   .map(
     (table) => `
-SELECT MIN(operation_id) AS operation_id FROM "${getTableConfig(table).schema ?? "public"}"."${getTableName(getReorgTable(table))}"
+SELECT MIN(operation_id) AS operation_id FROM "${getTableConfig(table).schema ?? "public"}"."${getReorgTableName(table)}"
 WHERE SUBSTRING(checkpoint, 11, 16)::numeric = ${String(decodeCheckpoint(checkpoint).chainId)}
 AND checkpoint > '${checkpoint}'`,
   )
   .join(" UNION ALL ")}) AS all_mins;`),
-          )
-          .then((result) => {
-            // @ts-ignore
-            return result.rows[0]?.operation_id as string | null;
-          });
-
-        for (const table of tables) {
-          const primaryKeyColumns = getPrimaryKeyColumns(table);
-          const schema = getTableConfig(table).schema ?? "public";
+        )
+        .then((result) => {
+          // @ts-ignore
+          return result.rows[0]?.operation_id as string | null;
+        });
 
-          const result = await tx.wrap((tx) =>
-            tx.execute(`
+      for (const table of tables) {
+        const primaryKeyColumns = getPrimaryKeyColumns(table);
+        const schema = getTableConfig(table).schema ?? "public";
+
+        const result = await tx.wrap((tx) =>
+          tx.execute(`
 WITH reverted1 AS (
-  DELETE FROM "${schema}"."${getTableName(getReorgTable(table))}"
+  DELETE FROM "${schema}"."${getReorgTableName(table)}"
   WHERE ${minOperationId!} IS NOT NULL AND operation_id >= ${minOperationId!}
   RETURNING * 
 ), reverted2 AS (
@@ -281,21 +517,46 @@ WITH reverted1 AS (
   ON ${primaryKeyColumns.map(({ sql }) => `reverted2."${sql}" = reverted1."${sql}"`).join("AND ")}
   AND reverted2.operation_id = reverted1.operation_id
 ), ${getRevertSql({ table })};`),
-          );
+        );
 
-          // @ts-ignore
-          counts.push(result.rows[0]!.count);
-        }
-      } else {
-        for (const table of tables) {
-          const primaryKeyColumns = getPrimaryKeyColumns(table);
-          const schema = getTableConfig(table).schema ?? "public";
+        // @ts-ignore
+        counts.push(result.rows[0]!.count);
+      }
+
+      return counts;
+    },
+    undefined,
+    context,
+  );
+};
+
+export const revertIsolated = async (
+  qb: QB,
+  {
+    checkpoint,
+    tables,
+  }: {
+    checkpoint: string;
+    tables: Table[];
+  },
+  context?: { logger?: Logger },
+) => {
+  if (tables.length === 0) return [];
+
+  return qb.transaction(
+    { label: "revert" },
+    async (tx) => {
+      const counts: number[] = [];
+
+      for (const table of tables) {
+        const primaryKeyColumns = getPrimaryKeyColumns(table);
+        const schema = getTableConfig(table).schema ?? "public";
 
-          const result = await tx.wrap((tx) =>
-            tx.execute(`
+        const result = await tx.wrap((tx) =>
+          tx.execute(`
 WITH reverted1 AS (
-  DELETE FROM "${schema}"."${getTableName(getReorgTable(table))}"
-  WHERE checkpoint > '${checkpoint}' RETURNING * 
+  DELETE FROM "${schema}"."${getReorgTableName(table)}"
+  WHERE checkpoint > '${checkpoint}' AND SUBSTRING(checkpoint, 11, 16)::numeric = ${String(decodeCheckpoint(checkpoint).chainId)} RETURNING * 
 ), reverted2 AS (
   SELECT ${primaryKeyColumns.map(({ sql }) => `"${sql}"`).join(", ")}, MIN(operation_id) AS operation_id FROM reverted1
   GROUP BY ${primaryKeyColumns.map(({ sql }) => `"${sql}"`).join(", ")}
@@ -307,11 +568,10 @@ WITH reverted1 AS (
   ON ${primaryKeyColumns.map(({ sql }) => `reverted2."${sql}" = reverted1."${sql}"`).join("AND ")}
   AND reverted2.operation_id = reverted1.operation_id
 ), ${getRevertSql({ table })};`),
-          );
+        );
 
-          // @ts-ignore
-          counts.push(result.rows[0]!.count);
-        }
+        // @ts-ignore
+        counts.push(result.rows[0]!.count);
       }
 
       return counts;
@@ -321,23 +581,22 @@ WITH reverted1 AS (
   );
 };
 
-export const finalize = async (
+export const finalizeOmnichain = async (
   qb: QB,
   {
     checkpoint,
     tables,
-    preBuild,
     namespaceBuild,
   }: {
     checkpoint: string;
     tables: Table[];
-    preBuild: Pick<PreBuild, "ordering">;
     namespaceBuild: NamespaceBuild;
   },
   context?: { logger?: Logger },
-): Promise<void> => {
+) => {
   const PONDER_CHECKPOINT = getPonderCheckpointTable(namespaceBuild.schema);
 
+  // TODO(kyle) is this breaking an invariant?
   if (tables.length === 0) {
     await qb.wrap(
       (db) =>
@@ -349,27 +608,76 @@ export const finalize = async (
     return;
   }
 
-  // NOTE: It is invariant that PONDER_CHECKPOINT has a value for each chain.
-
   return qb.transaction(
     { label: "finalize" },
     async (tx) => {
-      if (preBuild.ordering === "multichain") {
+      await tx.wrap((tx) =>
+        tx.update(PONDER_CHECKPOINT).set({
+          finalizedCheckpoint: checkpoint,
+          safeCheckpoint: checkpoint,
+        }),
+      );
+
+      for (const table of tables) {
         await tx.wrap((tx) =>
           tx
-            .update(PONDER_CHECKPOINT)
-            .set({ finalizedCheckpoint: checkpoint })
-            .where(
-              eq(
-                PONDER_CHECKPOINT.chainId,
-                Number(decodeCheckpoint(checkpoint).chainId),
-              ),
-            ),
+            .delete(getReorgTable(table))
+            .where(lte(getReorgTable(table).checkpoint, checkpoint)),
         );
+      }
+    },
+    undefined,
+    context,
+  );
+};
 
-        const minOperationId = await tx
-          .wrap((tx) =>
-            tx.execute(`
+export const finalizeMultichain = async (
+  qb: QB,
+  {
+    checkpoint,
+    tables,
+    namespaceBuild,
+  }: {
+    checkpoint: string;
+    tables: Table[];
+    namespaceBuild: NamespaceBuild;
+  },
+  context?: { logger?: Logger },
+) => {
+  const PONDER_CHECKPOINT = getPonderCheckpointTable(namespaceBuild.schema);
+
+  // TODO(kyle) is this breaking an invariant?
+  if (tables.length === 0) {
+    await qb.wrap(
+      (db) =>
+        db
+          .update(PONDER_CHECKPOINT)
+          .set({ finalizedCheckpoint: checkpoint, safeCheckpoint: checkpoint }),
+      context,
+    );
+    return;
+  }
+
+  // NOTE: It is invariant that PONDER_CHECKPOINT has a value for each chain.
+
+  return qb.transaction(
+    { label: "finalize" },
+    async (tx) => {
+      await tx.wrap((tx) =>
+        tx
+          .update(PONDER_CHECKPOINT)
+          .set({ finalizedCheckpoint: checkpoint })
+          .where(
+            eq(
+              PONDER_CHECKPOINT.chainId,
+              Number(decodeCheckpoint(checkpoint).chainId),
+            ),
+          ),
+      );
+
+      const minOperationId = await tx
+        .wrap((tx) =>
+          tx.execute(`
 SELECT MIN(operation_id) AS operation_id FROM (
 ${tables
   .map(
@@ -382,14 +690,14 @@ WHERE checkpoint > (
 )`,
   )
   .join(" UNION ALL ")}) AS all_mins;`),
-          )
-          .then((result) => {
-            // @ts-ignore
-            return result.rows[0]?.operation_id as string | null;
-          });
+        )
+        .then((result) => {
+          // @ts-ignore
+          return result.rows[0]?.operation_id as string | null;
+        });
 
-        const result = await tx.wrap((tx) =>
-          tx.execute(`
+      const result = await tx.wrap((tx) =>
+        tx.execute(`
     WITH ${tables
       .map(
         (table, index) => `
@@ -405,39 +713,18 @@ WHERE checkpoint > (
         .map((_, index) => `SELECT checkpoint FROM deleted_${index}`)
         .join(" UNION ALL ")}
     )
-    SELECT MAX(checkpoint) as safe_checkpoint, SUBSTRING(checkpoint, 11, 16)::numeric as chain_id, COUNT(*) AS deleted_count 
+    SELECT MAX(checkpoint) as safe_checkpoint, SUBSTRING(checkpoint, 11, 16)::numeric as chain_id
     FROM all_deleted
     GROUP BY SUBSTRING(checkpoint, 11, 16)::numeric;`),
-        );
+      );
 
-        for (const { chain_id, safe_checkpoint } of result.rows) {
-          await tx.wrap((tx) =>
-            tx
-              .update(PONDER_CHECKPOINT)
-              .set({ safeCheckpoint: safe_checkpoint as string })
-              .where(eq(PONDER_CHECKPOINT.chainId, chain_id as number)),
-          );
-        }
-      } else {
+      for (const { chain_id, safe_checkpoint } of result.rows) {
         await tx.wrap((tx) =>
-          tx.update(PONDER_CHECKPOINT).set({
-            finalizedCheckpoint: checkpoint,
-            safeCheckpoint: checkpoint,
-          }),
+          tx
+            .update(PONDER_CHECKPOINT)
+            .set({ safeCheckpoint: safe_checkpoint as string })
+            .where(eq(PONDER_CHECKPOINT.chainId, chain_id as number)),
         );
-
-        for (const table of tables) {
-          await tx
-            .wrap((tx) =>
-              tx.execute(`
-WITH deleted AS (
-  DELETE FROM "${getTableConfig(table).schema ?? "public"}"."${getTableName(getReorgTable(table))}"
-  WHERE checkpoint <= '${checkpoint}'
-  RETURNING *
-) SELECT COUNT(*) AS deleted_count FROM deleted;`),
-            )
-            .then((result) => Number(result.rows[0]!.deleted_count));
-        }
       }
     },
     undefined,
@@ -445,19 +732,81 @@ WITH deleted AS (
   );
 };
 
+export const finalizeIsolated = async (
+  qb: QB,
+  {
+    checkpoint,
+    tables,
+    namespaceBuild,
+  }: {
+    checkpoint: string;
+    tables: Table[];
+    namespaceBuild: NamespaceBuild;
+  },
+  context?: { logger?: Logger },
+) => {
+  const PONDER_CHECKPOINT = getPonderCheckpointTable(namespaceBuild.schema);
+  const chainId = Number(decodeCheckpoint(checkpoint).chainId);
+
+  if (tables.length === 0) {
+    await qb.wrap(
+      (db) =>
+        db
+          .update(PONDER_CHECKPOINT)
+          .set({ finalizedCheckpoint: checkpoint, safeCheckpoint: checkpoint })
+          .where(eq(PONDER_CHECKPOINT.chainId, chainId)),
+      context,
+    );
+    return;
+  }
+  return qb.transaction({ label: "finalize" }, async (tx) => {
+    await tx.wrap((tx) =>
+      tx
+        .update(PONDER_CHECKPOINT)
+        .set({ finalizedCheckpoint: checkpoint, safeCheckpoint: checkpoint })
+        .where(eq(PONDER_CHECKPOINT.chainId, chainId)),
+    );
+
+    for (const table of tables) {
+      await tx.wrap((tx) =>
+        tx
+          .delete(getReorgTable(table))
+          .where(
+            and(
+              lte(getReorgTable(table).checkpoint, checkpoint),
+              eq(sql`chain_id`, chainId),
+            ),
+          ),
+      );
+    }
+  });
+};
+
 export const commitBlock = async (
   qb: QB,
-  { checkpoint, table }: { checkpoint: string; table: Table },
+  {
+    checkpoint,
+    table,
+    preBuild,
+  }: { checkpoint: string; table: Table; preBuild: Pick<PreBuild, "ordering"> },
   context?: { logger?: Logger },
 ) => {
   const reorgTable = getReorgTable(table);
+  let whereClause: SQL;
+  if (preBuild.ordering === "experimental_isolated") {
+    // Note: Query must include `chain_id` because it's possible for multiple chains to be indexing in parallel.
+    const chainId = Number(decodeCheckpoint(checkpoint).chainId);
+    whereClause = and(
+      eq(reorgTable.checkpoint, MAX_CHECKPOINT_STRING),
+      eq(sql`chain_id`, chainId),
+    )!;
+  } else {
+    whereClause = eq(reorgTable.checkpoint, MAX_CHECKPOINT_STRING);
+  }
+
   await qb.wrap(
     { label: "commit_block" },
-    (db) =>
-      db
-        .update(reorgTable)
-        .set({ checkpoint })
-        .where(eq(reorgTable.checkpoint, MAX_CHECKPOINT_STRING)),
+    (db) => db.update(reorgTable).set({ checkpoint }).where(whereClause),
     context,
   );
 };