envio 2.28.0-alpha.3 → 2.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.28.0-alpha.3",
+  "version": "v2.28.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,13 +25,13 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.28.0-alpha.3",
-    "envio-linux-arm64": "v2.28.0-alpha.3",
-    "envio-darwin-x64": "v2.28.0-alpha.3",
-    "envio-darwin-arm64": "v2.28.0-alpha.3"
+    "envio-linux-x64": "v2.28.0",
+    "envio-linux-arm64": "v2.28.0",
+    "envio-darwin-x64": "v2.28.0",
+    "envio-darwin-arm64": "v2.28.0"
   },
   "dependencies": {
-    "@envio-dev/hypersync-client": "0.6.5",
+    "@envio-dev/hypersync-client": "0.6.6",
     "rescript": "11.1.3",
     "rescript-schema": "9.3.0",
     "viem": "2.21.0",

package/src/Batch.res

@@ -0,0 +1,146 @@
+type progressedChain = {
+  chainId: int,
+  batchSize: int,
+  progressBlockNumber: int,
+  progressNextBlockLogIndex: option<int>,
+  totalEventsProcessed: int,
+}
+
+type t = {
+  items: array<Internal.eventItem>,
+  progressedChains: array<progressedChain>,
+  fetchStates: ChainMap.t<FetchState.t>,
+  dcsToStoreByChainId: dict<array<FetchState.indexingContract>>,
+}
+
+type multiChainEventComparitor = {
+  chain: ChainMap.Chain.t,
+  earliestEvent: FetchState.queueItem,
+}
+
+let getComparitorFromItem = (queueItem: Internal.eventItem) => {
+  let {timestamp, chain, blockNumber, logIndex} = queueItem
+  EventUtils.getEventComparator({
+    timestamp,
+    chainId: chain->ChainMap.Chain.toChainId,
+    blockNumber,
+    logIndex,
+  })
+}
+
+let getQueueItemComparitor = (earliestQueueItem: FetchState.queueItem, ~chain) => {
+  switch earliestQueueItem {
+  | Item({item}) => item->getComparitorFromItem
+  | NoItem({latestFetchedBlock: {blockTimestamp, blockNumber}}) => (
+      blockTimestamp,
+      chain->ChainMap.Chain.toChainId,
+      blockNumber,
+      0,
+    )
+  }
+}
+
+let isQueueItemEarlier = (a: multiChainEventComparitor, b: multiChainEventComparitor): bool => {
+  a.earliestEvent->getQueueItemComparitor(~chain=a.chain) <
+    b.earliestEvent->getQueueItemComparitor(~chain=b.chain)
+}
+
+/**
+ It either returnes an earliest item among all chains, or None if no chains are actively indexing
+ */
+let getOrderedNextItem = (fetchStates: ChainMap.t<FetchState.t>): option<
+  multiChainEventComparitor,
+> => {
+  fetchStates
+  ->ChainMap.entries
+  ->Belt.Array.reduce(None, (accum, (chain, fetchState)) => {
+    // If the fetch state has reached the end block we don't need to consider it
+    if fetchState->FetchState.isActivelyIndexing {
+      let earliestEvent = fetchState->FetchState.getEarliestEvent
+      let current: multiChainEventComparitor = {chain, earliestEvent}
+      switch accum {
+      | Some(previous) if isQueueItemEarlier(previous, current) => accum
+      | _ => Some(current)
+      }
+    } else {
+      accum
+    }
+  })
+}
+
+let popOrderedBatchItems = (
+  ~maxBatchSize,
+  ~fetchStates: ChainMap.t<FetchState.t>,
+  ~sizePerChain: dict<int>,
+) => {
+  let items = []
+
+  let rec loop = () =>
+    if items->Array.length < maxBatchSize {
+      switch fetchStates->getOrderedNextItem {
+      | Some({earliestEvent}) =>
+        switch earliestEvent {
+        | NoItem(_) => ()
+        | Item({item, popItemOffQueue}) => {
+            popItemOffQueue()
+            items->Js.Array2.push(item)->ignore
+            sizePerChain->Utils.Dict.incrementByInt(item.chain->ChainMap.Chain.toChainId)
+            loop()
+          }
+        }
+      | _ => ()
+      }
+    }
+  loop()
+
+  items
+}
+
+let popUnorderedBatchItems = (
+  ~maxBatchSize,
+  ~fetchStates: ChainMap.t<FetchState.t>,
+  ~sizePerChain: dict<int>,
+) => {
+  let items = []
+
+  let preparedFetchStates =
+    fetchStates
+    ->ChainMap.values
+    ->FetchState.filterAndSortForUnorderedBatch(~maxBatchSize)
+
+  let idx = ref(0)
+  let preparedNumber = preparedFetchStates->Array.length
+  let batchSize = ref(0)
+
+  // Accumulate items for all actively indexing chains
+  // the way to group as many items from a single chain as possible
+  // This way the loaders optimisations will hit more often
+  while batchSize.contents < maxBatchSize && idx.contents < preparedNumber {
+    let fetchState = preparedFetchStates->Js.Array2.unsafe_get(idx.contents)
+    let batchSizeBeforeTheChain = batchSize.contents
+
+    let rec loop = () =>
+      if batchSize.contents < maxBatchSize {
+        let earliestEvent = fetchState->FetchState.getEarliestEvent
+        switch earliestEvent {
+        | NoItem(_) => ()
+        | Item({item, popItemOffQueue}) => {
+            popItemOffQueue()
+            items->Js.Array2.push(item)->ignore
+            batchSize := batchSize.contents + 1
+            loop()
+          }
+        }
+      }
+    loop()
+
+    let chainBatchSize = batchSize.contents - batchSizeBeforeTheChain
+    if chainBatchSize > 0 {
+      sizePerChain->Utils.Dict.setByInt(fetchState.chainId, chainBatchSize)
+    }
+
+    idx := idx.contents + 1
+  }
+
+  items
+}

package/src/Batch.res.js

@@ -0,0 +1,129 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Utils = require("./Utils.res.js");
+var Caml_obj = require("rescript/lib/js/caml_obj.js");
+var ChainMap = require("./ChainMap.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var EventUtils = require("./EventUtils.res.js");
+var FetchState = require("./FetchState.res.js");
+
+function getComparitorFromItem(queueItem) {
+  return EventUtils.getEventComparator({
+              timestamp: queueItem.timestamp,
+              chainId: queueItem.chain,
+              blockNumber: queueItem.blockNumber,
+              logIndex: queueItem.logIndex
+            });
+}
+
+function getQueueItemComparitor(earliestQueueItem, chain) {
+  if (earliestQueueItem.TAG === "Item") {
+    return getComparitorFromItem(earliestQueueItem._0.item);
+  }
+  var match = earliestQueueItem.latestFetchedBlock;
+  return [
+          match.blockTimestamp,
+          chain,
+          match.blockNumber,
+          0
+        ];
+}
+
+function isQueueItemEarlier(a, b) {
+  return Caml_obj.lessthan(getQueueItemComparitor(a.earliestEvent, a.chain), getQueueItemComparitor(b.earliestEvent, b.chain));
+}
+
+function getOrderedNextItem(fetchStates) {
+  return Belt_Array.reduce(ChainMap.entries(fetchStates), undefined, (function (accum, param) {
+                var fetchState = param[1];
+                if (!FetchState.isActivelyIndexing(fetchState)) {
+                  return accum;
+                }
+                var earliestEvent = FetchState.getEarliestEvent(fetchState);
+                var current_chain = param[0];
+                var current = {
+                  chain: current_chain,
+                  earliestEvent: earliestEvent
+                };
+                if (accum !== undefined && isQueueItemEarlier(accum, current)) {
+                  return accum;
+                } else {
+                  return current;
+                }
+              }));
+}
+
+function popOrderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
+  var items = [];
+  var loop = function () {
+    while(true) {
+      if (items.length >= maxBatchSize) {
+        return ;
+      }
+      var match = getOrderedNextItem(fetchStates);
+      if (match === undefined) {
+        return ;
+      }
+      var earliestEvent = match.earliestEvent;
+      if (earliestEvent.TAG !== "Item") {
+        return ;
+      }
+      var match$1 = earliestEvent._0;
+      var item = match$1.item;
+      match$1.popItemOffQueue();
+      items.push(item);
+      Utils.Dict.incrementByInt(sizePerChain, item.chain);
+      continue ;
+    };
+  };
+  loop();
+  return items;
+}
+
+function popUnorderedBatchItems(maxBatchSize, fetchStates, sizePerChain) {
+  var items = [];
+  var preparedFetchStates = FetchState.filterAndSortForUnorderedBatch(ChainMap.values(fetchStates), maxBatchSize);
+  var idx = 0;
+  var preparedNumber = preparedFetchStates.length;
+  var batchSize = {
+    contents: 0
+  };
+  while(batchSize.contents < maxBatchSize && idx < preparedNumber) {
+    var fetchState = preparedFetchStates[idx];
+    var batchSizeBeforeTheChain = batchSize.contents;
+    var loop = (function(fetchState){
+    return function loop() {
+      while(true) {
+        if (batchSize.contents >= maxBatchSize) {
+          return ;
+        }
+        var earliestEvent = FetchState.getEarliestEvent(fetchState);
+        if (earliestEvent.TAG !== "Item") {
+          return ;
+        }
+        var match = earliestEvent._0;
+        match.popItemOffQueue();
+        items.push(match.item);
+        batchSize.contents = batchSize.contents + 1 | 0;
+        continue ;
+      };
+    }
+    }(fetchState));
+    loop();
+    var chainBatchSize = batchSize.contents - batchSizeBeforeTheChain | 0;
+    if (chainBatchSize > 0) {
+      sizePerChain[fetchState.chainId] = chainBatchSize;
+    }
+    idx = idx + 1 | 0;
+  };
+  return items;
+}
+
+exports.getComparitorFromItem = getComparitorFromItem;
+exports.getQueueItemComparitor = getQueueItemComparitor;
+exports.isQueueItemEarlier = isQueueItemEarlier;
+exports.getOrderedNextItem = getOrderedNextItem;
+exports.popOrderedBatchItems = popOrderedBatchItems;
+exports.popUnorderedBatchItems = popUnorderedBatchItems;
+/* Utils Not a pure module */

package/src/FetchState.res

@@ -1271,3 +1271,18 @@ let filterAndSortForUnorderedBatch = {
     })
   }
 }
+
+let getProgressBlockNumber = ({latestFullyFetchedBlock, queue}: t) => {
+  switch queue->Utils.Array.last {
+  | Some(item) if latestFullyFetchedBlock.blockNumber >= item.blockNumber => item.blockNumber - 1
+  | _ => latestFullyFetchedBlock.blockNumber
+  }
+}
+
+let getProgressNextBlockLogIndex = ({queue, latestFullyFetchedBlock}: t) => {
+  switch queue->Utils.Array.last {
+  | Some(item) if latestFullyFetchedBlock.blockNumber >= item.blockNumber && item.logIndex > 0 =>
+    Some(item.logIndex - 1)
+  | _ => None
+  }
+}

package/src/FetchState.res.js

@@ -960,6 +960,24 @@ function filterAndSortForUnorderedBatch(fetchStates, maxBatchSize) {
             });
 }
 
+function getProgressBlockNumber(param) {
+  var latestFullyFetchedBlock = param.latestFullyFetchedBlock;
+  var item = Utils.$$Array.last(param.queue);
+  if (item !== undefined && latestFullyFetchedBlock.blockNumber >= item.blockNumber) {
+    return item.blockNumber - 1 | 0;
+  } else {
+    return latestFullyFetchedBlock.blockNumber;
+  }
+}
+
+function getProgressNextBlockLogIndex(param) {
+  var item = Utils.$$Array.last(param.queue);
+  if (item !== undefined && param.latestFullyFetchedBlock.blockNumber >= item.blockNumber && item.logIndex > 0) {
+    return item.logIndex - 1 | 0;
+  }
+  
+}
+
 exports.copy = copy;
 exports.mergeIntoPartition = mergeIntoPartition;
 exports.checkIsWithinSyncRange = checkIsWithinSyncRange;
@@ -990,4 +1008,6 @@ exports.rollback = rollback;
 exports.isActivelyIndexing = isActivelyIndexing;
 exports.isReadyToEnterReorgThreshold = isReadyToEnterReorgThreshold;
 exports.filterAndSortForUnorderedBatch = filterAndSortForUnorderedBatch;
+exports.getProgressBlockNumber = getProgressBlockNumber;
+exports.getProgressNextBlockLogIndex = getProgressNextBlockLogIndex;
 /* Utils Not a pure module */

package/src/Hasura.res

@@ -227,38 +227,22 @@ let trackDatabase = async (
   ~responseLimit,
   ~schema,
 ) => {
-  let trackOnlyInternalTableNames = [
-    InternalTable.Chains.table.tableName,
-    InternalTable.EventSyncState.table.tableName,
-    InternalTable.PersistedState.table.tableName,
-    InternalTable.EndOfBlockRangeScannedData.table.tableName,
-    InternalTable.DynamicContractRegistry.table.tableName,
-  ]
   let exposedInternalTableNames = [
     InternalTable.RawEvents.table.tableName,
     InternalTable.Views.metaViewName,
     InternalTable.Views.chainMetadataViewName,
   ]
   let userTableNames = userEntities->Js.Array2.map(entity => entity.table.tableName)
+  let tableNames = [exposedInternalTableNames, userTableNames]->Belt.Array.concatMany
 
   Logging.info("Tracking tables in Hasura")
 
   let _ = await clearHasuraMetadata(~endpoint, ~auth)
 
-  await trackTables(
-    ~endpoint,
-    ~auth,
-    ~pgSchema,
-    ~tableNames=[
-      exposedInternalTableNames,
-      trackOnlyInternalTableNames,
-      userTableNames,
-    ]->Belt.Array.concatMany,
-  )
+  await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
 
   let _ =
-    await [exposedInternalTableNames, userTableNames]
-    ->Belt.Array.concatMany
+    await tableNames
     ->Js.Array2.map(tableName =>
       createSelectPermissions(
         ~endpoint,

package/src/Hasura.res.js

@@ -205,13 +205,6 @@ async function createEntityRelationship(pgSchema, endpoint, auth, tableName, rel
 }
 
 async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
-  var trackOnlyInternalTableNames = [
-    InternalTable.Chains.table.tableName,
-    InternalTable.EventSyncState.table.tableName,
-    InternalTable.PersistedState.table.tableName,
-    InternalTable.EndOfBlockRangeScannedData.table.tableName,
-    InternalTable.DynamicContractRegistry.table.tableName
-  ];
   var exposedInternalTableNames = [
     InternalTable.RawEvents.table.tableName,
     InternalTable.Views.metaViewName,
@@ -220,17 +213,14 @@ async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEn
   var userTableNames = userEntities.map(function (entity) {
         return entity.table.tableName;
       });
+  var tableNames = Belt_Array.concatMany([
+        exposedInternalTableNames,
+        userTableNames
+      ]);
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
-  await trackTables(endpoint, auth, pgSchema, Belt_Array.concatMany([
-            exposedInternalTableNames,
-            trackOnlyInternalTableNames,
-            userTableNames
-          ]));
-  await Promise.all(Caml_splice_call.spliceObjApply(Belt_Array.concatMany([
-                  exposedInternalTableNames,
-                  userTableNames
-                ]).map(function (tableName) {
+  await trackTables(endpoint, auth, pgSchema, tableNames);
+  await Promise.all(Caml_splice_call.spliceObjApply(tableNames.map(function (tableName) {
                 return createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities);
               }), "concat", [userEntities.map(function (entityConfig) {
                   var match = entityConfig.table;

package/src/InternalConfig.res

@@ -18,3 +18,13 @@ type chain = {
   contracts: array<contract>,
   sources: array<Source.t>,
 }
+
+type sourceSync = {
+  initialBlockInterval: int,
+  backoffMultiplicative: float,
+  accelerationAdditive: int,
+  intervalCeiling: int,
+  backoffMillis: int,
+  queryTimeoutMillis: int,
+  fallbackStallTimeout: int,
+}

package/src/Persistence.res

@@ -32,7 +32,7 @@ type storage = {
     ~entities: array<Internal.entityConfig>=?,
     ~enums: array<Internal.enumConfig<Internal.enum>>=?,
   ) => promise<initialState>,
-  loadInitialState: unit => promise<initialState>,
+  resumeInitialState: unit => promise<initialState>,
   @raises("StorageError")
   loadByIdsOrThrow: 'item. (
     ~ids: array<string>,
@@ -123,14 +123,12 @@ let init = {
         persistence.storageStatus = Initializing(promise)
         if reset || !(await persistence.storage.isInitialized()) {
           Logging.info(`Initializing the indexer storage...`)
-
           let initialState = await persistence.storage.initialize(
             ~entities=persistence.allEntities,
             ~enums=persistence.allEnums,
             ~chainConfigs,
           )
-
-          Logging.info(`The indexer storage is ready. Uploading cache...`)
+          Logging.info(`The indexer storage is ready. Starting indexing!`)
           persistence.storageStatus = Ready(initialState)
         } else if (
           // In case of a race condition,
@@ -140,8 +138,29 @@ let init = {
           | _ => false
           }
         ) {
-          Logging.info(`The indexer storage is ready.`)
-          persistence.storageStatus = Ready(await persistence.storage.loadInitialState())
+          Logging.info(`Found existing indexer storage. Resuming indexing state...`)
+          let initialState = await persistence.storage.resumeInitialState()
+          persistence.storageStatus = Ready(initialState)
+          let checkpoints = Js.Dict.empty()
+          initialState.chains->Js.Array2.forEach(c => {
+            let checkpoint = switch c.progressNextBlockLogIndex {
+            | Value(
+                logIndex,
+              ) => // Latest processed log index (not necessarily processed by the indexer)
+              {
+                "blockNumber": c.progressBlockNumber + 1,
+                "logIndex": logIndex,
+              }
+            | Null =>
+              // Or simply the latest processed block number (might be -1 if not set)
+              c.progressBlockNumber->Utils.magic
+            }
+            checkpoints->Utils.Dict.setByInt(c.id, checkpoint)
+          })
+          Logging.info({
+            "msg": `Successfully resumed indexing state! Continuing from the last checkpoint.`,
+            "checkpoints": checkpoints,
+          })
         }
         resolveRef.contents()
       }

package/src/Persistence.res.js

@@ -66,7 +66,7 @@ async function init(persistence, chainConfigs, resetOpt) {
     if (reset || !await persistence.storage.isInitialized()) {
       Logging.info("Initializing the indexer storage...");
       var initialState = await persistence.storage.initialize(chainConfigs, persistence.allEntities, persistence.allEnums);
-      Logging.info("The indexer storage is ready. Uploading cache...");
+      Logging.info("The indexer storage is ready. Starting indexing!");
       persistence.storageStatus = {
         TAG: "Ready",
         _0: initialState
@@ -76,11 +76,26 @@ async function init(persistence, chainConfigs, resetOpt) {
       var tmp;
       tmp = typeof match !== "object" || match.TAG !== "Initializing" ? false : true;
       if (tmp) {
-        Logging.info("The indexer storage is ready.");
+        Logging.info("Found existing indexer storage. Resuming indexing state...");
+        var initialState$1 = await persistence.storage.resumeInitialState();
         persistence.storageStatus = {
           TAG: "Ready",
-          _0: await persistence.storage.loadInitialState()
+          _0: initialState$1
         };
+        var checkpoints = {};
+        initialState$1.chains.forEach(function (c) {
+              var logIndex = c._progress_log_index;
+              var checkpoint;
+              checkpoint = logIndex === null ? c.progress_block : ({
+                    blockNumber: c.progress_block + 1 | 0,
+                    logIndex: logIndex
+                  });
+              checkpoints[c.id] = checkpoint;
+            });
+        Logging.info({
+              msg: "Successfully resumed indexing state! Continuing from the last checkpoint.",
+              checkpoints: checkpoints
+            });
       }
       
     }

package/src/PgStorage.res

@@ -63,7 +63,6 @@ let makeInitializeTransaction = (
   ~isEmptyPgSchema=false,
 ) => {
   let generalTables = [
-    InternalTable.EventSyncState.table,
     InternalTable.Chains.table,
     InternalTable.PersistedState.table,
     InternalTable.EndOfBlockRangeScannedData.table,
@@ -566,10 +565,10 @@ let make = (
   ])
 
   let isInitialized = async () => {
-    let envioTables =
-      await sql->Postgres.unsafe(
-        `SELECT table_schema FROM information_schema.tables WHERE table_schema = '${pgSchema}' AND table_name = '${InternalTable.EventSyncState.table.tableName}' OR table_name = '${InternalTable.Chains.table.tableName}';`,
-      )
+    let envioTables = await sql->Postgres.unsafe(
+      `SELECT table_schema FROM information_schema.tables WHERE table_schema = '${pgSchema}' AND table_name = '${// This is for indexer before envio@2.28
+        "event_sync_state"}' OR table_name = '${InternalTable.Chains.table.tableName}';`,
+    )
     envioTables->Utils.Array.notEmpty
   }
 
@@ -671,7 +670,9 @@ let make = (
         // This means that the schema is used for something else than envio.
         !(
           schemaTableNames->Js.Array2.some(table =>
-            table.tableName === InternalTable.EventSyncState.table.tableName
+            table.tableName === InternalTable.Chains.table.tableName ||
+              // Case for indexer before envio@2.28
+              table.tableName === "event_sync_state"
           )
         )
     ) {
@@ -893,7 +894,7 @@ let make = (
     }
   }
 
-  let loadInitialState = async (): Persistence.initialState => {
+  let resumeInitialState = async (): Persistence.initialState => {
     let (cache, chains) = await Promise.all2((
       restoreEffectCache(~withUpload=false),
       sql
@@ -903,6 +904,13 @@ let make = (
       ->(Utils.magic: promise<array<unknown>> => promise<array<InternalTable.Chains.t>>),
     ))
 
+    if chains->Utils.Array.notEmpty {
+      let () =
+        await sql->Postgres.unsafe(
+          InternalTable.DynamicContractRegistry.makeCleanUpOnRestartQuery(~pgSchema, ~chains),
+        )
+    }
+
     {
       cleanRun: false,
       cache,
@@ -913,7 +921,7 @@ let make = (
   {
     isInitialized,
     initialize,
-    loadInitialState,
+    resumeInitialState,
     loadByFieldOrThrow,
     loadByIdsOrThrow,
     setOrThrow,

package/src/PgStorage.res.js

@@ -75,7 +75,6 @@ function makeInitializeTransaction(pgSchema, pgUser, chainConfigsOpt, entitiesOp
   var enums = enumsOpt !== undefined ? enumsOpt : [];
   var isEmptyPgSchema = isEmptyPgSchemaOpt !== undefined ? isEmptyPgSchemaOpt : false;
   var generalTables = [
-    InternalTable.EventSyncState.table,
     InternalTable.Chains.table,
     InternalTable.PersistedState.table,
     InternalTable.EndOfBlockRangeScannedData.table,
@@ -395,7 +394,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
   };
   var cacheDirPath = Path.resolve("..", ".envio", "cache");
   var isInitialized = async function () {
-    var envioTables = await sql.unsafe("SELECT table_schema FROM information_schema.tables WHERE table_schema = '" + pgSchema + "' AND table_name = '" + InternalTable.EventSyncState.table.tableName + "' OR table_name = '" + InternalTable.Chains.table.tableName + "';");
+    var envioTables = await sql.unsafe("SELECT table_schema FROM information_schema.tables WHERE table_schema = '" + pgSchema + "' AND table_name = 'event_sync_state' OR table_name = '" + InternalTable.Chains.table.tableName + "';");
     return Utils.$$Array.notEmpty(envioTables);
   };
   var restoreEffectCache = async function (withUpload) {
@@ -482,7 +481,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
     var enums = enumsOpt !== undefined ? enumsOpt : [];
     var schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
     if (Utils.$$Array.notEmpty(schemaTableNames) && !schemaTableNames.some(function (table) {
-            return table.table_name === InternalTable.EventSyncState.table.tableName;
+            return table.table_name === InternalTable.Chains.table.tableName ? true : table.table_name === "event_sync_state";
           })) {
       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.");
     }
@@ -634,21 +633,25 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, onI
       return Logging.errorWithExn(Utils.prettifyExn(exn$1), "Failed to dump cache.");
     }
   };
-  var loadInitialState = async function () {
+  var resumeInitialState = async function () {
     var match = await Promise.all([
           restoreEffectCache(false),
           sql.unsafe(makeLoadAllQuery(pgSchema, InternalTable.Chains.table.tableName))
         ]);
+    var chains = match[1];
+    if (Utils.$$Array.notEmpty(chains)) {
+      await sql.unsafe(InternalTable.DynamicContractRegistry.makeCleanUpOnRestartQuery(pgSchema, chains));
+    }
     return {
             cleanRun: false,
             cache: match[0],
-            chains: match[1]
+            chains: chains
           };
   };
   return {
           isInitialized: isInitialized,
           initialize: initialize,
-          loadInitialState: loadInitialState,
+          resumeInitialState: resumeInitialState,
           loadByIdsOrThrow: loadByIdsOrThrow,
           loadByFieldOrThrow: loadByFieldOrThrow,
           setOrThrow: setOrThrow$1,

package/src/Throttler.res

@@ -30,7 +30,10 @@ let rec startInternal = async (throttler: t) => {
       switch await fn() {
       | exception exn =>
         throttler.logger->Pino.errorExn(
-          Pino.createPinoMessageWithError("Scheduled action failed in throttler", exn),
+          Pino.createPinoMessageWithError(
+            "Scheduled action failed in throttler",
+            exn->Utils.prettifyExn,
+          ),
         )
       | _ => ()
       }