envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/db/EntityHistory.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Table from "./Table.res.mjs";
+import * as $$BigInt from "../bindings/BigInt.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 = [
@@ -39,15 +39,15 @@ var changeFieldType = {
 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;
+                    var v = $$BigInt.fromString(string);
+                    if (v !== undefined) {
+                      return v;
                     } else {
                       return s.fail("The string is not valid CheckpointId", undefined);
                     }
                   }),
-                s: (function ($$float) {
-                    return String($$float);
+                s: (function (bigint) {
+                    return bigint.toString();
                   })
               };
       }));
@@ -81,7 +81,7 @@ function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema) {
 }
 
 function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId], {prepare: true});
+  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId.toString()], {prepare: true});
 }
 
 function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
@@ -94,10 +94,10 @@ function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
 }
 
 function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
-  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId], {prepare: true});
+  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId.toString()], {prepare: true});
 }
 
-var checkpointIdFieldType = "Uint32";
+var checkpointIdFieldType = "UInt64";
 
 var maxPgTableNameLength = 63;
 

package/src/db/InternalTable.res

@@ -5,75 +5,13 @@ let isPrimaryKey = true
 let isNullable = true
 let isIndex = true
 
-module DynamicContractRegistry = {
-  let name = "dynamic_contract_registry"
-  let index = -1
-
-  let makeId = (~chainId, ~contractAddress) => {
-    chainId->Belt.Int.toString ++ "-" ++ contractAddress->Address.toString
-  }
-
-  // @genType Used for Test DB
-  @genType
-  type t = {
-    id: string,
-    @as("chain_id") chainId: int,
-    @as("registering_event_block_number") registeringEventBlockNumber: int,
-    @as("registering_event_log_index") registeringEventLogIndex: int,
-    @as("registering_event_block_timestamp") registeringEventBlockTimestamp: int,
-    @as("registering_event_contract_name") registeringEventContractName: string,
-    @as("registering_event_name") registeringEventName: string,
-    @as("registering_event_src_address") registeringEventSrcAddress: Address.t,
-    @as("contract_address") contractAddress: Address.t,
-    @as("contract_name") contractName: string,
-  }
-
-  let schema = S.schema(s => {
-    id: s.matches(S.string),
-    chainId: s.matches(S.int),
-    registeringEventBlockNumber: s.matches(S.int),
-    registeringEventLogIndex: s.matches(S.int),
-    registeringEventContractName: s.matches(S.string),
-    registeringEventName: s.matches(S.string),
-    registeringEventSrcAddress: s.matches(Address.schema),
-    registeringEventBlockTimestamp: s.matches(S.int),
-    contractAddress: s.matches(Address.schema),
-    contractName: s.matches(S.string),
-  })
-
-  let rowsSchema = S.array(schema)
-
-  let table = mkTable(
-    name,
-    ~fields=[
-      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),
-    ],
-  )
-
-  external castToInternal: t => Internal.entity = "%identity"
-
-  let config = {
-    name,
-    index,
-    schema,
-    rowsSchema,
-    table,
-  }->Internal.fromGenericEntityConfig
-}
+module DynamicContractRegistry = Config.DynamicContractRegistry
 
 module Chains = {
   type progressFields = [
     | #progress_block
     | #events_processed
+    | #source_block
   ]
 
   type field = [
@@ -86,7 +24,6 @@ module Chains = {
     | #first_event_block
     | #buffer_block
     | #ready_at
-    | #_num_batches_fetched
     | #_is_hyper_sync
   ]
 
@@ -102,17 +39,14 @@ module Chains = {
     #ready_at,
     #events_processed,
     #_is_hyper_sync,
-    #_num_batches_fetched,
   ]
 
   type metaFields = {
     @as("first_event_block") firstEventBlockNumber: Js.null<int>,
     @as("buffer_block") latestFetchedBlockNumber: int,
-    @as("source_block") blockHeight: int,
     @as("ready_at")
     timestampCaughtUpToHeadOrEndblock: Js.null<Js.Date.t>,
     @as("_is_hyper_sync") isHyperSync: bool,
-    @as("_num_batches_fetched") numBatchesFetched: int,
   }
 
   type t = {
@@ -120,8 +54,9 @@ module Chains = {
     @as("start_block") startBlock: int,
     @as("end_block") endBlock: Js.null<int>,
     @as("max_reorg_depth") maxReorgDepth: int,
+    @as("source_block") blockHeight: int,
     @as("progress_block") progressBlockNumber: int,
-    @as("events_processed") numEventsProcessed: int,
+    @as("events_processed") numEventsProcessed: float,
     ...metaFields,
   }
 
@@ -152,13 +87,11 @@ module Chains = {
         ~fieldSchema=S.null(Utils.Schema.dbDate),
         ~isNullable,
       ),
-      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#events_processed: field :> string), UInt52, ~fieldSchema=S.float),
       // 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), Int32, ~fieldSchema=S.int),
-      // TODO: Should deprecate after changing the ETA calculation logic
-      mkField((#_num_batches_fetched: field :> string), Int32, ~fieldSchema=S.int),
     ],
   )
 
@@ -174,8 +107,7 @@ module Chains = {
       timestampCaughtUpToHeadOrEndblock: Js.Null.empty,
       progressBlockNumber: -1,
       isHyperSync: false,
-      numEventsProcessed: 0,
-      numBatchesFetched: 0,
+      numEventsProcessed: 0.,
     }
   }
 
@@ -194,8 +126,9 @@ module Chains = {
             initialValues->(Utils.magic: t => dict<unknown>)->Js.Dict.get((field :> string))
           switch Js.typeof(value) {
           | "object" => "NULL"
-          | "number" => value->Utils.magic->Belt.Int.toString
-          | "boolean" => value->Utils.magic ? "true" : "false"
+          | "number" => value->(Utils.magic: option<unknown> => int)->Belt.Int.toString
+          | "bigint" => value->(Utils.magic: option<unknown> => bigint)->BigInt.toString
+          | "boolean" => value->(Utils.magic: option<unknown> => bool) ? "true" : "false"
           | _ => Js.Exn.raiseError("Invalid envio_chains value type")
           }
         })
@@ -211,14 +144,7 @@ VALUES ${valuesRows->Js.Array2.joinWith(",\n       ")};`,
   }
 
   // Fields that can be updated outside of the batch transaction
-  let metaFields: array<field> = [
-    #source_block,
-    #buffer_block,
-    #first_event_block,
-    #ready_at,
-    #_is_hyper_sync,
-    #_num_batches_fetched,
-  ]
+  let metaFields: array<field> = [#buffer_block, #first_event_block, #ready_at, #_is_hyper_sync]
 
   let makeMetaFieldsUpdateQuery = (~pgSchema) => {
     // Generate SET clauses with parameter placeholders
@@ -240,9 +166,10 @@ WHERE "${(#id: field :> string)}" = $1;`
     maxReorgDepth: int,
     firstEventBlockNumber: Js.Null.t<int>,
     timestampCaughtUpToHeadOrEndblock: Js.Null.t<Js.Date.t>,
-    numEventsProcessed: int,
+    numEventsProcessed: float,
     progressBlockNumber: int,
     dynamicContracts: array<Internal.indexingContract>,
+    sourceBlockNumber: int,
   }
 
   // FIXME: Using registering_event_block_number for startBlock
@@ -256,8 +183,9 @@ WHERE "${(#id: field :> string)}" = $1;`
 "${(#max_reorg_depth: field :> string)}" as "maxReorgDepth",
 "${(#first_event_block: field :> string)}" as "firstEventBlockNumber",
 "${(#ready_at: field :> string)}" as "timestampCaughtUpToHeadOrEndblock",
-"${(#events_processed: field :> string)}" as "numEventsProcessed",
+"${(#events_processed: field :> string)}"::float8 as "numEventsProcessed",
 "${(#progress_block: field :> string)}" as "progressBlockNumber",
+"${(#source_block: field :> string)}" as "sourceBlockNumber",
 (
   SELECT COALESCE(json_agg(json_build_object(
     'address', "contract_address",
@@ -277,7 +205,7 @@ FROM "${pgSchema}"."${table.tableName}" as chains;`
     ->(Utils.magic: promise<array<unknown>> => promise<array<rawInitialState>>)
   }
 
-  let progressFields: array<progressFields> = [#progress_block, #events_processed]
+  let progressFields: array<progressFields> = [#progress_block, #events_processed, #source_block]
 
   let makeProgressFieldsUpdateQuery = (~pgSchema) => {
     let setClauses = Belt.Array.mapWithIndex(progressFields, (index, field) => {
@@ -318,7 +246,8 @@ WHERE "id" = $1;`
   type progressedChain = {
     chainId: int,
     progressBlockNumber: int,
-    totalEventsProcessed: int,
+    sourceBlockNumber: int,
+    totalEventsProcessed: float,
   }
 
   let setProgressedChains = (sql, ~pgSchema, ~progressedChains: array<progressedChain>) => {
@@ -338,7 +267,8 @@ WHERE "id" = $1;`
         ->Js.Array2.push(
           switch field {
           | #progress_block => data.progressBlockNumber->(Utils.magic: int => unknown)
-          | #events_processed => data.totalEventsProcessed->(Utils.magic: int => unknown)
+          | #events_processed => data.totalEventsProcessed->(Utils.magic: float => unknown)
+          | #source_block => data.sourceBlockNumber->(Utils.magic: int => unknown)
           },
         )
         ->ignore
@@ -382,7 +312,7 @@ module Checkpoints = {
   ]
 
   type t = {
-    id: float,
+    id: bigint,
     @as("chain_id")
     chainId: int,
     @as("block_number")
@@ -393,12 +323,24 @@ module Checkpoints = {
     eventsProcessed: int,
   }
 
-  let initialCheckpointId = 0.
+  // Schema for parsing DB results where BIGINT columns come back as strings
+  let dbSchema = S.object(s => {
+    id: s.field("id", BigInt.schema),
+    chainId: s.field("chain_id", S.int),
+    blockNumber: s.field("block_number", S.int),
+    blockHash: s.field(
+      "block_hash",
+      S.union([S.string->(Utils.magic: S.t<string> => S.t<Js.null<string>>), S.literal(%raw(`null`))]),
+    ),
+    eventsProcessed: s.field("events_processed", S.int),
+  })
+
+  let initialCheckpointId = 0n
 
   let table = mkTable(
     "envio_checkpoints",
     ~fields=[
-      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#id: field :> string), UInt64, ~fieldSchema=S.bigint, ~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),
@@ -433,12 +375,12 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
   }
 
   let makeCommitedCheckpointIdQuery = (~pgSchema) => {
-    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->Belt.Float.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
+    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->BigInt.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: Postgres.columnType :> string)}[],$2::${(Integer: Postgres.columnType :> string)}[],$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
+SELECT * FROM unnest($1::${(BigInt: 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 = (
@@ -452,18 +394,20 @@ SELECT * FROM unnest($1::${(Integer: Postgres.columnType :> string)}[],$2::${(In
   ) => {
     let query = makeInsertCheckpointQuery(~pgSchema)
 
+    // Convert bigint arrays to string arrays for postgres driver compatibility
+    let checkpointIdStrings = checkpointIds->BigInt.arrayToStringArray
     sql
     ->Postgres.preparedUnsafe(
       query,
       (
-        checkpointIds,
+        checkpointIdStrings,
         checkpointChainIds,
         checkpointBlockNumbers,
         checkpointBlockHashes,
         checkpointEventsProcessed,
       )->(
         Utils.magic: (
-          (array<float>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
+          (array<string>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
         ) => unknown
       ),
     )
@@ -474,7 +418,7 @@ SELECT * FROM unnest($1::${(Integer: Postgres.columnType :> string)}[],$2::${(In
     sql
     ->Postgres.preparedUnsafe(
       `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
-      [rollbackTargetCheckpointId]->Utils.magic,
+      [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
     )
     ->Promise.ignoreValue
   }
@@ -483,11 +427,11 @@ SELECT * FROM unnest($1::${(Integer: Postgres.columnType :> string)}[],$2::${(In
     `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" < $1;`
   }
 
-  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: float) => {
+  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: bigint) => {
     sql
     ->Postgres.preparedUnsafe(
       makePruneStaleCheckpointsQuery(~pgSchema),
-      [safeCheckpointId]->Obj.magic,
+      [safeCheckpointId->BigInt.toString]->Obj.magic,
     )
     ->Promise.ignoreValue
   }
@@ -507,12 +451,16 @@ LIMIT 1;`
     ~reorgChainId: int,
     ~lastKnownValidBlockNumber: int,
   ) => {
-    sql
-    ->Postgres.preparedUnsafe(
-      makeGetRollbackTargetCheckpointQuery(~pgSchema),
-      (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
-    )
-    ->(Utils.magic: promise<unknown> => promise<array<{"id": Internal.checkpointId}>>)
+    let rawResult: promise<array<{"id": string}>> =
+      sql
+      ->Postgres.preparedUnsafe(
+        makeGetRollbackTargetCheckpointQuery(~pgSchema),
+        (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
+      )
+      ->(Utils.magic: promise<unknown> => promise<array<{"id": string}>>)
+    rawResult->Promise.thenResolve(rows => {
+      rows->Belt.Array.get(0)->Belt.Option.map(row => row["id"]->BigInt.fromStringUnsafe)
+    })
   }
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
@@ -533,7 +481,7 @@ GROUP BY "${(#chain_id: field :> string)}";`
     sql
     ->Postgres.preparedUnsafe(
       makeGetRollbackProgressDiffQuery(~pgSchema),
-      [rollbackTargetCheckpointId]->Obj.magic,
+      [rollbackTargetCheckpointId->BigInt.toString]->Obj.magic,
     )
     ->(
       Utils.magic: promise<unknown> => promise<
@@ -584,7 +532,7 @@ module RawEvents = {
     "raw_events",
     ~fields=[
       mkField("chain_id", Int32, ~fieldSchema=S.int),
-      mkField("event_id", BigInt({}), ~fieldSchema=S.bigint),
+      mkField("event_id", UInt64, ~fieldSchema=S.bigint),
       mkField("event_name", String, ~fieldSchema=S.string),
       mkField("contract_name", String, ~fieldSchema=S.string),
       mkField("block_number", Int32, ~fieldSchema=S.int),
@@ -595,7 +543,7 @@ module RawEvents = {
       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)),
+      mkField("serial", BigSerial, ~isNullable, ~isPrimaryKey, ~fieldSchema=S.null(S.bigint)),
     ],
   )
 }
@@ -614,7 +562,7 @@ SELECT
   "${(#progress_block: Chains.field :> string)}" AS "progressBlock",
   "${(#buffer_block: Chains.field :> string)}" AS "bufferBlock",
   "${(#first_event_block: Chains.field :> string)}" AS "firstEventBlock",
-  "${(#events_processed: Chains.field :> string)}" AS "eventsProcessed",
+  "${(#events_processed: Chains.field :> string)}"::float4 AS "eventsProcessed",
   "${(#source_block: Chains.field :> string)}" AS "sourceBlock",
   "${(#ready_at: Chains.field :> string)}" AS "readyAt",
   ("${(#ready_at: Chains.field :> string)}" IS NOT NULL) AS "isReady"
@@ -632,8 +580,8 @@ SELECT
   "${(#_is_hyper_sync: Chains.field :> string)}" AS "is_hyper_sync",
   "${(#buffer_block: Chains.field :> string)}" AS "latest_fetched_block_number",
   "${(#progress_block: Chains.field :> string)}" AS "latest_processed_block",
-  "${(#_num_batches_fetched: Chains.field :> string)}" AS "num_batches_fetched",
-  "${(#events_processed: Chains.field :> string)}" AS "num_events_processed",
+  0 AS "num_batches_fetched",
+  "${(#events_processed: Chains.field :> string)}"::float4 AS "num_events_processed",
   "${(#start_block: Chains.field :> string)}" AS "start_block",
   "${(#ready_at: Chains.field :> string)}" AS "timestamp_caught_up_to_head_or_endblock"
 FROM "${pgSchema}"."${Chains.table.tableName}";`