envio 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/Main.res

@@ -0,0 +1,351 @@
+open Belt
+
+type chainData = {
+  chainId: float,
+  poweredByHyperSync: bool,
+  firstEventBlockNumber: option<int>,
+  latestProcessedBlock: option<int>,
+  timestampCaughtUpToHeadOrEndblock: option<Js.Date.t>,
+  numEventsProcessed: int,
+  latestFetchedBlockNumber: int,
+  // Need this for API backwards compatibility
+  @as("currentBlockHeight")
+  knownHeight: int,
+  numBatchesFetched: int,
+  endBlock: option<int>,
+  numAddresses: int,
+}
+@tag("status")
+type state =
+  | @as("disabled") Disabled({})
+  | @as("initializing") Initializing({})
+  | @as("active")
+  Active({
+      envioVersion: string,
+      chains: array<chainData>,
+      indexerStartTime: Js.Date.t,
+      isPreRegisteringDynamicContracts: bool,
+      isUnorderedMultichainMode: bool,
+      rollbackOnReorg: bool,
+    })
+
+let chainDataSchema = S.schema((s): chainData => {
+  chainId: s.matches(S.float),
+  poweredByHyperSync: s.matches(S.bool),
+  firstEventBlockNumber: s.matches(S.option(S.int)),
+  latestProcessedBlock: s.matches(S.option(S.int)),
+  timestampCaughtUpToHeadOrEndblock: s.matches(S.option(S.datetime(S.string))),
+  numEventsProcessed: s.matches(S.int),
+  latestFetchedBlockNumber: s.matches(S.int),
+  knownHeight: s.matches(S.int),
+  numBatchesFetched: s.matches(S.int),
+  endBlock: s.matches(S.option(S.int)),
+  numAddresses: s.matches(S.int),
+})
+let stateSchema = S.union([
+  S.literal(Disabled({})),
+  S.literal(Initializing({})),
+  S.schema(s => Active({
+    envioVersion: s.matches(S.string),
+    chains: s.matches(S.array(chainDataSchema)),
+    indexerStartTime: s.matches(S.datetime(S.string)),
+    // Keep the field, since Dev Console expects it to be present
+    isPreRegisteringDynamicContracts: false,
+    isUnorderedMultichainMode: s.matches(S.bool),
+    rollbackOnReorg: s.matches(S.bool),
+  })),
+])
+
+let globalGsManagerRef: ref<option<GlobalStateManager.t>> = ref(None)
+
+let getGlobalIndexer = (~config: Config.t): 'indexer => {
+  let indexer = Utils.Object.createNullObject()
+
+  indexer
+  ->Utils.Object.definePropertyWithValue("name", {enumerable: true, value: config.name})
+  ->Utils.Object.definePropertyWithValue(
+    "description",
+    {enumerable: true, value: config.description},
+  )
+  ->ignore
+
+  let chainIds = []
+
+  // Build chains object with chain ID as string key
+  let chains = Utils.Object.createNullObject()
+  config.chainMap
+  ->ChainMap.values
+  ->Array.forEach(chainConfig => {
+    let chainIdStr = chainConfig.id->Int.toString
+
+    chainIds->Js.Array2.push(chainConfig.id)->ignore
+
+    let chainObj = Utils.Object.createNullObject()
+    chainObj
+    ->Utils.Object.definePropertyWithValue("id", {enumerable: true, value: chainConfig.id})
+    ->Utils.Object.definePropertyWithValue(
+      "startBlock",
+      {enumerable: true, value: chainConfig.startBlock},
+    )
+    ->Utils.Object.definePropertyWithValue(
+      "endBlock",
+      {enumerable: true, value: chainConfig.endBlock},
+    )
+    ->Utils.Object.definePropertyWithValue("name", {enumerable: true, value: chainConfig.name})
+    ->Utils.Object.defineProperty(
+      "isLive",
+      {
+        enumerable: true,
+        get: () => {
+          switch globalGsManagerRef.contents {
+          | None => false
+          | Some(gsManager) =>
+            let state = gsManager->GlobalStateManager.getState
+            let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
+            let chainFetcher = state.chainManager.chainFetchers->ChainMap.get(chain)
+            chainFetcher->ChainFetcher.isLive
+          }
+        },
+      },
+    )
+    ->ignore
+
+    // Add contracts to chain object
+    chainConfig.contracts->Array.forEach(contract => {
+      let contractObj = Utils.Object.createNullObject()
+      contractObj
+      ->Utils.Object.definePropertyWithValue("name", {enumerable: true, value: contract.name})
+      ->Utils.Object.definePropertyWithValue("abi", {enumerable: true, value: contract.abi})
+      ->Utils.Object.defineProperty(
+        "addresses",
+        {
+          enumerable: true,
+          get: () => {
+            switch globalGsManagerRef.contents {
+            | None => contract.addresses
+            | Some(gsManager) => {
+                let state = gsManager->GlobalStateManager.getState
+                let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
+                let chainFetcher = state.chainManager.chainFetchers->ChainMap.get(chain)
+                let indexingContracts = chainFetcher.fetchState.indexingContracts
+
+                // Collect all addresses for this contract name from indexingContracts
+                let addresses = []
+                let values = indexingContracts->Js.Dict.values
+                for idx in 0 to values->Array.length - 1 {
+                  let indexingContract = values->Js.Array2.unsafe_get(idx)
+                  if indexingContract.contractName === contract.name {
+                    addresses->Array.push(indexingContract.address)->ignore
+                  }
+                }
+                addresses
+              }
+            }
+          },
+        },
+      )
+      ->ignore
+
+      chainObj
+      ->Utils.Object.definePropertyWithValue(contract.name, {enumerable: true, value: contractObj})
+      ->ignore
+    })
+
+    // Primary key is chain ID as string
+    chains
+    ->Utils.Object.definePropertyWithValue(chainIdStr, {enumerable: true, value: chainObj})
+    ->ignore
+
+    // If chain has a name different from ID, add non-enumerable alias
+    if chainConfig.name !== chainIdStr {
+      chains
+      ->Utils.Object.definePropertyWithValue(chainConfig.name, {enumerable: false, value: chainObj})
+      ->ignore
+    }
+  })
+  indexer
+  ->Utils.Object.definePropertyWithValue("chainIds", {enumerable: true, value: chainIds})
+  ->ignore
+  indexer->Utils.Object.definePropertyWithValue("chains", {enumerable: true, value: chains})->ignore
+
+  indexer->Utils.magic
+}
+
+let startServer = (~getState, ~ctx: Ctx.t, ~isDevelopmentMode: bool) => {
+  open Express
+
+  let app = make()
+
+  let consoleCorsMiddleware = (req, res, next) => {
+    switch req.headers->Js.Dict.get("origin") {
+    | Some(origin) if origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl =>
+      res->setHeader("Access-Control-Allow-Origin", origin)
+    | _ => ()
+    }
+
+    res->setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+    res->setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+    if req.method === Rest.Options {
+      res->sendStatus(200)
+    } else {
+      next()
+    }
+  }
+  app->useFor("/console", consoleCorsMiddleware)
+  app->useFor("/metrics", consoleCorsMiddleware)
+
+  app->get("/healthz", (_req, res) => {
+    // this is the machine readable port used in kubernetes to check the health of this service.
+    //   aditional health information could be added in the future (info about errors, back-offs, etc).
+    res->sendStatus(200)
+  })
+
+  app->get("/console/state", (_req, res) => {
+    let state = if isDevelopmentMode {
+      getState()
+    } else {
+      Disabled({})
+    }
+
+    res->json(state->S.reverseConvertToJsonOrThrow(stateSchema))
+  })
+
+  app->post("/console/syncCache", (_req, res) => {
+    if isDevelopmentMode {
+      (ctx.persistence->Persistence.getInitializedStorageOrThrow).dumpEffectCache()
+      ->Promise.thenResolve(_ => res->json(Boolean(true)))
+      ->Promise.done
+    } else {
+      res->json(Boolean(false))
+    }
+  })
+
+  PromClient.collectDefaultMetrics()
+
+  app->get("/metrics", (_req, res) => {
+    res->set("Content-Type", PromClient.defaultRegister->PromClient.getContentType)
+    let _ =
+      PromClient.defaultRegister
+      ->PromClient.metrics
+      ->Promise.thenResolve(metrics => res->endWithData(metrics))
+  })
+
+  let _ = app->listen(Env.serverPort)
+}
+
+type args = {@as("tui-off") tuiOff?: bool}
+
+type process
+@val external process: process = "process"
+@get external argv: process => 'a = "argv"
+
+type mainArgs = Yargs.parsedArgs<args>
+
+let start = async (
+  ~makeGeneratedConfig: unit => Config.t,
+  ~persistence: Persistence.t,
+  ~isTest=false,
+) => {
+  let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
+  let shouldUseTui = !isTest && !(mainArgs.tuiOff->Belt.Option.getWithDefault(Env.tuiOffEnvVar))
+  // The most simple check to verify whether we are running in development mode
+  // and prevent exposing the console to public, when creating a real deployment.
+  // Note: isTest overrides isDevelopmentMode to ensure proper process exit in test mode.
+  let isDevelopmentMode = !isTest && Env.Db.password === "testing"
+
+  // Register all handlers first, then get the config with registrations
+  let configWithoutRegistrations = makeGeneratedConfig()
+  let registrations = await HandlerLoader.registerAllHandlers(~config=configWithoutRegistrations)
+  let config = makeGeneratedConfig()
+  let config = if isTest {
+    {...config, shouldRollbackOnReorg: false}
+  } else {
+    config
+  }
+  let ctx = {
+    Ctx.registrations,
+    config,
+    persistence,
+  }
+
+  let envioVersion = Utils.EnvioPackage.value.version
+  Prometheus.Info.set(~version=envioVersion)
+  Prometheus.RollbackEnabled.set(~enabled=ctx.config.shouldRollbackOnReorg)
+
+  if !isTest {
+    startServer(~ctx, ~isDevelopmentMode, ~getState=() =>
+      switch globalGsManagerRef.contents {
+      | None => Initializing({})
+      | Some(gsManager) => {
+          let state = gsManager->GlobalStateManager.getState
+          let chains =
+            state.chainManager.chainFetchers
+            ->ChainMap.values
+            ->Array.map(cf => {
+              let {fetchState} = cf
+              let latestFetchedBlockNumber = Pervasives.max(
+                FetchState.bufferBlockNumber(fetchState),
+                0,
+              )
+              let knownHeight =
+                cf->ChainFetcher.hasProcessedToEndblock
+                  ? cf.fetchState.endBlock->Option.getWithDefault(cf.fetchState.knownHeight)
+                  : cf.fetchState.knownHeight
+
+              {
+                chainId: cf.chainConfig.id->Js.Int.toFloat,
+                poweredByHyperSync: (
+                  cf.sourceManager->SourceManager.getActiveSource
+                ).poweredByHyperSync,
+                latestFetchedBlockNumber,
+                knownHeight,
+                numBatchesFetched: cf.numBatchesFetched,
+                endBlock: cf.fetchState.endBlock,
+                firstEventBlockNumber: cf.firstEventBlockNumber,
+                latestProcessedBlock: cf.committedProgressBlockNumber === -1
+                  ? None
+                  : Some(cf.committedProgressBlockNumber),
+                timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
+                numEventsProcessed: cf.numEventsProcessed,
+                numAddresses: cf.fetchState->FetchState.numAddresses,
+              }
+            })
+          Active({
+            envioVersion,
+            chains,
+            indexerStartTime: state.indexerStartTime,
+            isPreRegisteringDynamicContracts: false,
+            rollbackOnReorg: ctx.config.shouldRollbackOnReorg,
+            isUnorderedMultichainMode: switch ctx.config.multichain {
+            | Unordered => true
+            | Ordered => false
+            },
+          })
+        }
+      }
+    )
+  }
+
+  await ctx.persistence->Persistence.init(~chainConfigs=ctx.config.chainMap->ChainMap.values)
+
+  let chainManager = await ChainManager.makeFromDbState(
+    ~initialState=ctx.persistence->Persistence.getInitializedState,
+    ~config=ctx.config,
+    ~registrations=ctx.registrations,
+  )
+  let globalState = GlobalState.make(~ctx, ~chainManager, ~isDevelopmentMode, ~shouldUseTui)
+  let gsManager = globalState->GlobalStateManager.make
+  if shouldUseTui {
+    let _rerender = Tui.start(~getState=() => gsManager->GlobalStateManager.getState)
+  }
+  globalGsManagerRef := Some(gsManager)
+  gsManager->GlobalStateManager.dispatchTask(NextQuery(CheckAllChains))
+  /*
+    NOTE:
+      This `ProcessEventBatch` dispatch shouldn't be necessary but we are adding for safety, it should immediately return doing 
+      nothing since there is no events on the queues.
+ */
+
+  gsManager->GlobalStateManager.dispatchTask(ProcessEventBatch)
+}

package/src/Main.res.mjs

@@ -0,0 +1,312 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Tui from "./tui/Tui.res.mjs";
+import * as Caml from "rescript/lib/es6/caml.js";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import Express from "express";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as GlobalState from "./GlobalState.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
+import * as PromClient from "prom-client";
+import Yargs from "yargs/yargs";
+import * as ChainFetcher from "./ChainFetcher.res.mjs";
+import * as ChainManager from "./ChainManager.res.mjs";
+import * as HandlerLoader from "./HandlerLoader.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as Helpers from "yargs/helpers";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as GlobalStateManager from "./GlobalStateManager.res.mjs";
+
+var chainDataSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              chainId: s.m(S$RescriptSchema.$$float),
+              poweredByHyperSync: s.m(S$RescriptSchema.bool),
+              firstEventBlockNumber: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              latestProcessedBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              timestampCaughtUpToHeadOrEndblock: s.m(S$RescriptSchema.option(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined))),
+              numEventsProcessed: s.m(S$RescriptSchema.$$int),
+              latestFetchedBlockNumber: s.m(S$RescriptSchema.$$int),
+              currentBlockHeight: s.m(S$RescriptSchema.$$int),
+              numBatchesFetched: s.m(S$RescriptSchema.$$int),
+              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              numAddresses: s.m(S$RescriptSchema.$$int)
+            };
+    });
+
+var stateSchema = S$RescriptSchema.union([
+      S$RescriptSchema.literal({
+            status: "disabled"
+          }),
+      S$RescriptSchema.literal({
+            status: "initializing"
+          }),
+      S$RescriptSchema.schema(function (s) {
+            return {
+                    status: "active",
+                    envioVersion: s.m(S$RescriptSchema.string),
+                    chains: s.m(S$RescriptSchema.array(chainDataSchema)),
+                    indexerStartTime: s.m(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined)),
+                    isPreRegisteringDynamicContracts: false,
+                    isUnorderedMultichainMode: s.m(S$RescriptSchema.bool),
+                    rollbackOnReorg: s.m(S$RescriptSchema.bool)
+                  };
+          })
+    ]);
+
+var globalGsManagerRef = {
+  contents: undefined
+};
+
+function getGlobalIndexer(config) {
+  var indexer = Object.create(null);
+  Object.defineProperty(Object.defineProperty(indexer, "name", {
+            enumerable: true,
+            value: config.name
+          }), "description", {
+        enumerable: true,
+        value: config.description
+      });
+  var chainIds = [];
+  var chains = Object.create(null);
+  Belt_Array.forEach(ChainMap.values(config.chainMap), (function (chainConfig) {
+          var chainIdStr = String(chainConfig.id);
+          chainIds.push(chainConfig.id);
+          var chainObj = Object.create(null);
+          Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(chainObj, "id", {
+                                enumerable: true,
+                                value: chainConfig.id
+                              }), "startBlock", {
+                            enumerable: true,
+                            value: chainConfig.startBlock
+                          }), "endBlock", {
+                        enumerable: true,
+                        value: chainConfig.endBlock
+                      }), "name", {
+                    enumerable: true,
+                    value: chainConfig.name
+                  }), "isLive", {
+                enumerable: true,
+                get: (function () {
+                    var gsManager = globalGsManagerRef.contents;
+                    if (gsManager === undefined) {
+                      return false;
+                    }
+                    var state = GlobalStateManager.getState(Caml_option.valFromOption(gsManager));
+                    var chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
+                    var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+                    return ChainFetcher.isLive(chainFetcher);
+                  })
+              });
+          Belt_Array.forEach(chainConfig.contracts, (function (contract) {
+                  var contractObj = Object.create(null);
+                  Object.defineProperty(Object.defineProperty(Object.defineProperty(contractObj, "name", {
+                                enumerable: true,
+                                value: contract.name
+                              }), "abi", {
+                            enumerable: true,
+                            value: contract.abi
+                          }), "addresses", {
+                        enumerable: true,
+                        get: (function () {
+                            var gsManager = globalGsManagerRef.contents;
+                            if (gsManager === undefined) {
+                              return contract.addresses;
+                            }
+                            var state = GlobalStateManager.getState(Caml_option.valFromOption(gsManager));
+                            var chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
+                            var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+                            var indexingContracts = chainFetcher.fetchState.indexingContracts;
+                            var addresses = [];
+                            var values = Js_dict.values(indexingContracts);
+                            for(var idx = 0 ,idx_finish = values.length; idx < idx_finish; ++idx){
+                              var indexingContract = values[idx];
+                              if (indexingContract.contractName === contract.name) {
+                                addresses.push(indexingContract.address);
+                              }
+                              
+                            }
+                            return addresses;
+                          })
+                      });
+                  Object.defineProperty(chainObj, contract.name, {
+                        enumerable: true,
+                        value: contractObj
+                      });
+                }));
+          Object.defineProperty(chains, chainIdStr, {
+                enumerable: true,
+                value: chainObj
+              });
+          if (chainConfig.name !== chainIdStr) {
+            Object.defineProperty(chains, chainConfig.name, {
+                  enumerable: false,
+                  value: chainObj
+                });
+            return ;
+          }
+          
+        }));
+  Object.defineProperty(indexer, "chainIds", {
+        enumerable: true,
+        value: chainIds
+      });
+  Object.defineProperty(indexer, "chains", {
+        enumerable: true,
+        value: chains
+      });
+  return indexer;
+}
+
+function startServer(getState, ctx, isDevelopmentMode) {
+  var app = Express();
+  var consoleCorsMiddleware = function (req, res, next) {
+    var origin = Js_dict.get(req.headers, "origin");
+    if (origin !== undefined && (origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl)) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+    if (req.method === "OPTIONS") {
+      res.sendStatus(200);
+      return ;
+    } else {
+      return next();
+    }
+  };
+  app.use("/console", consoleCorsMiddleware);
+  app.use("/metrics", consoleCorsMiddleware);
+  app.get("/healthz", (function (_req, res) {
+          res.sendStatus(200);
+        }));
+  app.get("/console/state", (function (_req, res) {
+          var state = isDevelopmentMode ? getState() : ({
+                status: "disabled"
+              });
+          res.json(S$RescriptSchema.reverseConvertToJsonOrThrow(state, stateSchema));
+        }));
+  app.post("/console/syncCache", (function (_req, res) {
+          if (isDevelopmentMode) {
+            Persistence.getInitializedStorageOrThrow(ctx.persistence).dumpEffectCache().then(function () {
+                  res.json(true);
+                });
+          } else {
+            res.json(false);
+          }
+        }));
+  PromClient.collectDefaultMetrics();
+  app.get("/metrics", (function (_req, res) {
+          res.set("Content-Type", PromClient.register.contentType);
+          PromClient.register.metrics().then(function (metrics) {
+                return res.end(metrics);
+              });
+        }));
+  app.listen(Env.serverPort);
+}
+
+async function start(makeGeneratedConfig, persistence, isTestOpt) {
+  var isTest = isTestOpt !== undefined ? isTestOpt : false;
+  var mainArgs = Yargs(Helpers.hideBin(process.argv)).argv;
+  var shouldUseTui = !isTest && !Belt_Option.getWithDefault(mainArgs["tui-off"], Env.tuiOffEnvVar);
+  var isDevelopmentMode = !isTest && Env.Db.password === "testing";
+  var configWithoutRegistrations = makeGeneratedConfig();
+  var registrations = await HandlerLoader.registerAllHandlers(configWithoutRegistrations);
+  var config = makeGeneratedConfig();
+  var config$1 = isTest ? ({
+        name: config.name,
+        description: config.description,
+        handlers: config.handlers,
+        contractHandlers: config.contractHandlers,
+        shouldRollbackOnReorg: false,
+        shouldSaveFullHistory: config.shouldSaveFullHistory,
+        multichain: config.multichain,
+        chainMap: config.chainMap,
+        defaultChain: config.defaultChain,
+        ecosystem: config.ecosystem,
+        enableRawEvents: config.enableRawEvents,
+        maxAddrInPartition: config.maxAddrInPartition,
+        batchSize: config.batchSize,
+        lowercaseAddresses: config.lowercaseAddresses,
+        addContractNameToContractNameMapping: config.addContractNameToContractNameMapping,
+        userEntitiesByName: config.userEntitiesByName
+      }) : config;
+  var ctx = {
+    registrations: registrations,
+    config: config$1,
+    persistence: persistence
+  };
+  var envioVersion = Utils.EnvioPackage.value.version;
+  Prometheus.Info.set(envioVersion);
+  Prometheus.RollbackEnabled.set(config$1.shouldRollbackOnReorg);
+  if (!isTest) {
+    startServer((function () {
+            var gsManager = globalGsManagerRef.contents;
+            if (gsManager === undefined) {
+              return {
+                      status: "initializing"
+                    };
+            }
+            var state = GlobalStateManager.getState(Caml_option.valFromOption(gsManager));
+            var chains = Belt_Array.map(ChainMap.values(state.chainManager.chainFetchers), (function (cf) {
+                    var latestFetchedBlockNumber = Caml.int_max(FetchState.bufferBlockNumber(cf.fetchState), 0);
+                    var knownHeight = ChainFetcher.hasProcessedToEndblock(cf) ? Belt_Option.getWithDefault(cf.fetchState.endBlock, cf.fetchState.knownHeight) : cf.fetchState.knownHeight;
+                    return {
+                            chainId: cf.chainConfig.id,
+                            poweredByHyperSync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync,
+                            firstEventBlockNumber: cf.firstEventBlockNumber,
+                            latestProcessedBlock: cf.committedProgressBlockNumber === -1 ? undefined : cf.committedProgressBlockNumber,
+                            timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
+                            numEventsProcessed: cf.numEventsProcessed,
+                            latestFetchedBlockNumber: latestFetchedBlockNumber,
+                            currentBlockHeight: knownHeight,
+                            numBatchesFetched: cf.numBatchesFetched,
+                            endBlock: cf.fetchState.endBlock,
+                            numAddresses: FetchState.numAddresses(cf.fetchState)
+                          };
+                  }));
+            var match = config$1.multichain;
+            var tmp;
+            tmp = match === "ordered" ? false : true;
+            return {
+                    status: "active",
+                    envioVersion: envioVersion,
+                    chains: chains,
+                    indexerStartTime: state.indexerStartTime,
+                    isPreRegisteringDynamicContracts: false,
+                    isUnorderedMultichainMode: tmp,
+                    rollbackOnReorg: config$1.shouldRollbackOnReorg
+                  };
+          }), ctx, isDevelopmentMode);
+  }
+  await Persistence.init(persistence, ChainMap.values(config$1.chainMap), undefined);
+  var chainManager = await ChainManager.makeFromDbState(Persistence.getInitializedState(persistence), config$1, registrations);
+  var globalState = GlobalState.make(ctx, chainManager, isDevelopmentMode, shouldUseTui);
+  var gsManager = GlobalStateManager.make(globalState, undefined);
+  if (shouldUseTui) {
+    Tui.start(function () {
+          return GlobalStateManager.getState(gsManager);
+        });
+  }
+  globalGsManagerRef.contents = Caml_option.some(gsManager);
+  GlobalStateManager.dispatchTask(gsManager, {
+        TAG: "NextQuery",
+        _0: "CheckAllChains"
+      });
+  return GlobalStateManager.dispatchTask(gsManager, "ProcessEventBatch");
+}
+
+export {
+  chainDataSchema ,
+  stateSchema ,
+  globalGsManagerRef ,
+  getGlobalIndexer ,
+  startServer ,
+  start ,
+}
+/* chainDataSchema Not a pure module */

package/src/Persistence.res

@@ -23,6 +23,7 @@ type initialChainState = {
   firstEventBlockNumber: option<int>,
   timestampCaughtUpToHeadOrEndblock: option<Js.Date.t>,
   dynamicContracts: array<Internal.indexingContract>,
+  sourceBlockNumber: int,
 }
 
 type initialState = {
@@ -90,8 +91,6 @@ type storage = {
   dumpEffectCache: unit => promise<unit>,
   // Execute raw SQL query
   executeUnsafe: string => promise<unknown>,
-  // Check if entity history has rows
-  hasEntityHistoryRows: unit => promise<bool>,
   // Update chain metadata
   setChainMeta: dict<InternalTable.Chains.metaFields> => promise<unknown>,
   // Prune old checkpoints

package/src/PgStorage.gen.ts

@@ -0,0 +1,10 @@
+/* TypeScript file generated from PgStorage.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import * as PgStorageJS from './PgStorage.res.mjs';
+
+import type {sql as Postgres_sql} from '../src/bindings/Postgres.gen.js';
+
+export const makeClient: () => Postgres_sql = PgStorageJS.makeClient as any;