envio 2.32.3 → 3.0.0-alpha.0

package/src/db/EntityHistory.res

@@ -5,41 +5,47 @@ module RowAction = {
   let variants = [SET, DELETE]
   let name = "ENVIO_HISTORY_CHANGE"
   let schema = S.enum(variants)
-}
-
-type entityUpdateAction<'entityType> =
-  | Set('entityType)
-  | Delete
-
-type entityUpdate<'entityType> = {
-  entityId: string,
-  entityUpdateAction: entityUpdateAction<'entityType>,
-  checkpointId: int,
+  let config: Table.enumConfig<t> = {
+    name,
+    variants,
+    schema,
+  }
 }
 
 // Prefix with envio_ to avoid colleasions
 let changeFieldName = "envio_change"
-let checkpointIdFieldName = "checkpoint_id"
+let checkpointIdFieldName = "envio_checkpoint_id"
+let checkpointIdFieldType = Uint32
+let changeFieldType = Enum({config: RowAction.config->Table.fromGenericEnumConfig})
+
+let unsafeCheckpointIdSchema =
+  S.string
+  ->S.setName("CheckpointId")
+  ->S.transform(s => {
+    parser: string =>
+      switch string->Belt.Float.fromString {
+      | Some(float) => float
+      | None => s.fail("The string is not valid CheckpointId")
+      },
+    serializer: float => float->Belt.Float.toString,
+  })
 
-let makeSetUpdateSchema: S.t<'entity> => S.t<entityUpdate<'entity>> = entitySchema => {
+let makeSetUpdateSchema: S.t<'entity> => S.t<Change.t<'entity>> = entitySchema => {
   S.object(s => {
     s.tag(changeFieldName, RowAction.SET)
-    {
-      checkpointId: s.field(checkpointIdFieldName, S.int),
-      entityId: s.field("id", S.string),
-      entityUpdateAction: Set(s.flatten(entitySchema)),
-    }
+    Change.Set({
+      checkpointId: s.field(checkpointIdFieldName, unsafeCheckpointIdSchema),
+      entityId: s.field(Table.idFieldName, S.string),
+      entity: s.flatten(entitySchema),
+    })
   })
 }
 
-type t<'entity> = {
-  table: table,
-  setUpdateSchema: S.t<entityUpdate<'entity>>,
+type pgEntityHistory<'entity> = {
+  table: Table.table,
+  setChangeSchema: S.t<Change.t<'entity>>,
   // Used for parsing
-  setUpdateSchemaRows: S.t<array<entityUpdate<'entity>>>,
-  makeInsertDeleteUpdatesQuery: (~pgSchema: string) => string,
-  makeGetRollbackRemovedIdsQuery: (~pgSchema: string) => string,
-  makeGetRollbackRestoredEntitiesQuery: (~pgSchema: string) => string,
+  setChangeSchemaRows: S.t<array<Change.t<'entity>>>,
 }
 
 let maxPgTableNameLength = 63
@@ -55,120 +61,6 @@ let historyTableName = (~entityName, ~entityIndex) => {
   }
 }
 
-let fromTable = (table: table, ~schema: S.t<'entity>, ~entityIndex): t<'entity> => {
-  let id = "id"
-
-  let dataFields = table.fields->Belt.Array.keepMap(field =>
-    switch field {
-    | Field(field) =>
-      switch field.fieldName {
-      //id is not nullable and should be part of the pk
-      | "id" => {...field, fieldName: id, isPrimaryKey: true}->Field->Some
-      | _ =>
-        {
-          ...field,
-          isNullable: true, //All entity fields are nullable in the case
-          isIndex: false, //No need to index any additional entity data fields in entity history
-        }
-        ->Field
-        ->Some
-      }
-
-    | DerivedFrom(_) => None
-    }
-  )
-
-  let actionField = mkField(changeFieldName, Custom(RowAction.name), ~fieldSchema=S.never)
-
-  let checkpointIdField = mkField(
-    checkpointIdFieldName,
-    Integer,
-    ~fieldSchema=S.int,
-    ~isPrimaryKey=true,
-  )
-
-  let entityTableName = table.tableName
-  let historyTableName = historyTableName(~entityName=entityTableName, ~entityIndex)
-  //ignore composite indices
-  let table = mkTable(
-    historyTableName,
-    ~fields=dataFields->Belt.Array.concat([checkpointIdField, actionField]),
-  )
-
-  let setUpdateSchema = makeSetUpdateSchema(schema)
-
-  let makeInsertDeleteUpdatesQuery = {
-    // Get all field names for the INSERT statement
-    let allFieldNames = table.fields->Belt.Array.map(field => field->getFieldName)
-    let allFieldNamesStr =
-      allFieldNames->Belt.Array.map(name => `"${name}"`)->Js.Array2.joinWith(", ")
-
-    // Build the SELECT part: id from unnest, checkpoint_id from unnest, 'DELETE' for action, NULL for all other fields
-    let selectParts = allFieldNames->Belt.Array.map(fieldName => {
-      switch fieldName {
-      | "id" => "u.id"
-      | field if field == checkpointIdFieldName => "u.checkpoint_id"
-      | field if field == changeFieldName => "'DELETE'"
-      | _ => "NULL"
-      }
-    })
-    let selectPartsStr = selectParts->Js.Array2.joinWith(", ")
-    (~pgSchema) => {
-      `INSERT INTO "${pgSchema}"."${historyTableName}" (${allFieldNamesStr})
-SELECT ${selectPartsStr}
-FROM UNNEST($1::text[], $2::int[]) AS u(id, checkpoint_id)`
-    }
-  }
-
-  // Get data field names for rollback queries (exclude changeFieldName and checkpointIdFieldName)
-  let dataFieldNames =
-    table.fields
-    ->Belt.Array.map(field => field->getFieldName)
-    ->Belt.Array.keep(fieldName =>
-      fieldName != changeFieldName && fieldName != checkpointIdFieldName
-    )
-  let dataFieldsCommaSeparated =
-    dataFieldNames->Belt.Array.map(name => `"${name}"`)->Js.Array2.joinWith(", ")
-
-  // Returns entity IDs that were created after the rollback target and have no history before it.
-  // These entities should be deleted during rollback.
-  let makeGetRollbackRemovedIdsQuery = (~pgSchema) => {
-    `SELECT DISTINCT id
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${checkpointIdFieldName}" > $1
-  AND NOT EXISTS (
-    SELECT 1
-    FROM "${pgSchema}"."${historyTableName}" h
-    WHERE h.id = "${historyTableName}".id
-      AND h."${checkpointIdFieldName}" <= $1
-  )`
-  }
-
-  // Returns the most recent entity state for IDs that need to be restored during rollback.
-  // For each ID modified after the rollback target, retrieves its latest state at or before the target.
-  let makeGetRollbackRestoredEntitiesQuery = (~pgSchema) => {
-    `SELECT DISTINCT ON (id) ${dataFieldsCommaSeparated}
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${checkpointIdFieldName}" <= $1
-  AND EXISTS (
-    SELECT 1
-    FROM "${pgSchema}"."${historyTableName}" h
-    WHERE h.id = "${historyTableName}".id
-      AND h."${checkpointIdFieldName}" > $1
-  )
-ORDER BY id, "${checkpointIdFieldName}" DESC`
-  }
-
-  {
-    table,
-    setUpdateSchema,
-    setUpdateSchemaRows: S.array(setUpdateSchema),
-    makeInsertDeleteUpdatesQuery,
-    makeGetRollbackRemovedIdsQuery,
-    makeGetRollbackRestoredEntitiesQuery,
-  }
-}
-
 type safeReorgBlocks = {
   chainIds: array<int>,
   blockNumbers: array<int>,
@@ -225,11 +117,11 @@ let pruneStaleEntityHistory = (
 }
 
 // If an entity doesn't have a history before the update
-// we create it automatically with checkpoint_id 0
+// we create it automatically with envio_checkpoint_id 0
 let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   `WITH target_ids AS (
-  SELECT UNNEST($1::${(Text: Table.fieldType :> string)}[]) AS id
+  SELECT UNNEST($1::${(Text: Postgres.columnType :> string)}[]) AS id
 ),
 missing_history AS (
   SELECT e.*
@@ -252,22 +144,7 @@ let backfillHistory = (sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<st
   ->Promise.ignoreValue
 }
 
-let insertDeleteUpdates = (
-  sql,
-  ~pgSchema,
-  ~entityHistory,
-  ~batchDeleteEntityIds,
-  ~batchDeleteCheckpointIds,
-) => {
-  sql
-  ->Postgres.preparedUnsafe(
-    entityHistory.makeInsertDeleteUpdatesQuery(~pgSchema),
-    (batchDeleteEntityIds, batchDeleteCheckpointIds)->Obj.magic,
-  )
-  ->Promise.ignoreValue
-}
-
-let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: int) => {
+let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: float) => {
   sql
   ->Postgres.preparedUnsafe(
     `DELETE FROM "${pgSchema}"."${historyTableName(

package/src/db/EntityHistory.res.mjs

@@ -0,0 +1,121 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./Table.res.mjs";
+import * as Js_string from "rescript/lib/es6/js_string.js";
+import * as Belt_Float from "rescript/lib/es6/belt_Float.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var variants = [
+  "SET",
+  "DELETE"
+];
+
+var name = "ENVIO_HISTORY_CHANGE";
+
+var schema = S$RescriptSchema.$$enum(variants);
+
+var config = {
+  name: name,
+  variants: variants,
+  schema: schema
+};
+
+var RowAction = {
+  variants: variants,
+  name: name,
+  schema: schema,
+  config: config
+};
+
+var changeFieldName = "envio_change";
+
+var checkpointIdFieldName = "envio_checkpoint_id";
+
+var changeFieldType = {
+  type: "Enum",
+  config: config
+};
+
+var unsafeCheckpointIdSchema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "CheckpointId"), (function (s) {
+        return {
+                p: (function (string) {
+                    var $$float = Belt_Float.fromString(string);
+                    if ($$float !== undefined) {
+                      return $$float;
+                    } else {
+                      return s.fail("The string is not valid CheckpointId", undefined);
+                    }
+                  }),
+                s: (function ($$float) {
+                    return String($$float);
+                  })
+              };
+      }));
+
+function makeSetUpdateSchema(entitySchema) {
+  return S$RescriptSchema.object(function (s) {
+              s.tag(changeFieldName, "SET");
+              return {
+                      type: "SET",
+                      entityId: s.f(Table.idFieldName, S$RescriptSchema.string),
+                      entity: s.flatten(entitySchema),
+                      checkpointId: s.f(checkpointIdFieldName, unsafeCheckpointIdSchema)
+                    };
+            });
+}
+
+var historyTablePrefix = "envio_history_";
+
+function historyTableName(entityName, entityIndex) {
+  var fullName = historyTablePrefix + entityName;
+  if (fullName.length <= 63) {
+    return fullName;
+  }
+  var entityIndexStr = String(entityIndex);
+  return Js_string.slice(0, 63 - entityIndexStr.length | 0, fullName) + entityIndexStr;
+}
+
+function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema) {
+  var historyTableRef = "\"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\"";
+  return "WITH anchors AS (\n  SELECT t.id, MAX(t." + checkpointIdFieldName + ") AS keep_checkpoint_id\n  FROM " + historyTableRef + " t WHERE t." + checkpointIdFieldName + " <= $1\n  GROUP BY t.id\n)\nDELETE FROM " + historyTableRef + " d\nUSING anchors a\nWHERE d.id = a.id\n  AND (\n    d." + checkpointIdFieldName + " < a.keep_checkpoint_id\n    OR (\n      d." + checkpointIdFieldName + " = a.keep_checkpoint_id AND\n      NOT EXISTS (\n        SELECT 1 FROM " + historyTableRef + " ps \n        WHERE ps.id = d.id AND ps." + checkpointIdFieldName + " > $1\n      ) \n    )\n  );";
+}
+
+function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId) {
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId], {prepare: true});
+}
+
+function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
+  var historyTableRef = "\"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\"";
+  return "WITH target_ids AS (\n  SELECT UNNEST($1::TEXT[]) AS id\n),\nmissing_history AS (\n  SELECT e.*\n  FROM \"" + pgSchema + "\".\"" + entityName + "\" e\n  JOIN target_ids t ON e.id = t.id\n  LEFT JOIN " + historyTableRef + " h ON h.id = e.id\n  WHERE h.id IS NULL\n)\nINSERT INTO " + historyTableRef + "\nSELECT *, 0 AS " + checkpointIdFieldName + ", '" + "SET" + "' as " + changeFieldName + "\nFROM missing_history;";
+}
+
+function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
+  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName, entityIndex), [ids], {prepare: true});
+}
+
+function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
+  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId], {prepare: true});
+}
+
+var checkpointIdFieldType = "Uint32";
+
+var maxPgTableNameLength = 63;
+
+export {
+  RowAction ,
+  changeFieldName ,
+  checkpointIdFieldName ,
+  checkpointIdFieldType ,
+  changeFieldType ,
+  unsafeCheckpointIdSchema ,
+  makeSetUpdateSchema ,
+  maxPgTableNameLength ,
+  historyTablePrefix ,
+  historyTableName ,
+  makePruneStaleEntityHistoryQuery ,
+  pruneStaleEntityHistory ,
+  makeBackfillHistoryQuery ,
+  backfillHistory ,
+  rollback ,
+}
+/* schema Not a pure module */

package/src/db/InternalTable.gen.ts

@@ -3,9 +3,9 @@
 /* eslint-disable */
 /* tslint:disable */
 
-import type {Json_t as Js_Json_t} from '../../src/Js.shim';
+import type {Json_t as Js_Json_t} from '../../src/Js.shim.js';
 
-import type {t as Address_t} from '../../src/Address.gen';
+import type {t as Address_t} from '../../src/Address.gen.js';
 
 export type DynamicContractRegistry_t = {
   readonly id: string; 

package/src/db/InternalTable.res

@@ -46,21 +46,19 @@ module DynamicContractRegistry = {
   let table = mkTable(
     name,
     ~fields=[
-      mkField("id", Text, ~isPrimaryKey, ~fieldSchema=S.string),
-      mkField("chain_id", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_block_number", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_log_index", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_block_timestamp", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_contract_name", Text, ~fieldSchema=S.string),
-      mkField("registering_event_name", Text, ~fieldSchema=S.string),
-      mkField("registering_event_src_address", Text, ~fieldSchema=Address.schema),
-      mkField("contract_address", Text, ~fieldSchema=Address.schema),
-      mkField("contract_name", Text, ~fieldSchema=S.string),
+      mkField("id", String, ~isPrimaryKey, ~fieldSchema=S.string),
+      mkField("chain_id", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_block_number", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_log_index", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_block_timestamp", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_contract_name", String, ~fieldSchema=S.string),
+      mkField("registering_event_name", String, ~fieldSchema=S.string),
+      mkField("registering_event_src_address", String, ~fieldSchema=Address.schema),
+      mkField("contract_address", String, ~fieldSchema=Address.schema),
+      mkField("contract_name", String, ~fieldSchema=S.string),
     ],
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema, ~entityIndex=index)
-
   external castToInternal: t => Internal.entity = "%identity"
 
   let config = {
@@ -69,7 +67,6 @@ module DynamicContractRegistry = {
     schema,
     rowsSchema,
     table,
-    entityHistory,
   }->Internal.fromGenericEntityConfig
 }
 
@@ -131,19 +128,19 @@ module Chains = {
   let table = mkTable(
     "envio_chains",
     ~fields=[
-      mkField((#id: field :> string), Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
       // Values populated from config
-      mkField((#start_block: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#end_block: field :> string), Integer, ~fieldSchema=S.null(S.int), ~isNullable),
-      mkField((#max_reorg_depth: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#start_block: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#end_block: field :> string), Int32, ~fieldSchema=S.null(S.int), ~isNullable),
+      mkField((#max_reorg_depth: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the latest block that was fetched from the source
-      mkField((#buffer_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#buffer_block: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the currently active source
-      mkField((#source_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#source_block: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the first event that was processed for this chain
       mkField(
         (#first_event_block: field :> string),
-        Integer,
+        Int32,
         ~fieldSchema=S.null(S.int),
         ~isNullable,
       ),
@@ -151,17 +148,17 @@ module Chains = {
       // null during historical sync, set to current time when sync is complete
       mkField(
         (#ready_at: field :> string),
-        TimestampWithNullTimezone,
+        Date,
         ~fieldSchema=S.null(Utils.Schema.dbDate),
         ~isNullable,
       ),
-      mkField((#events_processed: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
       // TODO: In the future it should reference a table with sources
       mkField((#_is_hyper_sync: field :> string), Boolean, ~fieldSchema=S.bool),
       // Fully processed block number
-      mkField((#progress_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#progress_block: field :> string), Int32, ~fieldSchema=S.int),
       // TODO: Should deprecate after changing the ETA calculation logic
-      mkField((#_num_batches_fetched: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#_num_batches_fetched: field :> string), Int32, ~fieldSchema=S.int),
     ],
   )
 
@@ -360,7 +357,6 @@ module PersistedState = {
     envio_version: string,
     config_hash: string,
     schema_hash: string,
-    handler_files_hash: string,
     abi_files_hash: string,
   }
 
@@ -368,11 +364,10 @@ module PersistedState = {
     "persisted_state",
     ~fields=[
       mkField("id", Serial, ~fieldSchema=S.int, ~isPrimaryKey),
-      mkField("envio_version", Text, ~fieldSchema=S.string),
-      mkField("config_hash", Text, ~fieldSchema=S.string),
-      mkField("schema_hash", Text, ~fieldSchema=S.string),
-      mkField("handler_files_hash", Text, ~fieldSchema=S.string),
-      mkField("abi_files_hash", Text, ~fieldSchema=S.string),
+      mkField("envio_version", String, ~fieldSchema=S.string),
+      mkField("config_hash", String, ~fieldSchema=S.string),
+      mkField("schema_hash", String, ~fieldSchema=S.string),
+      mkField("abi_files_hash", String, ~fieldSchema=S.string),
     ],
   )
 }
@@ -387,7 +382,7 @@ module Checkpoints = {
   ]
 
   type t = {
-    id: int,
+    id: float,
     @as("chain_id")
     chainId: int,
     @as("block_number")
@@ -398,16 +393,16 @@ module Checkpoints = {
     eventsProcessed: int,
   }
 
-  let initialCheckpointId = 0
+  let initialCheckpointId = 0.
 
   let table = mkTable(
     "envio_checkpoints",
     ~fields=[
-      mkField((#id: field :> string), Integer, ~fieldSchema=S.int, ~isPrimaryKey),
-      mkField((#chain_id: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#block_number: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#block_hash: field :> string), Text, ~fieldSchema=S.null(S.string), ~isNullable),
-      mkField((#events_processed: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#chain_id: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#block_hash: field :> string), String, ~fieldSchema=S.null(S.string), ~isNullable),
+      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
     ],
   )
 
@@ -438,12 +433,12 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
   }
 
   let makeCommitedCheckpointIdQuery = (~pgSchema) => {
-    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->Belt.Int.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
+    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->Belt.Float.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
   }
 
   let makeInsertCheckpointQuery = (~pgSchema) => {
     `INSERT INTO "${pgSchema}"."${table.tableName}" ("${(#id: field :> string)}", "${(#chain_id: field :> string)}", "${(#block_number: field :> string)}", "${(#block_hash: field :> string)}", "${(#events_processed: field :> string)}")
-SELECT * FROM unnest($1::${(Integer :> string)}[],$2::${(Integer :> string)}[],$3::${(Integer :> string)}[],$4::${(Text :> string)}[],$5::${(Integer :> string)}[]);`
+SELECT * FROM unnest($1::${(Integer: Postgres.columnType :> string)}[],$2::${(Integer: Postgres.columnType :> string)}[],$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
   }
 
   let insert = (
@@ -468,14 +463,14 @@ SELECT * FROM unnest($1::${(Integer :> string)}[],$2::${(Integer :> string)}[],$
         checkpointEventsProcessed,
       )->(
         Utils.magic: (
-          (array<int>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
+          (array<float>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
         ) => unknown
       ),
     )
     ->Promise.ignoreValue
   }
 
-  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: int) => {
+  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
     sql
     ->Postgres.preparedUnsafe(
       `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
@@ -488,7 +483,7 @@ SELECT * FROM unnest($1::${(Integer :> string)}[],$2::${(Integer :> string)}[],$
     `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" < $1;`
   }
 
-  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: int) => {
+  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: float) => {
     sql
     ->Postgres.preparedUnsafe(
       makePruneStaleCheckpointsQuery(~pgSchema),
@@ -517,7 +512,7 @@ LIMIT 1;`
       makeGetRollbackTargetCheckpointQuery(~pgSchema),
       (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
     )
-    ->(Utils.magic: promise<unknown> => promise<array<{"id": int}>>)
+    ->(Utils.magic: promise<unknown> => promise<array<{"id": Internal.checkpointId}>>)
   }
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
@@ -530,7 +525,11 @@ WHERE "${(#id: field :> string)}" > $1
 GROUP BY "${(#chain_id: field :> string)}";`
   }
 
-  let getRollbackProgressDiff = (sql, ~pgSchema, ~rollbackTargetCheckpointId: int) => {
+  let getRollbackProgressDiff = (
+    sql,
+    ~pgSchema,
+    ~rollbackTargetCheckpointId: Internal.checkpointId,
+  ) => {
     sql
     ->Postgres.preparedUnsafe(
       makeGetRollbackProgressDiffQuery(~pgSchema),
@@ -584,18 +583,18 @@ module RawEvents = {
   let table = mkTable(
     "raw_events",
     ~fields=[
-      mkField("chain_id", Integer, ~fieldSchema=S.int),
-      mkField("event_id", Numeric, ~fieldSchema=S.bigint),
-      mkField("event_name", Text, ~fieldSchema=S.string),
-      mkField("contract_name", Text, ~fieldSchema=S.string),
-      mkField("block_number", Integer, ~fieldSchema=S.int),
-      mkField("log_index", Integer, ~fieldSchema=S.int),
-      mkField("src_address", Text, ~fieldSchema=Address.schema),
-      mkField("block_hash", Text, ~fieldSchema=S.string),
-      mkField("block_timestamp", Integer, ~fieldSchema=S.int),
-      mkField("block_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
-      mkField("transaction_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
-      mkField("params", JsonB, ~fieldSchema=S.json(~validate=false)),
+      mkField("chain_id", Int32, ~fieldSchema=S.int),
+      mkField("event_id", BigInt({}), ~fieldSchema=S.bigint),
+      mkField("event_name", String, ~fieldSchema=S.string),
+      mkField("contract_name", String, ~fieldSchema=S.string),
+      mkField("block_number", Int32, ~fieldSchema=S.int),
+      mkField("log_index", Int32, ~fieldSchema=S.int),
+      mkField("src_address", String, ~fieldSchema=Address.schema),
+      mkField("block_hash", String, ~fieldSchema=S.string),
+      mkField("block_timestamp", Int32, ~fieldSchema=S.int),
+      mkField("block_fields", Json, ~fieldSchema=S.json(~validate=false)),
+      mkField("transaction_fields", Json, ~fieldSchema=S.json(~validate=false)),
+      mkField("params", Json, ~fieldSchema=S.json(~validate=false)),
       mkField("serial", Serial, ~isNullable, ~isPrimaryKey, ~fieldSchema=S.null(S.int)),
     ],
   )