envio 3.2.0 → 3.3.0-alpha.0

package/src/PgStorage.res.mjs

@@ -13,10 +13,9 @@ 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 EventUtils from "./EventUtils.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
-import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
@@ -608,47 +607,6 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-function convertFieldsToJson(fields) {
-  if (fields !== undefined) {
-    return Utils.Dict.mapValues(fields, value => {
-      if (typeof value === "bigint") {
-        return value.toString();
-      } else {
-        return value;
-      }
-    });
-  } else {
-    return {};
-  }
-}
-
-function makeRawEvent(eventItem, config) {
-  let event = eventItem.event;
-  let blockNumber = eventItem.blockNumber;
-  let eventConfig = eventItem.eventConfig;
-  let logIndex = event.logIndex;
-  let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
-  let blockFields = convertFieldsToJson(event.block);
-  let transactionFields = convertFieldsToJson(event.transaction);
-  config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
-  let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
-  let params$1 = params === null ? "null" : params;
-  return {
-    chain_id: eventItem.chain,
-    event_id: eventId,
-    event_name: eventConfig.name,
-    contract_name: eventConfig.contractName,
-    block_number: blockNumber,
-    log_index: logIndex,
-    src_address: event.srcAddress,
-    block_hash: eventItem.blockHash,
-    block_timestamp: eventItem.timestamp,
-    block_fields: blockFields,
-    transaction_fields: transactionFields,
-    params: params$1
-  };
-}
-
 async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
   try {
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
@@ -659,7 +617,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     if (config.enableRawEvents) {
       let rows = Stdlib_Array.filterMap(batch.items, item => {
         if (item.kind === 0) {
-          return makeRawEvent(item, config);
+          return config.ecosystem.toRawEvent(item);
         }
       });
       if (escapeTables !== undefined && Primitive_option.valFromOption(escapeTables).has(InternalTable.RawEvents.table)) {
@@ -1004,7 +962,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         numEventsProcessed: 0,
         firstEventBlockNumber: undefined,
         timestampCaughtUpToHeadOrEndblock: undefined,
-        indexingAddresses: ChainFetcher.configAddresses(chainConfig),
+        indexingAddresses: ChainState.configAddresses(chainConfig),
         sourceBlockNumber: 0
       })),
       checkpointId: InternalTable.Checkpoints.initialCheckpointId,
@@ -1275,8 +1233,6 @@ export {
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,
   executeSet,
-  convertFieldsToJson,
-  makeRawEvent,
   writeBatch,
   makeGetRollbackRestoredEntitiesQuery,
   makeGetRollbackRemovedIdsQuery,

package/src/Prometheus.res

@@ -352,14 +352,13 @@ module IndexingAddresses = {
 }
 
 module IndexingMaxConcurrency = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_indexing_max_concurrency",
-    ~help="The maximum number of concurrent queries to the chain data-source.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
+  let gauge = PromClient.Gauge.makeGauge({
+    "name": "envio_indexing_max_concurrency",
+    "help": "The maximum number of concurrent data-source queries across the whole indexer.",
+  })
 
-  let set = (~maxConcurrency, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=maxConcurrency)
+  let set = (~maxConcurrency) => {
+    gauge->PromClient.Gauge.set(maxConcurrency)
   }
 }
 
@@ -426,7 +425,7 @@ module IndexingBufferSize = {
 module IndexingTargetBufferSize = {
   let gauge = PromClient.Gauge.makeGauge({
     "name": "envio_indexing_target_buffer_size",
-    "help": "The target buffer size per chain for indexing. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target.",
+    "help": "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target.",
   })
 
   let set = (~targetBufferSize) => {

package/src/Prometheus.res.mjs

@@ -400,10 +400,13 @@ let IndexingAddresses = {
   set: set$4
 };
 
-let gauge$5 = makeOrThrow$1("envio_indexing_max_concurrency", "The maximum number of concurrent queries to the chain data-source.", chainIdLabelsSchema);
+let gauge$5 = PromClient.Gauge.makeGauge({
+  name: "envio_indexing_max_concurrency",
+  help: "The maximum number of concurrent data-source queries across the whole indexer."
+});
 
-function set$5(maxConcurrency, chainId) {
-  handleInt$1(gauge$5, chainId, maxConcurrency);
+function set$5(maxConcurrency) {
+  gauge$5.set(maxConcurrency);
 }
 
 let IndexingMaxConcurrency = {
@@ -464,7 +467,7 @@ let IndexingBufferSize = {
 
 let gauge$9 = PromClient.Gauge.makeGauge({
   name: "envio_indexing_target_buffer_size",
-  help: "The target buffer size per chain for indexing. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
+  help: "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
 });
 
 function set$9(targetBufferSize) {

package/src/PruneStaleHistory.res

@@ -0,0 +1,45 @@
+// Throttled prune of stale entity-history rows below the safe checkpoint.
+
+let runPrune = async (state: IndexerState.t) => {
+  switch state->IndexerState.getSafeCheckpointId {
+  | None => ()
+  | Some(safeCheckpointId) =>
+    let persistence = state->IndexerState.persistence
+    await persistence.storage.pruneStaleCheckpoints(~safeCheckpointId)
+
+    for idx in 0 to persistence.allEntities->Array.length - 1 {
+      if idx !== 0 {
+        // Add some delay between entities
+        // To unblock the pg client if it's needed for something else
+        await Utils.delay(1000)
+      }
+      let entityConfig = persistence.allEntities->Array.getUnsafe(idx)
+      let timeRef = Hrtime.makeTimer()
+      try {
+        let () = await persistence.storage.pruneStaleEntityHistory(
+          ~entityName=entityConfig.name,
+          ~entityIndex=entityConfig.index,
+          ~safeCheckpointId,
+        )
+      } catch {
+      | exn =>
+        exn->ErrorHandling.mkLogAndRaise(
+          ~msg=`Failed to prune stale entity history`,
+          ~logger=Logging.createChild(
+            ~params={
+              "entityName": entityConfig.name,
+              "safeCheckpointId": safeCheckpointId,
+            },
+          ),
+        )
+      }
+      Prometheus.RollbackHistoryPrune.increment(
+        ~timeSeconds=Hrtime.timeSince(timeRef)->Hrtime.toSecondsFloat,
+        ~entityName=entityConfig.name,
+      )
+    }
+  }
+}
+
+let schedule = (state: IndexerState.t) =>
+  state->IndexerState.pruneStaleEntityHistoryThrottler->Throttler.schedule(() => runPrune(state))

package/src/PruneStaleHistory.res.mjs

@@ -0,0 +1,46 @@
+// 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 IndexerState from "./IndexerState.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+async function runPrune(state) {
+  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
+  if (safeCheckpointId === undefined) {
+    return;
+  }
+  let persistence = IndexerState.persistence(state);
+  await persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
+  for (let idx = 0, idx_finish = persistence.allEntities.length; idx < idx_finish; ++idx) {
+    if (idx !== 0) {
+      await Utils.delay(1000);
+    }
+    let entityConfig = persistence.allEntities[idx];
+    let timeRef = Hrtime.makeTimer();
+    try {
+      await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      ErrorHandling.mkLogAndRaise(Logging.createChild({
+        entityName: entityConfig.name,
+        safeCheckpointId: safeCheckpointId
+      }), `Failed to prune stale entity history`, exn);
+    }
+    Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+  }
+}
+
+function schedule(state) {
+  Throttler.schedule(IndexerState.pruneStaleEntityHistoryThrottler(state), () => runPrune(state));
+}
+
+export {
+  runPrune,
+  schedule,
+}
+/* Utils Not a pure module */

package/src/RawEvent.res

@@ -0,0 +1,73 @@
+let convertFieldsToJson = (fields: option<dict<unknown>>) => {
+  switch fields {
+  | None => %raw(`{}`)
+  | Some(fields) =>
+    // Convert bigint fields to string. There are no fields with nested
+    // bigints, so iterating only the top level is safe.
+    fields
+    ->Utils.Dict.mapValues(value =>
+      typeof(value) === #bigint
+        ? value
+          ->(Utils.magic: unknown => bigint)
+          ->BigInt.toString
+          ->(Utils.magic: string => unknown)
+        : value
+    )
+    ->(Utils.magic: dict<unknown> => JSON.t)
+  }
+}
+
+// Block and transaction are passed already extracted from the ecosystem's
+// concrete payload (EVM or Fuel) — `RawEvent` stays payload-shape-agnostic and
+// only needs them as opaque field bags to serialise.
+let make = (
+  eventItem: Internal.eventItem,
+  ~block,
+  ~transaction,
+  ~params: Internal.eventParams,
+  ~srcAddress: Address.t,
+  ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
+): Internal.rawEvent => {
+  let {eventConfig, chain, blockNumber, blockHash, timestamp: blockTimestamp, logIndex} = eventItem
+  let chainId = chain->ChainMap.Chain.toChainId
+  let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
+  let blockFields =
+    block
+    ->(Utils.magic: 'block => option<dict<unknown>>)
+    ->convertFieldsToJson
+  let transactionFields =
+    transaction
+    ->(Utils.magic: 'transaction => option<dict<unknown>>)
+    ->convertFieldsToJson
+
+  blockFields->cleanUpRawEventFieldsInPlace
+
+  // Serialize to unknown, because serializing to Js.Json.t fails for Bytes Fuel type, since it has unknown schema
+  let params =
+    params
+    ->S.reverseConvertOrThrow(eventConfig.paramsRawEventSchema)
+    ->(Utils.magic: unknown => JSON.t)
+  let params = if params === %raw(`null`) {
+    // Should probably make the params field nullable
+    // But this is currently needed to make events
+    // with empty params work
+    %raw(`"null"`)
+  } else {
+    params
+  }
+
+  {
+    chain_id: chainId,
+    event_id: eventId,
+    event_name: eventConfig.name,
+    contract_name: eventConfig.contractName,
+    block_number: blockNumber,
+    log_index: logIndex,
+    src_address: srcAddress,
+    block_hash: blockHash,
+    block_timestamp: blockTimestamp,
+    block_fields: blockFields,
+    transaction_fields: transactionFields,
+    params,
+  }
+}

package/src/RawEvent.res.mjs

@@ -0,0 +1,51 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as EventUtils from "./EventUtils.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function convertFieldsToJson(fields) {
+  if (fields !== undefined) {
+    return Utils.Dict.mapValues(fields, value => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      } else {
+        return value;
+      }
+    });
+  } else {
+    return {};
+  }
+}
+
+function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEventFieldsInPlace) {
+  let logIndex = eventItem.logIndex;
+  let blockNumber = eventItem.blockNumber;
+  let eventConfig = eventItem.eventConfig;
+  let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
+  let blockFields = convertFieldsToJson(block);
+  let transactionFields = convertFieldsToJson(transaction);
+  cleanUpRawEventFieldsInPlace(blockFields);
+  let params$1 = S$RescriptSchema.reverseConvertOrThrow(params, eventConfig.paramsRawEventSchema);
+  let params$2 = params$1 === null ? "null" : params$1;
+  return {
+    chain_id: eventItem.chain,
+    event_id: eventId,
+    event_name: eventConfig.name,
+    contract_name: eventConfig.contractName,
+    block_number: blockNumber,
+    log_index: logIndex,
+    src_address: srcAddress,
+    block_hash: eventItem.blockHash,
+    block_timestamp: eventItem.timestamp,
+    block_fields: blockFields,
+    transaction_fields: transactionFields,
+    params: params$2
+  };
+}
+
+export {
+  convertFieldsToJson,
+  make,
+}
+/* Utils Not a pure module */

package/src/Rollback.res

@@ -0,0 +1,204 @@
+// The reorg rollback state machine. Re-enters fetch/process/rollback through
+// the injected schedule* effects.
+
+/**
+Finds the last known valid block number below the reorg block
+If not found, returns the highest block below threshold
+*/
+let getLastKnownValidBlock = async (
+  chainState: ChainState.t,
+  ~reorgBlockNumber: int,
+  ~isRealtime: bool,
+) => {
+  // Don't include the reorg block itself — different source instances
+  // may have mismatching hashes at the head, so we always rollback
+  // the block where we detected the reorg.
+  let scannedBlockNumbers =
+    chainState
+    ->ChainState.reorgDetection
+    ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
+      ~blockNumber=reorgBlockNumber,
+      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+    )
+
+  switch scannedBlockNumbers {
+  | [] => chainState->ChainState.getHighestBlockBelowThreshold
+  | _ => {
+      let blockNumbersAndHashes = await chainState
+      ->ChainState.sourceManager
+      ->SourceManager.getBlockHashes(~blockNumbers=scannedBlockNumbers, ~isRealtime)
+
+      switch chainState
+      ->ChainState.reorgDetection
+      ->ReorgDetection.getLatestValidScannedBlock(~blockNumbersAndHashes) {
+      | Some(blockNumber) => blockNumber
+      | None => chainState->ChainState.getHighestBlockBelowThreshold
+      }
+    }
+  }
+}
+
+let rec rollback = async (
+  state: IndexerState.t,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+  ~scheduleRollback,
+) =>
+  // Owns its error boundary: launch doesn't catch, so a failure mid-rollback
+  // must stop the indexer.
+  try {
+    switch state->IndexerState.rollbackState {
+    | NoRollback | RollbackReady(_) =>
+      JsError.throwWithMessage("Internal error: Rollback initiated with invalid state")
+    | ReorgDetected({chain, blockNumber: reorgBlockNumber}) =>
+      let chainState = state->IndexerState.getChainState(~chain)
+
+      state->IndexerState.enterFindingReorgDepth
+      let rollbackTargetBlockNumber = await chainState->getLastKnownValidBlock(
+        ~reorgBlockNumber,
+        ~isRealtime=state->IndexerState.isRealtime,
+      )
+
+      chainState
+      ->ChainState.sourceManager
+      ->SourceManager.onReorg(~rollbackTargetBlock=rollbackTargetBlockNumber)
+
+      state->IndexerState.foundReorgDepth(~chain, ~rollbackTargetBlockNumber)
+      // Rendezvous with the processing loop: whichever of {depth found, loop
+      // idle} happens last triggers the rollback; the earlier one finds the
+      // other condition unmet and bails here.
+      scheduleRollback()
+    // Reached when a batch finished (loop idle) while the reorg depth wasn't
+    // found yet. Wait for the ReorgDetected branch above to find it and re-kick.
+    | FindingReorgDepth => ()
+    | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
+      Logging.info("Waiting for batch to finish processing before executing rollback")
+    | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
+      await executeRollback(
+        state,
+        ~reorgChain,
+        ~rollbackTargetBlockNumber,
+        ~scheduleFetch,
+        ~scheduleProcessing,
+      )
+    }
+  } catch {
+  | exn =>
+    IndexerState.errorExit(state, exn->ErrorHandling.make(~msg=IndexerState.unexpectedErrorMsg))
+  }
+
+and executeRollback = async (
+  state: IndexerState.t,
+  ~reorgChain,
+  ~rollbackTargetBlockNumber,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+) => {
+  let startTime = Hrtime.makeTimer()
+
+  let chainState = state->IndexerState.getChainState(~chain=reorgChain)
+
+  let logger = Logging.createChildFrom(
+    ~logger=chainState->ChainState.logger,
+    ~params={
+      "action": "Rollback",
+      "reorgChain": reorgChain,
+      "targetBlockNumber": rollbackTargetBlockNumber,
+    },
+  )
+  logger->Logging.childInfo("Started rollback on reorg")
+  Prometheus.RollbackTargetBlockNumber.set(
+    ~blockNumber=rollbackTargetBlockNumber,
+    ~chain=reorgChain,
+  )
+
+  let reorgChainId = reorgChain->ChainMap.Chain.toChainId
+
+  // Finish pending batch writes first: the target checkpoint, the progress
+  // diff and the rollback diff below must all be computed from the same db
+  // state. Otherwise an in-flight batch lands after the progress reads and
+  // its entity changes get reverted without the chain progress being
+  // rolled back, so the events are never reprocessed.
+  await state->Writing.flush
+
+  let rollbackTargetCheckpointId = {
+    switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
+      ~reorgChainId,
+      ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
+    ) {
+    | Some(checkpointId) => checkpointId
+    | None => 0n
+    }
+  }
+
+  let eventsProcessedDiffByChain = Dict.make()
+  let newProgressBlockNumberPerChain = Dict.make()
+  let rollbackedProcessedEvents = ref(0.)
+
+  {
+    let rollbackProgressDiff = await (
+      state->IndexerState.persistence
+    ).storage.getRollbackProgressDiff(~rollbackTargetCheckpointId)
+    for idx in 0 to rollbackProgressDiff->Array.length - 1 {
+      let diff = rollbackProgressDiff->Array.getUnsafe(idx)
+      eventsProcessedDiffByChain->Utils.Dict.setByInt(
+        diff["chain_id"],
+        {
+          let eventsProcessedDiff =
+            Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
+          rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessedDiff
+          eventsProcessedDiff
+        },
+      )
+      newProgressBlockNumberPerChain->Utils.Dict.setByInt(
+        diff["chain_id"],
+        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChainId {
+          Pervasives.min(diff["new_progress_block_number"], rollbackTargetBlockNumber)
+        } else {
+          diff["new_progress_block_number"]
+        },
+      )
+    }
+  }
+
+  state
+  ->IndexerState.chainStates
+  ->Utils.Dict.forEach(cs => {
+    let chainId = (cs->ChainState.chainConfig).id
+    cs->ChainState.rollback(
+      ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
+        chainId,
+      ),
+      ~eventsProcessedDiff=eventsProcessedDiffByChain->Utils.Dict.dangerouslyGetByIntNonOption(
+        chainId,
+      ),
+      ~rollbackTargetBlockNumber,
+      ~isReorgChain=chainId === reorgChainId,
+    )
+  })
+
+  let diff = await state->InMemoryStore.prepareRollbackDiff(
+    ~rollbackTargetCheckpointId,
+    ~rollbackDiffCheckpointId=state->IndexerState.committedCheckpointId->BigInt.add(1n),
+    ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
+  )
+
+  logger->Logging.childTrace({
+    "msg": "Finished rollback on reorg",
+    "entityChanges": {
+      "deleted": diff["deletedEntities"],
+      "upserted": diff["setEntities"],
+    },
+    "rollbackedEvents": rollbackedProcessedEvents.contents,
+    "beforeCheckpointId": state->IndexerState.committedCheckpointId,
+    "targetCheckpointId": rollbackTargetCheckpointId,
+  })
+  Prometheus.RollbackSuccess.increment(
+    ~timeSeconds=Hrtime.timeSince(startTime)->Hrtime.toSecondsFloat,
+    ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
+  )
+
+  state->IndexerState.completeRollback(~eventsProcessedDiffByChain)
+  scheduleFetch()
+  scheduleProcessing()
+}

package/src/Rollback.res.mjs

@@ -0,0 +1,118 @@
+// 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 IndexerState from "./IndexerState.res.mjs";
+import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.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 ReorgDetection from "./ReorgDetection.res.mjs";
+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);
+  if (scannedBlockNumbers.length === 0) {
+    return ChainState.getHighestBlockBelowThreshold(chainState);
+  }
+  let blockNumbersAndHashes = await SourceManager.getBlockHashes(ChainState.sourceManager(chainState), scannedBlockNumbers, isRealtime);
+  let blockNumber = ReorgDetection.getLatestValidScannedBlock(ChainState.reorgDetection(chainState), blockNumbersAndHashes);
+  if (blockNumber !== undefined) {
+    return blockNumber;
+  } else {
+    return ChainState.getHighestBlockBelowThreshold(chainState);
+  }
+}
+
+async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
+  let startTime = Hrtime.makeTimer();
+  let chainState = IndexerState.getChainState(state, reorgChain);
+  let logger = Logging.createChildFrom(ChainState.logger(chainState), {
+    action: "Rollback",
+    reorgChain: reorgChain,
+    targetBlockNumber: rollbackTargetBlockNumber
+  });
+  Logging.childInfo(logger, "Started rollback on reorg");
+  Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber, reorgChain);
+  await Writing.flush(state);
+  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
+  let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
+  let eventsProcessedDiffByChain = {};
+  let newProgressBlockNumberPerChain = {};
+  let rollbackedProcessedEvents = 0;
+  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+  for (let idx = 0, idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx) {
+    let diff = rollbackProgressDiff[idx];
+    let eventsProcessedDiff = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
+    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
+    eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
+    newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
+  }
+  Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
+    let chainId = ChainState.chainConfig(cs).id;
+    ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+  });
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  Logging.childTrace(logger, {
+    msg: "Finished rollback on reorg",
+    entityChanges: {
+      deleted: diff$1.deletedEntities,
+      upserted: diff$1.setEntities
+    },
+    rollbackedEvents: rollbackedProcessedEvents,
+    beforeCheckpointId: IndexerState.committedCheckpointId(state),
+    targetCheckpointId: rollbackTargetCheckpointId
+  });
+  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+  IndexerState.completeRollback(state, eventsProcessedDiffByChain);
+  scheduleFetch();
+  return scheduleProcessing();
+}
+
+async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollback) {
+  try {
+    let match = IndexerState.rollbackState(state);
+    if (typeof match !== "object") {
+      if (match === "NoRollback") {
+        return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+      } else {
+        return;
+      }
+    }
+    switch (match.TAG) {
+      case "ReorgDetected" :
+        let chain = match.chain;
+        let chainState = IndexerState.getChainState(state, chain);
+        IndexerState.enterFindingReorgDepth(state);
+        let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainState, match.blockNumber, IndexerState.isRealtime(state));
+        SourceManager.onReorg(ChainState.sourceManager(chainState), rollbackTargetBlockNumber);
+        IndexerState.foundReorgDepth(state, chain, rollbackTargetBlockNumber);
+        return scheduleRollback();
+      case "FoundReorgDepth" :
+        if (IndexerState.isProcessing(state)) {
+          return Logging.info("Waiting for batch to finish processing before executing rollback");
+        } else {
+          return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
+        }
+      case "RollbackReady" :
+        return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+    }
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, IndexerState.unexpectedErrorMsg));
+  }
+}
+
+export {
+  getLastKnownValidBlock,
+  rollback,
+  executeRollback,
+}
+/* Utils Not a pure module */