envio 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/LoadLayer.res

@@ -85,7 +85,7 @@ let callEffect = (
   )
 
   if hadActiveCalls {
-    let elapsed = Hrtime.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=timerRef)
+    let elapsed = Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=timerRef)
     if elapsed > 0. {
       Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
         ~labels=effectName,
@@ -113,17 +113,17 @@ let callEffect = (
       ~labels=effectName,
       ~value=effect.activeCallsCount,
     )
-    let newTimer = Hrtime.makeTimer()
+    let newTimer = Performance.now()
     Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
       ~labels=effectName,
-      ~value=Hrtime.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=newTimer),
+      ~value=Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=newTimer),
     )
     effect.prevCallStartTimerRef = newTimer
 
     Prometheus.EffectCalls.totalCallsCount->Prometheus.SafeCounter.increment(~labels=effectName)
     Prometheus.EffectCalls.sumTimeCounter->Prometheus.SafeCounter.handleFloat(
       ~labels=effectName,
-      ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~value=timerRef->Performance.secondsSince,
     )
   })
 }
@@ -137,7 +137,7 @@ let rec executeWithRateLimit = (
 ) => {
   let effectName = effect.name
 
-  let timerRef = Hrtime.makeTimer()
+  let timerRef = Performance.now()
   let promises = []
 
   switch effect.rateLimit {

package/src/LoadLayer.res.mjs

@@ -2,11 +2,11 @@
 
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
@@ -55,7 +55,7 @@ function callEffect(effect, arg, inMemTable, timerRef, onError) {
   effect.activeCallsCount = effect.activeCallsCount + 1 | 0;
   Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
   if (hadActiveCalls) {
-    let elapsed = Hrtime.secondsBetween(effect.prevCallStartTimerRef, timerRef);
+    let elapsed = Performance.secondsBetween(effect.prevCallStartTimerRef, timerRef);
     if (elapsed > 0) {
       Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, elapsed);
     }
@@ -64,17 +64,17 @@ function callEffect(effect, arg, inMemTable, timerRef, onError) {
   return effect.handler(arg).then(output => InMemoryStore.setEffectOutput(inMemTable, arg.checkpointId, arg.cacheKey, output, arg.context.cache)).catch(exn => onError(arg.cacheKey, exn)).finally(() => {
     effect.activeCallsCount = effect.activeCallsCount - 1 | 0;
     Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
-    let newTimer = Hrtime.makeTimer();
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Hrtime.secondsBetween(effect.prevCallStartTimerRef, newTimer));
+    let newTimer = Performance.now();
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Performance.secondsBetween(effect.prevCallStartTimerRef, newTimer));
     effect.prevCallStartTimerRef = newTimer;
     Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, effectName);
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Performance.secondsSince(timerRef));
   });
 }
 
 function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQueue) {
   let effectName = effect.name;
-  let timerRef = Hrtime.makeTimer();
+  let timerRef = Performance.now();
   let promises = [];
   let state = effect.rateLimit;
   if (state !== undefined) {

package/src/Main.res

@@ -1,19 +1,4 @@
-type chainData = {
-  chainId: float,
-  poweredByHyperSync: bool,
-  firstEventBlockNumber: option<int>,
-  latestProcessedBlock: option<int>,
-  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
-  numEventsProcessed: float,
-  latestFetchedBlockNumber: int,
-  // Need this for API backwards compatibility
-  @as("currentBlockHeight")
-  knownHeight: int,
-  numBatchesFetched: int,
-  startBlock: int,
-  endBlock: option<int>,
-  numAddresses: int,
-}
+type chainData = ChainState.chainData
 @tag("status")
 type state =
   | @as("disabled") Disabled({})
@@ -183,7 +168,7 @@ let buildChainsObject = (~config: Config.t) => {
             | Some(state) => {
                 let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
                 let chainState = state->IndexerState.getChainState(~chain)
-                let indexingAddresses = (chainState->ChainState.fetchState).indexingAddresses
+                let indexingAddresses = chainState->ChainState.indexingAddresses
 
                 // Collect all addresses for this contract name from indexingAddresses
                 let addresses = []
@@ -780,39 +765,7 @@ let start = async (
       | None => Initializing({})
       | Some(state) => {
           let chains =
-            state
-            ->IndexerState.chainStates
-            ->Dict.valuesToArray
-            ->Array.map(cs => {
-              let fetchState = cs->ChainState.fetchState
-              let latestFetchedBlockNumber = Pervasives.max(
-                FetchState.bufferBlockNumber(fetchState),
-                0,
-              )
-              let knownHeight =
-                cs->ChainState.hasProcessedToEndblock
-                  ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
-                  : fetchState.knownHeight
-
-              {
-                chainId: (cs->ChainState.chainConfig).id->Int.toFloat,
-                poweredByHyperSync: (
-                  cs->ChainState.sourceManager->SourceManager.getActiveSource
-                ).poweredByHyperSync,
-                latestFetchedBlockNumber,
-                knownHeight,
-                numBatchesFetched: 0,
-                startBlock: fetchState.startBlock,
-                endBlock: fetchState.endBlock,
-                firstEventBlockNumber: fetchState.firstEventBlock,
-                latestProcessedBlock: cs->ChainState.committedProgressBlockNumber === -1
-                  ? None
-                  : Some(cs->ChainState.committedProgressBlockNumber),
-                timestampCaughtUpToHeadOrEndblock: cs->ChainState.timestampCaughtUpToHeadOrEndblock,
-                numEventsProcessed: cs->ChainState.numEventsProcessed,
-                numAddresses: fetchState->FetchState.numAddresses,
-              }
-            })
+            state->IndexerState.chainStates->Dict.valuesToArray->Array.map(ChainState.toChainData)
           Active({
             envioVersion,
             chains,

package/src/Main.res.mjs

@@ -11,7 +11,6 @@ import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
@@ -20,8 +19,6 @@ import Yargs from "yargs/yargs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
-import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
-import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Helpers from "yargs/helpers";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
@@ -168,7 +165,7 @@ function buildChainsObject(config) {
           if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
-            let indexingAddresses = ChainState.fetchState(chainState).indexingAddresses;
+            let indexingAddresses = ChainState.indexingAddresses(chainState);
             let addresses = [];
             let values = Object.values(indexingAddresses);
             for (let idx = 0, idx_finish = values.length; idx < idx_finish; ++idx) {
@@ -586,25 +583,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
         };
       }
       let state$1 = Primitive_option.valFromOption(state);
-      let chains = Object.values(IndexerState.chainStates(state$1)).map(cs => {
-        let fetchState = ChainState.fetchState(cs);
-        let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
-        let knownHeight = ChainState.hasProcessedToEndblock(cs) ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
-        return {
-          chainId: ChainState.chainConfig(cs).id,
-          poweredByHyperSync: SourceManager.getActiveSource(ChainState.sourceManager(cs)).poweredByHyperSync,
-          firstEventBlockNumber: fetchState.firstEventBlock,
-          latestProcessedBlock: ChainState.committedProgressBlockNumber(cs) === -1 ? undefined : ChainState.committedProgressBlockNumber(cs),
-          timestampCaughtUpToHeadOrEndblock: ChainState.timestampCaughtUpToHeadOrEndblock(cs),
-          numEventsProcessed: ChainState.numEventsProcessed(cs),
-          latestFetchedBlockNumber: latestFetchedBlockNumber,
-          currentBlockHeight: knownHeight,
-          numBatchesFetched: 0,
-          startBlock: fetchState.startBlock,
-          endBlock: fetchState.endBlock,
-          numAddresses: FetchState.numAddresses(fetchState)
-        };
-      });
+      let chains = Object.values(IndexerState.chainStates(state$1)).map(ChainState.toChainData);
       return {
         status: "active",
         envioVersion: envioVersion,

package/src/PgStorage.res

@@ -1707,13 +1707,13 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     // Initialize sink if configured
     let sinkPromise = switch sink {
     | Some(sink) => {
-        let timerRef = Hrtime.makeTimer()
+        let timerRef = Performance.now()
         Some(
           sink.writeBatch(~batch, ~updatedEntities=chUpdates)
           ->Promise.thenResolve(_ => {
             Prometheus.StorageWrite.increment(
               ~storage=sink.name,
-              ~timeSeconds=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+              ~timeSeconds=timerRef->Performance.secondsSince,
             )
             None
           })
@@ -1724,7 +1724,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     | None => None
     }
 
-    let primaryTimerRef = Hrtime.makeTimer()
+    let primaryTimerRef = Performance.now()
     await writeBatch(
       sql,
       ~batch,
@@ -1741,7 +1741,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     )
     Prometheus.StorageWrite.increment(
       ~storage="postgres",
-      ~timeSeconds=primaryTimerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~timeSeconds=primaryTimerRef->Performance.secondsSince,
     )
   }
 

package/src/PgStorage.res.mjs

@@ -8,13 +8,13 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Hasura from "./Hasura.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
@@ -1116,16 +1116,16 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     }
     let sinkPromise;
     if (sink !== undefined) {
-      let timerRef = Hrtime.makeTimer();
+      let timerRef = Performance.now();
       sinkPromise = sink.writeBatch(batch, chUpdates).then(() => {
-        Prometheus.StorageWrite.increment(sink.name, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+        Prometheus.StorageWrite.increment(sink.name, Performance.secondsSince(timerRef));
       }).catch(exn => exn);
     } else {
       sinkPromise = undefined;
     }
-    let primaryTimerRef = Hrtime.makeTimer();
+    let primaryTimerRef = Performance.now();
     await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
-    return Prometheus.StorageWrite.increment("postgres", Hrtime.toSecondsFloat(Hrtime.timeSince(primaryTimerRef)));
+    return Prometheus.StorageWrite.increment("postgres", Performance.secondsSince(primaryTimerRef));
   };
   let close = () => sql.end();
   return {

package/src/Prometheus.res

@@ -212,7 +212,7 @@ module PreloadHandler = {
 
   type operationRef = {
     mutable pendingCount: int,
-    timerRef: Hrtime.timeRef,
+    timerRef: Performance.timeRef,
   }
   let operations: dict<operationRef> = Dict.make()
 
@@ -227,11 +227,11 @@ module PreloadHandler = {
         key,
         {
           pendingCount: 1,
-          timerRef: Hrtime.makeTimer(),
+          timerRef: Performance.now(),
         },
       )
     }
-    Hrtime.makeTimer()
+    Performance.now()
   }
 
   let endOperation = (timerRef, ~contract, ~event) => {
@@ -242,13 +242,13 @@ module PreloadHandler = {
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
         ~labels,
-        ~value=operationRef.timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+        ~value=operationRef.timerRef->Performance.secondsSince,
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
     sumTimeCounter->SafeCounter.handleFloat(
       ~labels,
-      ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~value=timerRef->Performance.secondsSince,
     )
     count->SafeCounter.increment(~labels)
   }
@@ -764,7 +764,7 @@ module StorageLoad = {
 
   type operationRef = {
     mutable pendingCount: int,
-    timerRef: Hrtime.timeRef,
+    timerRef: Performance.timeRef,
   }
   let operations = Dict.make()
 
@@ -780,12 +780,12 @@ module StorageLoad = {
         (
           {
             pendingCount: 1,
-            timerRef: Hrtime.makeTimer(),
+            timerRef: Performance.now(),
           }: operationRef
         ),
       )
     }
-    Hrtime.makeTimer()
+    Performance.now()
   }
 
   let endOperation = (timerRef, ~storage, ~operation, ~whereSize, ~size) => {
@@ -796,13 +796,13 @@ module StorageLoad = {
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
         ~labels,
-        ~value=operationRef.timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+        ~value=operationRef.timerRef->Performance.secondsSince,
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
     sumTimeCounter->SafeCounter.handleFloat(
       ~labels,
-      ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~value=timerRef->Performance.secondsSince,
     )
     counter->SafeCounter.increment(~labels)
     whereSizeCounter->SafeCounter.handleInt(~labels, ~value=whereSize)

package/src/Prometheus.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as PromClient from "./bindings/PromClient.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -290,10 +290,10 @@ function startOperation(contract, event) {
   } else {
     operations[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation(timerRef, contract, event) {
@@ -305,10 +305,10 @@ function endOperation(timerRef, contract, event) {
   let operationRef = operations[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$1, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$1, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations, key);
   }
-  handleFloat(sumTimeCounter, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  handleFloat(sumTimeCounter, labels, Performance.secondsSince(timerRef));
   increment(count$1, labels);
 }
 
@@ -775,10 +775,10 @@ function startOperation$1(storage, operation) {
   } else {
     operations$1[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation$1(timerRef, storage, operation, whereSize, size) {
@@ -790,10 +790,10 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
   let operationRef = operations$1[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$7, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$7, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations$1, key);
   }
-  handleFloat(sumTimeCounter$3, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  handleFloat(sumTimeCounter$3, labels, Performance.secondsSince(timerRef));
   increment(counter$8, labels);
   handleInt(whereSizeCounter, labels, whereSize);
   handleInt(sizeCounter$1, labels, size);

package/src/PruneStaleHistory.res

@@ -14,7 +14,7 @@ let runPrune = async (state: IndexerState.t) => {
         await Utils.delay(1000)
       }
       let entityConfig = persistence.allEntities->Array.getUnsafe(idx)
-      let timeRef = Hrtime.makeTimer()
+      let timeRef = Performance.now()
       try {
         let () = await persistence.storage.pruneStaleEntityHistory(
           ~entityName=entityConfig.name,
@@ -34,7 +34,7 @@ let runPrune = async (state: IndexerState.t) => {
         )
       }
       Prometheus.RollbackHistoryPrune.increment(
-        ~timeSeconds=Hrtime.timeSince(timeRef)->Hrtime.toSecondsFloat,
+        ~timeSeconds=Performance.secondsSince(timeRef),
         ~entityName=entityConfig.name,
       )
     }

package/src/PruneStaleHistory.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -21,7 +21,7 @@ async function runPrune(state) {
       await Utils.delay(1000);
     }
     let entityConfig = persistence.allEntities[idx];
-    let timeRef = Hrtime.makeTimer();
+    let timeRef = Performance.now();
     try {
       await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
     } catch (raw_exn) {
@@ -31,7 +31,7 @@ async function runPrune(state) {
         safeCheckpointId: safeCheckpointId
       }), `Failed to prune stale entity history`, exn);
     }
-    Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+    Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
   }
 }
 

package/src/Rollback.res

@@ -18,7 +18,7 @@ let getLastKnownValidBlock = async (
     ->ChainState.reorgDetection
     ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
       ~blockNumber=reorgBlockNumber,
-      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+      ~knownHeight=chainState->ChainState.knownHeight,
     )
 
   switch scannedBlockNumbers {
@@ -94,7 +94,7 @@ and executeRollback = async (
   ~scheduleFetch,
   ~scheduleProcessing,
 ) => {
-  let startTime = Hrtime.makeTimer()
+  let startTime = Performance.now()
 
   let chainState = state->IndexerState.getChainState(~chain=reorgChain)
 
@@ -194,7 +194,7 @@ and executeRollback = async (
     "targetCheckpointId": rollbackTargetCheckpointId,
   })
   Prometheus.RollbackSuccess.increment(
-    ~timeSeconds=Hrtime.timeSince(startTime)->Hrtime.toSecondsFloat,
+    ~timeSeconds=Performance.secondsSince(startTime),
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )
 

package/src/Rollback.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
@@ -18,7 +18,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime) {
-  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.fetchState(chainState).knownHeight);
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.knownHeight(chainState));
   if (scannedBlockNumbers.length === 0) {
     return ChainState.getHighestBlockBelowThreshold(chainState);
   }
@@ -32,7 +32,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 }
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
-  let startTime = Hrtime.makeTimer();
+  let startTime = Performance.now();
   let chainState = IndexerState.getChainState(state, reorgChain);
   let logger = Logging.createChildFrom(ChainState.logger(chainState), {
     action: "Rollback",
@@ -70,7 +70,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     beforeCheckpointId: IndexerState.committedCheckpointId(state),
     targetCheckpointId: rollbackTargetCheckpointId
   });
-  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+  Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
   scheduleFetch();
   return scheduleProcessing();

package/src/SimulateItems.res

@@ -195,6 +195,78 @@ let findEventConfig = (~config: Config.t, ~contractName: string, ~eventName: str
   found.contents
 }
 
+let dummySrcAddress = Address.unsafeFromString("0x0000000000000000000000000000000000000000")
+
+// First address configured for `contractName` on the simulated chain. Only the
+// simulated chain is consulted — a contract's address on another chain has no
+// meaning here.
+let firstContractAddress = (~chainConfig: Config.chain, ~contractName: string): option<
+  Address.t,
+> => {
+  let found = ref(None)
+  chainConfig.contracts->Array.forEach(contract => {
+    if found.contents->Option.isNone && contract.name === contractName {
+      found := contract.addresses->Array.get(0)
+    }
+  })
+  found.contents
+}
+
+let deriveSrcAddress = (
+  ~providedSrcAddress: option<Address.t>,
+  ~eventConfig: Internal.eventConfig,
+  ~chainConfig: Config.chain,
+): Address.t => {
+  switch providedSrcAddress {
+  | Some(addr) => addr
+  | None =>
+    if eventConfig.isWildcard {
+      dummySrcAddress
+    } else {
+      switch firstContractAddress(~chainConfig, ~contractName=eventConfig.contractName) {
+      | Some(addr) => addr
+      | None => dummySrcAddress
+      }
+    }
+  }
+}
+
+// A non-wildcard event is gated by `clientAddressFilter` on srcAddress ownership,
+// so a simulate item whose srcAddress isn't indexed on this chain would be
+// silently dropped (handler never runs). Fail loudly instead.
+let validateSrcAddresses = (
+  ~simulateItems: array<JSON.t>,
+  ~config: Config.t,
+  ~chainConfig: Config.chain,
+  ~indexingAddresses: array<Internal.indexingAddress>,
+): unit => {
+  let known = Utils.Set.make()
+  indexingAddresses->Array.forEach(ia => known->Utils.Set.add(ia.address->Address.toString)->ignore)
+  simulateItems->Array.forEach(rawJson => {
+    let raw = rawJson->(Utils.magic: JSON.t => rawSimulateItem)
+    switch (raw->getContract, raw->getEvent) {
+    | (Some(contractName), Some(eventName)) =>
+      switch findEventConfig(~config, ~contractName, ~eventName) {
+      | Some(eventConfig) if !eventConfig.isWildcard =>
+        let item = rawJson->(Utils.magic: JSON.t => Envio.evmSimulateItem)
+        let srcAddress = deriveSrcAddress(
+          ~providedSrcAddress=item.srcAddress,
+          ~eventConfig,
+          ~chainConfig,
+        )
+        if !(known->Utils.Set.has(srcAddress->Address.toString)) {
+          JsError.throwWithMessage(
+            `simulate: ${contractName}.${eventName} resolved to address ${srcAddress->Address.toString}, which isn't indexed on chain ${chainConfig.id->Int.toString}. ` ++
+            `Provide a "srcAddress" configured or registered for ${contractName} on this chain, or use a wildcard event.`,
+          )
+        }
+      | _ => ()
+      }
+    | _ => ()
+    }
+  })
+}
+
 let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
   Internal.item,
 > => {
@@ -238,21 +310,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         li
       }
 
-      let srcAddress = switch item.srcAddress {
-      | Some(addr) => addr
-      | None =>
-        // Use first address from contract config
-        let addr = ref(Address.unsafeFromString("0x0000000000000000000000000000000000000000"))
-        chainConfig.contracts->Array.forEach(contract => {
-          if contract.name === contractName {
-            switch contract.addresses->Array.get(0) {
-            | Some(a) => addr := a
-            | None => ()
-            }
-          }
-        })
-        addr.contents
-      }
+      let srcAddress = deriveSrcAddress(
+        ~providedSrcAddress=item.srcAddress,
+        ~eventConfig,
+        ~chainConfig,
+      )
 
       let rawItem = rawJson->(Utils.magic: JSON.t => {..})
       let blockJson: option<JSON.t> =
@@ -288,6 +350,9 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
           blockNumber,
           blockHash,
           logIndex,
+          // Simulate keeps the transaction inline on the payload, so the store
+          // key is unused.
+          transactionIndex: 0,
           payload: (
             {
               contractName: eventConfig.contractName,