envio 3.5.0-alpha.2 → 3.5.0-rc.0

package/src/CrossChainState.res.mjs

@@ -4,7 +4,6 @@ import * as Env from "./Env.res.mjs";
 import * as Batch from "./Batch.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as ChainMap from "./ChainMap.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -27,6 +26,7 @@ function make(chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt)
     chainStates: chainStates,
     chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
     isRealtime: isRealtime,
+    isCaughtUp: isRealtime,
     isInReorgThreshold: isInReorgThreshold,
     targetBufferSize: targetBufferSize
   };
@@ -40,6 +40,10 @@ function isRealtime(crossChainState) {
   return crossChainState.isRealtime;
 }
 
+function isCaughtUp(crossChainState) {
+  return crossChainState.isCaughtUp;
+}
+
 function isInReorgThreshold(crossChainState) {
   return crossChainState.isInReorgThreshold;
 }
@@ -104,20 +108,58 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
       everyChainCaughtUp = false;
     }
   }
-  let indexerCaughtUp = nextItemIsNone(crossChainState) && everyChainCaughtUp;
+  crossChainState.isCaughtUp = crossChainState.isCaughtUp || nextItemIsNone(crossChainState) && everyChainCaughtUp;
   let allChainsReady = true;
   for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
-    let cs$1 = crossChainState.chainStates[chainIds[i$1]];
-    if (indexerCaughtUp) {
-      ChainState.markReady(cs$1);
-    }
-    if (!ChainState.isReady(cs$1)) {
+    if (!ChainState.isReady(crossChainState.chainStates[chainIds[i$1]])) {
       allChainsReady = false;
     }
   }
   crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady;
 }
 
+function isSettledAtHead(crossChainState) {
+  let settled = nextItemIsNone(crossChainState);
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    if (!ChainState.isFetchingAtHead(crossChainState.chainStates[crossChainState.chainIds[i]])) {
+      settled = false;
+    }
+  }
+  return settled;
+}
+
+function markCaughtUpIfSettled(crossChainState) {
+  if (isSettledAtHead(crossChainState)) {
+    crossChainState.isCaughtUp = true;
+    return;
+  }
+}
+
+function markCaughtUpOnResume(crossChainState) {
+  let everyChainCaughtUp = crossChainState.chainIds.length !== 0;
+  let everyChainReady = true;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    if (!ChainState.isDurablyCaughtUp(cs)) {
+      everyChainCaughtUp = false;
+    }
+    if (!ChainState.isReady(cs)) {
+      everyChainReady = false;
+    }
+  }
+  if (everyChainCaughtUp && !everyChainReady && nextItemIsNone(crossChainState)) {
+    crossChainState.isCaughtUp = true;
+    return;
+  }
+}
+
+function markReady(crossChainState, readyAt) {
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    ChainState.markReady(crossChainState.chainStates[crossChainState.chainIds[i]], readyAt);
+  }
+  crossChainState.isRealtime = true;
+}
+
 function priorityOrder(crossChainState) {
   return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(ChainState.frontierProgress(a), ChainState.frontierProgress(b)));
 }
@@ -203,15 +245,8 @@ async function checkAndFetch(crossChainState, dispatchChain) {
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let chainId = crossChainState.chainIds[i];
     let action = actionByChain[chainId];
-    if (action !== undefined) {
-      let exit = 0;
-      if (typeof action === "object" || action === "WaitingForNewBlock") {
-        exit = 1;
-      }
-      if (exit === 1) {
-        let chain = ChainMap.Chain.makeUnsafe(chainId);
-        promises.push(dispatchChain(chain, action));
-      }
+    if (action !== undefined && (typeof action === "object" || action === "WaitingForNewBlock")) {
+      promises.push(dispatchChain(chainId, action));
     }
   }
   await Promise.all(promises);
@@ -222,6 +257,7 @@ export {
   make,
   chainStates,
   isRealtime,
+  isCaughtUp,
   isInReorgThreshold,
   targetBufferSize,
   nextItemIsNone,
@@ -229,6 +265,9 @@ export {
   createBatch,
   enterReorgThreshold,
   applyBatchProgress,
+  markCaughtUpIfSettled,
+  markCaughtUpOnResume,
+  markReady,
   priorityOrder,
   checkAndFetch,
 }

package/src/CrossChainState.resi

@@ -15,6 +15,7 @@ let make: (
 // Accessors.
 let chainStates: t => dict<ChainState.t>
 let isRealtime: t => bool
+let isCaughtUp: t => bool
 let isInReorgThreshold: t => bool
 let targetBufferSize: t => int
 
@@ -31,10 +32,13 @@ let createBatch: (
 ) => Batch.t
 let enterReorgThreshold: t => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
+let markCaughtUpIfSettled: t => unit
+let markCaughtUpOnResume: t => unit
+let markReady: (t, ~readyAt: Date.t) => unit
 
 // Fetch control.
 let priorityOrder: t => array<ChainState.t>
 let checkAndFetch: (
   t,
-  ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
+  ~dispatchChain: (~chainId: ChainId.t, ~action: FetchState.nextQuery) => promise<unit>,
 ) => promise<unit>

package/src/Env.res

@@ -3,9 +3,6 @@
 
 %%private(let envSafe = EnvSafe.make())
 
-// resets the timestampCaughtUpToHeadOrEndblock after a restart when true
-let updateSyncTimeOnRestart =
-  envSafe->EnvSafe.get("UPDATE_SYNC_TIME_ON_RESTART", S.bool, ~fallback=true)
 let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.option(S.int))
 let maxAddrInPartition = envSafe->EnvSafe.get("MAX_PARTITION_SIZE", S.int, ~fallback=5_000)
 

package/src/Env.res.mjs

@@ -13,8 +13,6 @@ import 'dotenv/config'
 
 let envSafe = EnvSafe.make(undefined);
 
-let updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
-
 let targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.int), undefined, undefined, undefined, undefined);
 
 let maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.int, undefined, 5000, undefined, undefined);
@@ -221,7 +219,6 @@ EnvSafe.close(envSafe);
 let maxChainConcurrency = 100;
 
 export {
-  updateSyncTimeOnRestart,
   targetBufferSize,
   maxAddrInPartition,
   maxChainConcurrency,

package/src/EventConfigBuilder.res

@@ -342,7 +342,7 @@ let buildEvmOnEventRegistration = (
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
   ~where: option<JSON.t>,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
   ~startBlock: option<int>=?,
 ): Internal.evmOnEventRegistration => {

package/src/EventProcessing.res

@@ -13,7 +13,7 @@ let computeChainsState = (chainStates: dict<ChainState.t>): Internal.chains => {
   values->Array.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
     chains->Dict.set(
-      chainId->Int.toString,
+      chainId->ChainId.toString,
       {
         Internal.id: chainId,
         isRealtime,
@@ -280,7 +280,7 @@ let registerProcessEventBatchMetrics = (
   batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
     logger->Logging.childTrace({
       "msg": "Finished processing",
-      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "chainId": chainId,
       "batchSize": chainAfterBatch.batchSize,
       "progress": chainAfterBatch.progressBlockNumber,
     })
@@ -312,7 +312,7 @@ let materializeBatchEvents = async (
   | _ =>
     let itemsByChain: dict<array<Internal.item>> = Dict.make()
     batch.items->Array.forEach(item => {
-      let chainId = item->Internal.getItemChainId->Int.toString
+      let chainId = item->Internal.getItemChainId->ChainId.toString
       switch itemsByChain->Utils.Dict.dangerouslyGetNonOption(chainId) {
       | Some(items) => items->Array.push(item)
       | None => itemsByChain->Dict.set(chainId, [item])
@@ -345,7 +345,7 @@ let processEventBatch = async (
   batch.progressedChainsById->Dict.forEachWithKey((chainAfterBatch, chainId) => {
     logger->Logging.childTrace({
       "msg": "Started processing",
-      "chainId": chainId->Int.fromString->Option.getUnsafe,
+      "chainId": chainId,
       "batchSize": chainAfterBatch.batchSize,
     })
   })

package/src/EventProcessing.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -25,7 +25,7 @@ function computeChainsState(chainStates) {
   let isRealtime = values.every(ChainState.isReady);
   values.forEach(cs => {
     let chainId = ChainState.chainConfig(cs).id;
-    chains[chainId.toString()] = {
+    chains[ChainId.toString(chainId)] = {
       id: chainId,
       isRealtime: isRealtime
     };
@@ -179,7 +179,7 @@ async function runBatchHandlersOrThrow(batch, indexerState, loadManager, persist
 function registerProcessEventBatchMetrics(logger, batch, indexerState, loadDuration, handlerDuration) {
   Stdlib_Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, chainId) => Logging.childTrace(logger, {
     msg: "Finished processing",
-    chainId: Stdlib_Int.fromString(chainId, undefined),
+    chainId: chainId,
     batchSize: chainAfterBatch.batchSize,
     progress: chainAfterBatch.progressBlockNumber
   }));
@@ -191,7 +191,7 @@ async function materializeBatchEvents(batch, chainStates, ecosystem) {
   if (match.length !== 1) {
     let itemsByChain = {};
     batch.items.forEach(item => {
-      let chainId = Internal.getItemChainId(item).toString();
+      let chainId = ChainId.toString(Internal.getItemChainId(item));
       let items = itemsByChain[chainId];
       if (items !== undefined) {
         items.push(item);
@@ -214,7 +214,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
   let logger = Logging.getLogger();
   Stdlib_Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, chainId) => Logging.childTrace(logger, {
     msg: "Started processing",
-    chainId: Stdlib_Int.fromString(chainId, undefined),
+    chainId: chainId,
     batchSize: chainAfterBatch.batchSize
   }));
   try {