envio 2.31.0-alpha.3 → 2.31.1-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.31.0-alpha.3",
+  "version": "v2.31.1-rc.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.31.0-alpha.3",
-    "envio-linux-arm64": "v2.31.0-alpha.3",
-    "envio-darwin-x64": "v2.31.0-alpha.3",
-    "envio-darwin-arm64": "v2.31.0-alpha.3"
+    "envio-linux-x64": "v2.31.1-rc.0",
+    "envio-linux-arm64": "v2.31.1-rc.0",
+    "envio-darwin-x64": "v2.31.1-rc.0",
+    "envio-darwin-arm64": "v2.31.1-rc.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",

package/src/Envio.res

@@ -59,7 +59,6 @@ let experimental_createEffect = (
   options: effectOptions<'input, 'output>,
   handler: effectArgs<'input> => promise<'output>,
 ) => {
-  Prometheus.EffectCallsCount.set(~callsCount=0, ~effectName=options.name)
   let outputSchema =
     S.schema(_ => options.output)->(Utils.magic: S.t<S.t<'output>> => S.t<Internal.effectOutput>)
   {
@@ -86,7 +85,7 @@ let experimental_createEffect = (
       })
       Some({
         table: Internal.makeCacheTable(~effectName=options.name),
-        rowsSchema: S.array(itemSchema),
+        outputSchema,
         itemSchema,
       })
     | None

package/src/Envio.res.js

@@ -2,11 +2,9 @@
 'use strict';
 
 var Internal = require("./Internal.res.js");
-var Prometheus = require("./Prometheus.res.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
 function experimental_createEffect(options, handler) {
-  Prometheus.EffectCallsCount.set(0, options.name);
   var outputSchema = S$RescriptSchema.schema(function (param) {
         return options.output;
       });
@@ -21,7 +19,7 @@ function experimental_createEffect(options, handler) {
         });
     tmp = {
       itemSchema: itemSchema,
-      rowsSchema: S$RescriptSchema.array(itemSchema),
+      outputSchema: outputSchema,
       table: Internal.makeCacheTable(options.name)
     };
   } else {

package/src/FetchState.res

@@ -351,8 +351,11 @@ let registerDynamicContracts = (
     switch item->Internal.getItemDcs {
     | None => ()
     | Some(dcs) =>
-      for idx in 0 to dcs->Array.length - 1 {
-        let dc = dcs->Js.Array2.unsafe_get(idx)
+      let idx = ref(0)
+      while idx.contents < dcs->Array.length {
+        let dc = dcs->Js.Array2.unsafe_get(idx.contents)
+
+        let shouldRemove = ref(false)
 
         switch fetchState.contractConfigs->Utils.Dict.dangerouslyGetNonOption(dc.contractName) {
         | Some({filterByAddresses}) =>
@@ -378,8 +381,7 @@ let registerDynamicContracts = (
               )
               logger->Logging.childWarn(`Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`)
             }
-            // Remove the DC from item to prevent it from saving to the db
-            let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+            shouldRemove := true
           | None =>
             let shouldUpdate = switch registeringContracts->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
@@ -401,8 +403,7 @@ let registerDynamicContracts = (
                 Pervasives.min(earliestRegisteringEventBlockNumber.contents, dc.startBlock)
               registeringContracts->Js.Dict.set(dc.address->Address.toString, dc)
             } else {
-              // Remove the DC from item to prevent it from saving to the db
-              let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+              shouldRemove := true
             }
           }
         | None => {
@@ -414,9 +415,17 @@ let registerDynamicContracts = (
               },
             )
             logger->Logging.childWarn(`Skipping contract registration: Contract doesn't have any events to fetch.`)
-            let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx)
+            shouldRemove := true
           }
         }
+
+        if shouldRemove.contents {
+          // Remove the DC from item to prevent it from saving to the db
+          let _ = dcs->Js.Array2.removeCountInPlace(~count=1, ~pos=idx.contents)
+          // Don't increment idx - next element shifted into current position
+        } else {
+          idx := idx.contents + 1
+        }
       }
     }
   }

package/src/FetchState.res.js

@@ -237,8 +237,10 @@ function registerDynamicContracts(fetchState, items) {
     var item = items[itemIdx];
     var dcs = item.dcs;
     if (dcs !== undefined) {
-      for(var idx = 0 ,idx_finish = dcs.length; idx < idx_finish; ++idx){
+      var idx = 0;
+      while(idx < dcs.length) {
         var dc = dcs[idx];
+        var shouldRemove = false;
         var match = fetchState.contractConfigs[dc.contractName];
         if (match !== undefined) {
           var existingContract = indexingContracts[dc.address];
@@ -254,7 +256,7 @@ function registerDynamicContracts(fetchState, items) {
                   });
               Logging.childWarn(logger, "Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.");
             }
-            dcs.splice(idx, 1);
+            shouldRemove = true;
           } else {
             var registeringContract = registeringContracts[dc.address];
             var shouldUpdate;
@@ -274,7 +276,7 @@ function registerDynamicContracts(fetchState, items) {
               earliestRegisteringEventBlockNumber = earliestRegisteringEventBlockNumber < dc.startBlock ? earliestRegisteringEventBlockNumber : dc.startBlock;
               registeringContracts[dc.address] = dc;
             } else {
-              dcs.splice(idx, 1);
+              shouldRemove = true;
             }
           }
         } else {
@@ -284,9 +286,14 @@ function registerDynamicContracts(fetchState, items) {
                 contractName: dc.contractName
               });
           Logging.childWarn(logger$1, "Skipping contract registration: Contract doesn't have any events to fetch.");
+          shouldRemove = true;
+        }
+        if (shouldRemove) {
           dcs.splice(idx, 1);
+        } else {
+          idx = idx + 1 | 0;
         }
-      }
+      };
     }
     
   }
@@ -331,7 +338,7 @@ function registerDynamicContracts(fetchState, items) {
             addressesByContractName: pendingAddressesByContractName.contents
           });
     };
-    for(var idx$1 = 0 ,idx_finish$1 = Object.keys(addressesByContractName).length; idx$1 < idx_finish$1; ++idx$1){
+    for(var idx$1 = 0 ,idx_finish = Object.keys(addressesByContractName).length; idx$1 < idx_finish; ++idx$1){
       var contractName = Object.keys(addressesByContractName)[idx$1];
       var addresses = addressesByContractName[contractName];
       var contractConfig = fetchState.contractConfigs[contractName];

package/src/Internal.res

@@ -290,7 +290,7 @@ type effectArgs = {
 type effectCacheItem = {id: string, output: effectOutput}
 type effectCacheMeta = {
   itemSchema: S.t<effectCacheItem>,
-  rowsSchema: S.t<array<effectCacheItem>>,
+  outputSchema: S.t<effectOutput>,
   table: Table.table,
 }
 type effect = {
@@ -302,14 +302,17 @@ type effect = {
   mutable callsCount: int,
 }
 let cacheTablePrefix = "envio_effect_"
+let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<Js.Json.t> => S.t<effectOutput>)
+let effectCacheItemRowsSchema = S.array(
+  S.schema(s => {id: s.matches(S.string), output: s.matches(cacheOutputSchema)}),
+)
 let makeCacheTable = (~effectName) => {
   Table.mkTable(
     cacheTablePrefix ++ effectName,
     ~fields=[
       Table.mkField("id", Text, ~fieldSchema=S.string, ~isPrimaryKey=true),
-      Table.mkField("output", JsonB, ~fieldSchema=S.json(~validate=false), ~isNullable=true),
+      Table.mkField("output", JsonB, ~fieldSchema=cacheOutputSchema, ~isNullable=true),
     ],
-    ~compositeIndices=[],
   )
 }
 

package/src/Internal.res.js

@@ -36,10 +36,19 @@ function makeEnumConfig(name, variants) {
 
 var cacheTablePrefix = "envio_effect_";
 
+var cacheOutputSchema = S$RescriptSchema.json(false);
+
+var effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(function (s) {
+          return {
+                  id: s.m(S$RescriptSchema.string),
+                  output: s.m(cacheOutputSchema)
+                };
+        }));
+
 function makeCacheTable(effectName) {
-  return Table.mkTable(cacheTablePrefix + effectName, [], [
+  return Table.mkTable(cacheTablePrefix + effectName, undefined, [
               Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-              Table.mkField("output", "JSONB", S$RescriptSchema.json(false), undefined, undefined, true, undefined, undefined, undefined)
+              Table.mkField("output", "JSONB", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
             ]);
 }
 
@@ -47,5 +56,7 @@ exports.fuelSupplyParamsSchema = fuelSupplyParamsSchema;
 exports.fuelTransferParamsSchema = fuelTransferParamsSchema;
 exports.makeEnumConfig = makeEnumConfig;
 exports.cacheTablePrefix = cacheTablePrefix;
+exports.cacheOutputSchema = cacheOutputSchema;
+exports.effectCacheItemRowsSchema = effectCacheItemRowsSchema;
 exports.makeCacheTable = makeCacheTable;
 /* fuelSupplyParamsSchema Not a pure module */

package/src/Persistence.res

@@ -192,7 +192,12 @@ let getInitializedState = persistence => {
   }
 }
 
-let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items) => {
+let setEffectCacheOrThrow = async (
+  persistence,
+  ~effect: Internal.effect,
+  ~items,
+  ~invalidationsCount,
+) => {
   switch persistence.storageStatus {
   | Unknown
   | Initializing(_) =>
@@ -210,7 +215,8 @@ let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items
       }
       let initialize = effectCacheRecord.count === 0
       await storage.setEffectCacheOrThrow(~effect, ~items, ~initialize)
-      effectCacheRecord.count = effectCacheRecord.count + items->Js.Array2.length
+      effectCacheRecord.count =
+        effectCacheRecord.count + items->Js.Array2.length - invalidationsCount
       Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
     }
   }

package/src/Persistence.res.js

@@ -119,7 +119,7 @@ function getInitializedState(persistence) {
   }
 }
 
-async function setEffectCacheOrThrow(persistence, effect, items) {
+async function setEffectCacheOrThrow(persistence, effect, items, invalidationsCount) {
   var match = persistence.storageStatus;
   if (typeof match !== "object") {
     return Js_exn.raiseError("Failed to access the indexer storage. The Persistence layer is not initialized.");
@@ -144,7 +144,7 @@ async function setEffectCacheOrThrow(persistence, effect, items) {
   }
   var initialize = effectCacheRecord.count === 0;
   await storage.setEffectCacheOrThrow(effect, items, initialize);
-  effectCacheRecord.count = effectCacheRecord.count + items.length | 0;
+  effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
   return Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
 }
 

package/src/PgStorage.res

@@ -22,7 +22,7 @@ let makeCreateTableIndicesQuery = (table: Table.table, ~pgSchema) => {
     compositeIndices->Array.map(createCompositeIndex)->Js.Array2.joinWith("\n")
 }
 
-let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
+let makeCreateTableQuery = (table: Table.table, ~pgSchema, ~isNumericArrayAsText) => {
   open Belt
   let fieldsMapped =
     table
@@ -34,6 +34,8 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
       {
         `"${fieldName}" ${switch fieldType {
           | Custom(name) if !(name->Js.String2.startsWith("NUMERIC(")) => `"${pgSchema}".${name}`
+          // Workaround for Hasura bug https://github.com/enviodev/hyperindex/issues/788
+          | Numeric if isArray && isNumericArrayAsText => (Table.Text :> string)
           | _ => (fieldType :> string)
           }}${isArray ? "[]" : ""}${switch defaultValue {
           | Some(defaultValue) => ` DEFAULT ${defaultValue}`
@@ -57,6 +59,7 @@ let makeCreateTableQuery = (table: Table.table, ~pgSchema) => {
 let makeInitializeTransaction = (
   ~pgSchema,
   ~pgUser,
+  ~isHasuraEnabled,
   ~chainConfigs=[],
   ~entities=[],
   ~enums=[],
@@ -105,7 +108,10 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
 
   // Batch all table creation first (optimal for PostgreSQL)
   allTables->Js.Array2.forEach((table: Table.table) => {
-    query := query.contents ++ "\n" ++ makeCreateTableQuery(table, ~pgSchema)
+    query :=
+      query.contents ++
+      "\n" ++
+      makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=isHasuraEnabled)
   })
 
   // Then batch all indices (better performance when tables exist)
@@ -263,7 +269,7 @@ let makeTableBatchSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema: S.t<'
   // Currently history update table uses S.object with transformation for schema,
   // which is being lossed during conversion to dbSchema.
   // So use simple insert values for now.
-  let isHistoryUpdate = table.tableName->Js.String2.startsWith("envio_history_")
+  let isHistoryUpdate = table.tableName->Js.String2.startsWith(EntityHistory.historyTablePrefix)
 
   // Should experiment how much it'll affect performance
   // Although, it should be fine not to perform the validation check,
@@ -329,7 +335,7 @@ let removeInvalidUtf8InPlace = entities =>
         // This is unsafe, but we rely that it'll use
         // the mutated reference on retry.
         // TODO: Test it properly after we start using
-        // in-memory PGLite for indexer test framework.
+        // real pg for indexer test framework.
         dict->Js.Dict.set(
           key,
           value
@@ -507,6 +513,7 @@ let make = (
   ~pgUser,
   ~pgDatabase,
   ~pgPassword,
+  ~isHasuraEnabled,
   ~onInitialize=?,
   ~onNewTables=?,
 ): Persistence.storage => {
@@ -552,7 +559,7 @@ let make = (
               let table = Internal.makeCacheTable(~effectName)
 
               sql
-              ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
+              ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false))
               ->Promise.then(() => {
                 let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
 
@@ -645,6 +652,7 @@ let make = (
       ~enums,
       ~chainConfigs,
       ~isEmptyPgSchema=schemaTableNames->Utils.Array.isEmpty,
+      ~isHasuraEnabled,
     )
     // Execute all queries within a single transaction for integrity
     let _ = await sql->Postgres.beginSql(sql => {
@@ -790,7 +798,10 @@ let make = (
     }
 
     if initialize {
-      let _ = await sql->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema))
+      let _ =
+        await sql->Postgres.unsafe(
+          makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false),
+        )
       // Integration with other tools like Hasura
       switch onNewTables {
       | Some(onNewTables) => await onNewTables(~tableNames=[table.tableName])

package/src/PgStorage.res.js

@@ -15,6 +15,7 @@ var Internal = require("./Internal.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var Persistence = require("./Persistence.res.js");
+var EntityHistory = require("./db/EntityHistory.res.js");
 var InternalTable = require("./db/InternalTable.res.js");
 var Child_process = require("child_process");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
@@ -44,15 +45,20 @@ function makeCreateTableIndicesQuery(table, pgSchema) {
   return Belt_Array.map(singleIndices, createIndex).join("\n") + Belt_Array.map(compositeIndices, createCompositeIndex).join("\n");
 }
 
-function makeCreateTableQuery(table, pgSchema) {
+function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText) {
   var fieldsMapped = Belt_Array.map(Table.getFields(table), (function (field) {
             var defaultValue = field.defaultValue;
+            var isArray = field.isArray;
             var fieldType = field.fieldType;
             var fieldName = Table.getDbFieldName(field);
             var tmp;
-            tmp = fieldType === "TIMESTAMP" || fieldType === "TIMESTAMP WITH TIME ZONE" || fieldType === "JSONB" || fieldType === "SERIAL" || fieldType === "TEXT" || fieldType === "DOUBLE PRECISION" || fieldType === "NUMERIC" || fieldType === "BOOLEAN" || fieldType === "BIGINT" || fieldType === "INTEGER" || fieldType === "TIMESTAMP WITH TIME ZONE NULL" || fieldType.startsWith("NUMERIC(") ? fieldType : "\"" + pgSchema + "\"." + fieldType;
+            tmp = fieldType === "TIMESTAMP" || fieldType === "TIMESTAMP WITH TIME ZONE" || fieldType === "JSONB" || fieldType === "SERIAL" || fieldType === "TEXT" || fieldType === "DOUBLE PRECISION" || fieldType === "NUMERIC" || fieldType === "BOOLEAN" || fieldType === "BIGINT" || fieldType === "INTEGER" || fieldType === "TIMESTAMP WITH TIME ZONE NULL" ? (
+                fieldType === "NUMERIC" && isArray && isNumericArrayAsText ? "TEXT" : fieldType
+              ) : (
+                fieldType.startsWith("NUMERIC(") ? fieldType : "\"" + pgSchema + "\"." + fieldType
+              );
             return "\"" + fieldName + "\" " + tmp + (
-                    field.isArray ? "[]" : ""
+                    isArray ? "[]" : ""
                   ) + (
                     defaultValue !== undefined ? " DEFAULT " + defaultValue : (
                         field.isNullable ? "" : " NOT NULL"
@@ -68,7 +74,7 @@ function makeCreateTableQuery(table, pgSchema) {
         ) + ");";
 }
 
-function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt) {
+function makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigsOpt, entitiesOpt, enumsOpt, isEmptyPgSchemaOpt) {
   var chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
   var entities = entitiesOpt !== undefined ? entitiesOpt : [];
   var enums = enumsOpt !== undefined ? enumsOpt : [];
@@ -99,7 +105,7 @@ function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOp
         query.contents = query.contents + "\n" + enumCreateQuery;
       });
   allTables.forEach(function (table) {
-        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema);
+        query.contents = query.contents + "\n" + makeCreateTableQuery(table, pgSchema, isHasuraEnabled);
       });
   allTables.forEach(function (table) {
         var indices = makeCreateTableIndicesQuery(table, pgSchema);
@@ -194,7 +200,7 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
 function makeTableBatchSetQuery(pgSchema, table, itemSchema) {
   var match = Table.toSqlParams(table, itemSchema, pgSchema);
   var isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
-  var isHistoryUpdate = table.tableName.startsWith("envio_history_");
+  var isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
   if ((isRawEvents || !match.hasArrayField) && !isHistoryUpdate) {
     return {
             query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
@@ -354,7 +360,7 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort) {
   return result;
 }
 
-function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onInitialize, onNewTables) {
+function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, onInitialize, onNewTables) {
   var psqlExecOptions_env = Js_dict.fromArray([
         [
           "PGPASSWORD",
@@ -403,7 +409,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
           await Promise.all(cacheFiles.map(function (entry) {
                     var effectName = entry.slice(0, -4);
                     var table = Internal.makeCacheTable(effectName);
-                    return sql.unsafe(makeCreateTableQuery(table, pgSchema)).then(function () {
+                    return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(function () {
                                 var inputFile = Path.join(cacheDirPath, entry);
                                 var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + table.tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
                                 return new Promise((function (resolve, reject) {
@@ -461,7 +467,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
           })) {
       Js_exn.raiseError("Cannot run Envio migrations on PostgreSQL schema \"" + pgSchema + "\" because it contains non-Envio tables. Running migrations would delete all data in this schema.\n\nTo resolve this:\n1. If you want to use this schema, first backup any important data, then drop it with: \"pnpm envio local db-migrate down\"\n2. Or specify a different schema name by setting the \"ENVIO_PG_PUBLIC_SCHEMA\" environment variable\n3. Or manually drop the schema in your database if you're certain the data is not needed.");
     }
-    var queries = makeInitializeTransaction(pgSchema, pgUser, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
+    var queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
     await sql.begin(function (sql) {
           return Promise.all(queries.map(function (query) {
                           return sql.unsafe(query);
@@ -568,7 +574,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
     var match = cacheMeta !== undefined ? cacheMeta : Js_exn.raiseError("Failed to set effect cache for \"" + effect.name + "\". Effect has no cache enabled.");
     var table = match.table;
     if (initialize) {
-      await sql.unsafe(makeCreateTableQuery(table, pgSchema));
+      await sql.unsafe(makeCreateTableQuery(table, pgSchema, false));
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }

package/src/Prometheus.res

@@ -525,30 +525,6 @@ module RollbackTargetBlockNumber = {
   }
 }
 
-module ProcessingBlockNumber = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_processing_block_number",
-    ~help="The latest item block number included in the currently processing batch for the chain.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~blockNumber, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=blockNumber)
-  }
-}
-
-module ProcessingBatchSize = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_processing_batch_size",
-    ~help="The number of items included in the currently processing batch for the chain.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~batchSize, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=batchSize)
-  }
-}
-
 module ProcessingMaxBatchSize = {
   let gauge = PromClient.Gauge.makeGauge({
     "name": "envio_processing_max_batch_size",
@@ -593,6 +569,17 @@ module ProgressEventsCount = {
   }
 }
 
+module ProgressBatchCount = {
+  let counter = PromClient.Counter.makeCounter({
+    "name": "envio_progress_batches_count",
+    "help": "The number of batches processed and reflected in the database.",
+  })
+
+  let increment = () => {
+    counter->PromClient.Counter.inc
+  }
+}
+
 let effectLabelsSchema = S.object(s => {
   s.field("effect", S.string)
 })
@@ -621,6 +608,18 @@ module EffectCacheCount = {
   }
 }
 
+module EffectCacheInvalidationsCount = {
+  let counter = SafeCounter.makeOrThrow(
+    ~name="envio_effect_cache_invalidations_count",
+    ~help="The number of effect cache invalidations.",
+    ~labelSchema=effectLabelsSchema,
+  )
+
+  let increment = (~effectName) => {
+    counter->SafeCounter.increment(~labels=effectName)
+  }
+}
+
 module StorageLoad = {
   let operationLabelsSchema = S.object(s => s.field("operation", S.string))
 

package/src/Prometheus.res.js

@@ -628,51 +628,29 @@ var RollbackTargetBlockNumber = {
   set: set$15
 };
 
-var gauge$17 = makeOrThrow$1("envio_processing_block_number", "The latest item block number included in the currently processing batch for the chain.", chainIdLabelsSchema);
-
-function set$16(blockNumber, chainId) {
-  handleInt$1(gauge$17, chainId, blockNumber);
-}
-
-var ProcessingBlockNumber = {
-  gauge: gauge$17,
-  set: set$16
-};
-
-var gauge$18 = makeOrThrow$1("envio_processing_batch_size", "The number of items included in the currently processing batch for the chain.", chainIdLabelsSchema);
-
-function set$17(batchSize, chainId) {
-  handleInt$1(gauge$18, chainId, batchSize);
-}
-
-var ProcessingBatchSize = {
-  gauge: gauge$18,
-  set: set$17
-};
-
-var gauge$19 = new PromClient.Gauge({
+var gauge$17 = new PromClient.Gauge({
       name: "envio_processing_max_batch_size",
       help: "The maximum number of items to process in a single batch."
     });
 
-function set$18(maxBatchSize) {
-  gauge$19.set(maxBatchSize);
+function set$16(maxBatchSize) {
+  gauge$17.set(maxBatchSize);
 }
 
 var ProcessingMaxBatchSize = {
-  gauge: gauge$19,
-  set: set$18
+  gauge: gauge$17,
+  set: set$16
 };
 
-var gauge$20 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+var gauge$18 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$19(blockNumber, chainId) {
-  handleInt$1(gauge$20, chainId, blockNumber);
+function set$17(blockNumber, chainId) {
+  handleInt$1(gauge$18, chainId, blockNumber);
 }
 
 var ProgressBlockNumber = {
-  gauge: gauge$20,
-  set: set$19
+  gauge: gauge$18,
+  set: set$17
 };
 
 var deprecatedGauge$1 = new PromClient.Gauge({
@@ -681,45 +659,70 @@ var deprecatedGauge$1 = new PromClient.Gauge({
       labelNames: ["chainId"]
     });
 
-var gauge$21 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+var gauge$19 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$20(processedCount, chainId) {
+function set$18(processedCount, chainId) {
   deprecatedGauge$1.labels({
           chainId: chainId
         }).set(processedCount);
-  handleInt$1(gauge$21, chainId, processedCount);
+  handleInt$1(gauge$19, chainId, processedCount);
 }
 
 var ProgressEventsCount = {
   deprecatedGauge: deprecatedGauge$1,
-  gauge: gauge$21,
-  set: set$20
+  gauge: gauge$19,
+  set: set$18
+};
+
+var counter$5 = new PromClient.Counter({
+      name: "envio_progress_batches_count",
+      help: "The number of batches processed and reflected in the database."
+    });
+
+function increment$5() {
+  counter$5.inc();
+}
+
+var ProgressBatchCount = {
+  counter: counter$5,
+  increment: increment$5
 };
 
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var gauge$22 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
+var gauge$20 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
 
-function set$21(callsCount, effectName) {
-  handleInt$1(gauge$22, effectName, callsCount);
+function set$19(callsCount, effectName) {
+  handleInt$1(gauge$20, effectName, callsCount);
 }
 
 var EffectCallsCount = {
-  gauge: gauge$22,
-  set: set$21
+  gauge: gauge$20,
+  set: set$19
 };
 
-var gauge$23 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
+var gauge$21 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$22(count, effectName) {
-  handleInt$1(gauge$23, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$21, effectName, count);
 }
 
 var EffectCacheCount = {
-  gauge: gauge$23,
-  set: set$22
+  gauge: gauge$21,
+  set: set$20
+};
+
+var counter$6 = makeOrThrow("envio_effect_cache_invalidations_count", "The number of effect cache invalidations.", effectLabelsSchema);
+
+function increment$6(effectName) {
+  increment(counter$6, effectName);
+}
+
+var EffectCacheInvalidationsCount = {
+  counter: counter$6,
+  increment: increment$6
 };
 
 var operationLabelsSchema = S$RescriptSchema.object(function (s) {
@@ -730,7 +733,7 @@ var timeCounter$2 = makeOrThrow("envio_storage_load_time", "Processing time take
 
 var totalTimeCounter = makeOrThrow("envio_storage_load_total_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
 
-var counter$5 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
+var counter$7 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
 
 var whereSizeCounter = makeOrThrow("envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", operationLabelsSchema);
 
@@ -759,7 +762,7 @@ function endOperation(timerRef, operation, whereSize, size) {
     Utils.Dict.deleteInPlace(operations, operation);
   }
   handleInt(totalTimeCounter, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
-  increment(counter$5, operation);
+  increment(counter$7, operation);
   handleInt(whereSizeCounter, operation, whereSize);
   handleInt(sizeCounter, operation, size);
 }
@@ -768,7 +771,7 @@ var StorageLoad = {
   operationLabelsSchema: operationLabelsSchema,
   timeCounter: timeCounter$2,
   totalTimeCounter: totalTimeCounter,
-  counter: counter$5,
+  counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter,
   operations: operations,
@@ -817,13 +820,13 @@ exports.RollbackEnabled = RollbackEnabled;
 exports.RollbackSuccess = RollbackSuccess;
 exports.RollbackHistoryPrune = RollbackHistoryPrune;
 exports.RollbackTargetBlockNumber = RollbackTargetBlockNumber;
-exports.ProcessingBlockNumber = ProcessingBlockNumber;
-exports.ProcessingBatchSize = ProcessingBatchSize;
 exports.ProcessingMaxBatchSize = ProcessingMaxBatchSize;
 exports.ProgressBlockNumber = ProgressBlockNumber;
 exports.ProgressEventsCount = ProgressEventsCount;
+exports.ProgressBatchCount = ProgressBatchCount;
 exports.effectLabelsSchema = effectLabelsSchema;
 exports.EffectCallsCount = EffectCallsCount;
 exports.EffectCacheCount = EffectCacheCount;
+exports.EffectCacheInvalidationsCount = EffectCacheInvalidationsCount;
 exports.StorageLoad = StorageLoad;
 /* loadEntitiesDurationCounter Not a pure module */

package/src/ReorgDetection.res

@@ -37,8 +37,6 @@ let reorgDetectedToLogParams = (reorgDetected: reorgDetected, ~shouldRollbackOnR
 }
 
 type reorgResult = NoReorg | ReorgDetected(reorgDetected)
-type validBlockError = NotFound | AlreadyReorgedHashes
-type validBlockResult = result<blockDataWithTimestamp, validBlockError>
 
 type t = {
   // Whether to rollback on reorg
@@ -186,14 +184,13 @@ let registerReorgGuard = (
 }
 
 /**
-Returns the latest block data which matches block number and hashes in the provided array
-If it doesn't exist in the reorg threshold it returns None or the latest scanned block outside of the reorg threshold
+Returns the latest block number which matches block number and hashes in the provided array
+If it doesn't exist in the reorg threshold it returns NotFound
 */
 let getLatestValidScannedBlock = (
   self: t,
   ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
   ~currentBlockHeight,
-  ~skipReorgDuplicationCheck=false,
 ) => {
   let verifiedDataByBlockNumber = Js.Dict.empty()
   for idx in 0 to blockNumbersAndHashes->Array.length - 1 {
@@ -201,68 +198,38 @@ let getLatestValidScannedBlock = (
     verifiedDataByBlockNumber->Js.Dict.set(blockData.blockNumber->Int.toString, blockData)
   }
 
-  /*
-     Let's say we indexed block X with hash A.
-     The next query we got the block X with hash B.
-     We assume that the hash A is reorged since we received it earlier than B.
-     So when we try to detect the reorg depth, we consider hash A as already invalid,
-     and retry the block hashes query if we receive one. (since it could come from a different instance and cause a double reorg)
-     But the assumption that A is reorged might be wrong sometimes,
-     for example if we got B from instance which didn't handle a reorg A.
-     Theoretically, it's possible with high partition concurrency.
-     So to handle this and prevent entering an infinite loop,
-     we can skip the reorg duplication check if we're sure that the block hashes query
-     is not coming from a different instance. (let's say we tried several times)
- */
-  let isAlreadyReorgedResponse = skipReorgDuplicationCheck
-    ? false
-    : switch self.detectedReorgBlock {
-      | Some(detectedReorgBlock) =>
-        switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(
-          detectedReorgBlock.blockNumber->Int.toString,
-        ) {
-        | Some(verifiedBlockData) => verifiedBlockData.blockHash === detectedReorgBlock.blockHash
-        | None => false
-        }
-      | None => false
-      }
+  let dataByBlockNumber = self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
+  // Js engine automatically orders numeric object keys
+  let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
 
-  if isAlreadyReorgedResponse {
-    Error(AlreadyReorgedHashes)
-  } else {
-    let dataByBlockNumber = self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
-    // Js engine automatically orders numeric object keys
-    let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
-
-    let getPrevScannedBlock = idx =>
-      switch ascBlockNumberKeys
-      ->Belt.Array.get(idx - 1)
-      ->Option.flatMap(key => {
-        // We should already validate that the block number is verified at the point
-        verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(key)
-      }) {
-      | Some(data) => Ok(data)
-      | None => Error(NotFound)
+  let getPrevScannedBlockNumber = idx =>
+    ascBlockNumberKeys
+    ->Belt.Array.get(idx - 1)
+    ->Option.flatMap(key => {
+      // We should already validate that the block number is verified at the point
+      switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(key) {
+      | Some(v) => Some(v.blockNumber)
+      | None => None
       }
+    })
 
-    let rec loop = idx => {
-      switch ascBlockNumberKeys->Belt.Array.get(idx) {
-      | Some(blockNumberKey) =>
-        let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
-        switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
-        | None =>
-          Js.Exn.raiseError(
-            `Unexpected case. Couldn't find verified hash for block number ${blockNumberKey}`,
-          )
-        | Some(verifiedBlockData) if verifiedBlockData.blockHash === scannedBlock.blockHash =>
-          loop(idx + 1)
-        | Some(_) => getPrevScannedBlock(idx)
-        }
-      | None => getPrevScannedBlock(idx)
+  let rec loop = idx => {
+    switch ascBlockNumberKeys->Belt.Array.get(idx) {
+    | Some(blockNumberKey) =>
+      let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+      switch verifiedDataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
+      | None =>
+        Js.Exn.raiseError(
+          `Unexpected case. Couldn't find verified hash for block number ${blockNumberKey}`,
+        )
+      | Some(verifiedBlockData) if verifiedBlockData.blockHash === scannedBlock.blockHash =>
+        loop(idx + 1)
+      | Some(_) => getPrevScannedBlockNumber(idx)
       }
+    | None => getPrevScannedBlockNumber(idx)
     }
-    loop(0)
   }
+  loop(0)
 }
 
 /**
@@ -303,11 +270,22 @@ let rollbackToValidBlockNumber = (
   }
 }
 
-let getThresholdBlockNumbers = (self: t, ~currentBlockHeight) => {
-  let dataByBlockNumberCopyInThreshold =
-    self->getDataByBlockNumberCopyInThreshold(~currentBlockHeight)
+let getThresholdBlockNumbersBelowBlock = (self: t, ~blockNumber: int, ~currentBlockHeight) => {
+  let arr = []
+
+  // Js engine automatically orders numeric object keys
+  let ascBlockNumberKeys = self.dataByBlockNumber->Js.Dict.keys
+  let thresholdBlockNumber = currentBlockHeight - self.maxReorgDepth
 
-  dataByBlockNumberCopyInThreshold->Js.Dict.values->Js.Array2.map(v => v.blockNumber)
+  for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
+    let blockNumberKey = ascBlockNumberKeys->Js.Array2.unsafe_get(idx)
+    let scannedBlock = self.dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
+    if isInReorgThreshold && scannedBlock.blockNumber < blockNumber {
+      arr->Array.push(scannedBlock.blockNumber)
+    }
+  }
+  arr
 }
 
 let getHashByBlockNumber = (reorgDetection: t, ~blockNumber) => {

package/src/ReorgDetection.res.js

@@ -2,7 +2,6 @@
 'use strict';
 
 var Js_exn = require("rescript/lib/js/js_exn.js");
-var Js_dict = require("rescript/lib/js/js_dict.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
 
@@ -109,63 +108,37 @@ function registerReorgGuard(self, reorgGuard, currentBlockHeight) {
   }
 }
 
-function getLatestValidScannedBlock(self, blockNumbersAndHashes, currentBlockHeight, skipReorgDuplicationCheckOpt) {
-  var skipReorgDuplicationCheck = skipReorgDuplicationCheckOpt !== undefined ? skipReorgDuplicationCheckOpt : false;
+function getLatestValidScannedBlock(self, blockNumbersAndHashes, currentBlockHeight) {
   var verifiedDataByBlockNumber = {};
   for(var idx = 0 ,idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx){
     var blockData = blockNumbersAndHashes[idx];
     verifiedDataByBlockNumber[String(blockData.blockNumber)] = blockData;
   }
-  var isAlreadyReorgedResponse;
-  if (skipReorgDuplicationCheck) {
-    isAlreadyReorgedResponse = false;
-  } else {
-    var detectedReorgBlock = self.detectedReorgBlock;
-    if (detectedReorgBlock !== undefined) {
-      var verifiedBlockData = verifiedDataByBlockNumber[String(detectedReorgBlock.blockNumber)];
-      isAlreadyReorgedResponse = verifiedBlockData !== undefined ? verifiedBlockData.blockHash === detectedReorgBlock.blockHash : false;
-    } else {
-      isAlreadyReorgedResponse = false;
-    }
-  }
-  if (isAlreadyReorgedResponse) {
-    return {
-            TAG: "Error",
-            _0: "AlreadyReorgedHashes"
-          };
-  }
   var dataByBlockNumber = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
   var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
-  var getPrevScannedBlock = function (idx) {
-    var data = Belt_Option.flatMap(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
-            return verifiedDataByBlockNumber[key];
-          }));
-    if (data !== undefined) {
-      return {
-              TAG: "Ok",
-              _0: data
-            };
-    } else {
-      return {
-              TAG: "Error",
-              _0: "NotFound"
-            };
-    }
+  var getPrevScannedBlockNumber = function (idx) {
+    return Belt_Option.flatMap(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
+                  var v = verifiedDataByBlockNumber[key];
+                  if (v !== undefined) {
+                    return v.blockNumber;
+                  }
+                  
+                }));
   };
   var _idx = 0;
   while(true) {
     var idx$1 = _idx;
     var blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx$1);
     if (blockNumberKey === undefined) {
-      return getPrevScannedBlock(idx$1);
+      return getPrevScannedBlockNumber(idx$1);
     }
     var scannedBlock = dataByBlockNumber[blockNumberKey];
-    var verifiedBlockData$1 = verifiedDataByBlockNumber[blockNumberKey];
-    if (verifiedBlockData$1 === undefined) {
+    var verifiedBlockData = verifiedDataByBlockNumber[blockNumberKey];
+    if (verifiedBlockData === undefined) {
       return Js_exn.raiseError("Unexpected case. Couldn't find verified hash for block number " + blockNumberKey);
     }
-    if (verifiedBlockData$1.blockHash !== scannedBlock.blockHash) {
-      return getPrevScannedBlock(idx$1);
+    if (verifiedBlockData.blockHash !== scannedBlock.blockHash) {
+      return getPrevScannedBlockNumber(idx$1);
     }
     _idx = idx$1 + 1 | 0;
     continue ;
@@ -202,11 +175,20 @@ function rollbackToValidBlockNumber(param, blockNumber) {
         };
 }
 
-function getThresholdBlockNumbers(self, currentBlockHeight) {
-  var dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, currentBlockHeight);
-  return Js_dict.values(dataByBlockNumberCopyInThreshold).map(function (v) {
-              return v.blockNumber;
-            });
+function getThresholdBlockNumbersBelowBlock(self, blockNumber, currentBlockHeight) {
+  var arr = [];
+  var ascBlockNumberKeys = Object.keys(self.dataByBlockNumber);
+  var thresholdBlockNumber = currentBlockHeight - self.maxReorgDepth | 0;
+  for(var idx = 0 ,idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx){
+    var blockNumberKey = ascBlockNumberKeys[idx];
+    var scannedBlock = self.dataByBlockNumber[blockNumberKey];
+    var isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
+    if (isInReorgThreshold && scannedBlock.blockNumber < blockNumber) {
+      arr.push(scannedBlock.blockNumber);
+    }
+    
+  }
+  return arr;
 }
 
 function getHashByBlockNumber(reorgDetection, blockNumber) {
@@ -224,6 +206,6 @@ exports.getDataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshol
 exports.registerReorgGuard = registerReorgGuard;
 exports.getLatestValidScannedBlock = getLatestValidScannedBlock;
 exports.rollbackToValidBlockNumber = rollbackToValidBlockNumber;
-exports.getThresholdBlockNumbers = getThresholdBlockNumbers;
+exports.getThresholdBlockNumbersBelowBlock = getThresholdBlockNumbersBelowBlock;
 exports.getHashByBlockNumber = getHashByBlockNumber;
 /* No side effect */

package/src/SafeCheckpointTracking.res

@@ -36,32 +36,31 @@ let make = (
 let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) => {
   let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
 
-  if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) > safeBlockNumber {
-    0
-  } else {
-    let trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers->Array.length
-    switch trackingCheckpointsCount {
-    | 1 => safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(0)
-    | _ => {
-        let result = ref(None)
-        let idx = ref(1)
+  switch safeCheckpointTracking.checkpointIds {
+  | [] => 0
+  | _
+    if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) > safeBlockNumber => 0
+  | [checkpointId] => checkpointId
+  | _ => {
+      let trackingCheckpointsCount = safeCheckpointTracking.checkpointIds->Array.length
+      let result = ref(None)
+      let idx = ref(1)
 
-        while idx.contents < trackingCheckpointsCount && result.contents === None {
-          if (
-            safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
-              safeBlockNumber
-          ) {
-            result :=
-              Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
-          }
-          idx := idx.contents + 1
+      while idx.contents < trackingCheckpointsCount && result.contents === None {
+        if (
+          safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
+            safeBlockNumber
+        ) {
+          result :=
+            Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
         }
+        idx := idx.contents + 1
+      }
 
-        switch result.contents {
-        | Some(checkpointId) => checkpointId
-        | None =>
-          safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
-        }
+      switch result.contents {
+      | Some(checkpointId) => checkpointId
+      | None =>
+        safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
       }
     }
   }

package/src/SafeCheckpointTracking.res.js

@@ -21,13 +21,17 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
   var safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  var match = safeCheckpointTracking.checkpointIds;
+  if (match.length === 0) {
+    return 0;
+  }
   if (safeCheckpointTracking.checkpointBlockNumbers[0] > safeBlockNumber) {
     return 0;
   }
-  var trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers.length;
-  if (trackingCheckpointsCount === 1) {
-    return safeCheckpointTracking.checkpointIds[0];
+  if (match.length === 1) {
+    return match[0];
   }
+  var trackingCheckpointsCount = safeCheckpointTracking.checkpointIds.length;
   var result;
   var idx = 1;
   while(idx < trackingCheckpointsCount && result === undefined) {

package/src/db/EntityHistory.res

@@ -43,8 +43,9 @@ type t<'entity> = {
 }
 
 let maxPgTableNameLength = 63
+let historyTablePrefix = "envio_history_"
 let historyTableName = (~entityName, ~entityIndex) => {
-  let fullName = "envio_history_" ++ entityName
+  let fullName = historyTablePrefix ++ entityName
   if fullName->String.length > maxPgTableNameLength {
     let entityIndexStr = entityIndex->Belt.Int.toString
     fullName->Js.String.slice(~from=0, ~to_=maxPgTableNameLength - entityIndexStr->String.length) ++
@@ -86,8 +87,6 @@ let fromTable = (table: table, ~schema: S.t<'entity>, ~entityIndex): t<'entity>
     ~isPrimaryKey=true,
   )
 
-  // let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
-
   let entityTableName = table.tableName
   let historyTableName = historyTableName(~entityName=entityTableName, ~entityIndex)
   //ignore composite indices

package/src/db/EntityHistory.res.js

@@ -39,8 +39,10 @@ function makeSetUpdateSchema(entitySchema) {
             });
 }
 
+var historyTablePrefix = "envio_history_";
+
 function historyTableName(entityName, entityIndex) {
-  var fullName = "envio_history_" + entityName;
+  var fullName = historyTablePrefix + entityName;
   if (fullName.length <= 63) {
     return fullName;
   }
@@ -181,6 +183,7 @@ exports.changeFieldName = changeFieldName;
 exports.checkpointIdFieldName = checkpointIdFieldName;
 exports.makeSetUpdateSchema = makeSetUpdateSchema;
 exports.maxPgTableNameLength = maxPgTableNameLength;
+exports.historyTablePrefix = historyTablePrefix;
 exports.historyTableName = historyTableName;
 exports.fromTable = fromTable;
 exports.makePruneStaleEntityHistoryQuery = makePruneStaleEntityHistoryQuery;

package/src/sources/RpcSource.res

@@ -522,35 +522,38 @@ let make = (
     },
   )
 
-  let blockLoader = LazyLoader.make(
-    ~loaderFn=blockNumber =>
-      getKnownBlockWithBackoff(
-        ~provider,
-        ~sourceName=name,
-        ~chain,
-        ~backoffMsOnFailure=1000,
-        ~blockNumber,
-        ~lowercaseAddresses,
-      ),
-    ~onError=(am, ~exn) => {
-      Logging.error({
-        "err": exn->Utils.prettifyExn,
-        "msg": `EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
-            ->Belt.Int.toString} seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
-        "source": name,
-        "chainId": chain->ChainMap.Chain.toChainId,
-        "metadata": {
-          {
-            "asyncTaskName": "blockLoader: fetching block data - `getBlock` rpc call",
-            "suggestedFix": "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint.",
-          }
-        },
-      })
-    },
-  )
+  let makeBlockLoader = () =>
+    LazyLoader.make(
+      ~loaderFn=blockNumber =>
+        getKnownBlockWithBackoff(
+          ~provider,
+          ~sourceName=name,
+          ~chain,
+          ~backoffMsOnFailure=1000,
+          ~blockNumber,
+          ~lowercaseAddresses,
+        ),
+      ~onError=(am, ~exn) => {
+        Logging.error({
+          "err": exn->Utils.prettifyExn,
+          "msg": `EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
+              ->Belt.Int.toString} seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
+          "source": name,
+          "chainId": chain->ChainMap.Chain.toChainId,
+          "metadata": {
+            {
+              "asyncTaskName": "blockLoader: fetching block data - `getBlock` rpc call",
+              "suggestedFix": "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint.",
+            }
+          },
+        })
+      },
+    )
+
+  let blockLoader = ref(makeBlockLoader())
 
   let getEventBlockOrThrow = makeThrowingGetEventBlock(~getBlock=blockNumber =>
-    blockLoader->LazyLoader.get(blockNumber)
+    blockLoader.contents->LazyLoader.get(blockNumber)
   )
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
     ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
@@ -625,7 +628,7 @@ let make = (
 
     let firstBlockParentPromise =
       fromBlock > 0
-        ? blockLoader->LazyLoader.get(fromBlock - 1)->Promise.thenResolve(res => res->Some)
+        ? blockLoader.contents->LazyLoader.get(fromBlock - 1)->Promise.thenResolve(res => res->Some)
         : Promise.resolve(None)
 
     let {getLogSelectionOrThrow} = getSelectionConfig(selection)
@@ -636,7 +639,7 @@ let make = (
       ~toBlock=suggestedToBlock,
       ~addresses,
       ~topicQuery,
-      ~loadBlock=blockNumber => blockLoader->LazyLoader.get(blockNumber),
+      ~loadBlock=blockNumber => blockLoader.contents->LazyLoader.get(blockNumber),
       ~syncConfig,
       ~provider,
       ~mutSuggestedBlockIntervals,
@@ -873,8 +876,13 @@ let make = (
   }
 
   let getBlockHashes = (~blockNumbers, ~logger as _currentlyUnusedLogger) => {
+    // Clear cache by creating a fresh LazyLoader
+    // This is important, since we call this
+    // function when a reorg is detected
+    blockLoader := makeBlockLoader()
+
     blockNumbers
-    ->Array.map(blockNum => blockLoader->LazyLoader.get(blockNum))
+    ->Array.map(blockNum => blockLoader.contents->LazyLoader.get(blockNum))
     ->Promise.all
     ->Promise.thenResolve(blocks => {
       blocks

package/src/sources/RpcSource.res.js

@@ -533,22 +533,27 @@ function make(param) {
                 }
               });
         }), undefined, undefined, undefined, undefined);
-  var blockLoader = LazyLoader.make((function (blockNumber) {
-          return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000, lowercaseAddresses);
-        }), (function (am, exn) {
-          Logging.error({
-                err: Utils.prettifyExn(exn),
-                msg: "EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
-                source: name,
-                chainId: chain,
-                metadata: {
-                  asyncTaskName: "blockLoader: fetching block data - `getBlock` rpc call",
-                  suggestedFix: "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint."
-                }
-              });
-        }), undefined, undefined, undefined, undefined);
+  var makeBlockLoader = function () {
+    return LazyLoader.make((function (blockNumber) {
+                  return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000, lowercaseAddresses);
+                }), (function (am, exn) {
+                  Logging.error({
+                        err: Utils.prettifyExn(exn),
+                        msg: "EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
+                        source: name,
+                        chainId: chain,
+                        metadata: {
+                          asyncTaskName: "blockLoader: fetching block data - `getBlock` rpc call",
+                          suggestedFix: "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint."
+                        }
+                      });
+                }), undefined, undefined, undefined, undefined);
+  };
+  var blockLoader = {
+    contents: makeBlockLoader()
+  };
   var getEventBlockOrThrow = makeThrowingGetEventBlock(function (blockNumber) {
-        return LazyLoader.get(blockLoader, blockNumber);
+        return LazyLoader.get(blockLoader.contents, blockNumber);
       });
   var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((function (__x) {
               return LazyLoader.get(transactionLoader, __x);
@@ -601,13 +606,13 @@ function make(param) {
     var suggestedBlockInterval = maxSuggestedBlockInterval !== undefined ? maxSuggestedBlockInterval : Belt_Option.getWithDefault(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval);
     var toBlock$1 = toBlock !== undefined && toBlock < currentBlockHeight ? toBlock : currentBlockHeight;
     var suggestedToBlock = Caml.int_max(Caml.int_min((fromBlock + suggestedBlockInterval | 0) - 1 | 0, toBlock$1), fromBlock);
-    var firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader, fromBlock - 1 | 0).then(function (res) {
+    var firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(function (res) {
             return res;
           }) : Promise.resolve(undefined);
     var match = getSelectionConfig(selection);
     var match$1 = match.getLogSelectionOrThrow(addressesByContractName);
     var match$2 = await getNextPage(fromBlock, suggestedToBlock, match$1.addresses, match$1.topicQuery, (function (blockNumber) {
-            return LazyLoader.get(blockLoader, blockNumber);
+            return LazyLoader.get(blockLoader.contents, blockNumber);
           }), syncConfig, provider, mutSuggestedBlockIntervals, partitionId);
     var latestFetchedBlock = match$2.latestFetchedBlock;
     var logs = match$2.logs;
@@ -784,8 +789,9 @@ function make(param) {
           };
   };
   var getBlockHashes = function (blockNumbers, _currentlyUnusedLogger) {
+    blockLoader.contents = makeBlockLoader();
     return $$Promise.$$catch(Promise.all(Belt_Array.map(blockNumbers, (function (blockNum) {
-                            return LazyLoader.get(blockLoader, blockNum);
+                            return LazyLoader.get(blockLoader.contents, blockNum);
                           }))).then(function (blocks) {
                     return {
                             TAG: "Ok",