envio 3.0.0-alpha.3 → 3.0.0-alpha.5

package/src/Main.res

@@ -0,0 +1,342 @@
+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 (
+  ~registerAllHandlers: unit => promise<EventRegister.registrations>,
+  ~makeGeneratedConfig: unit => Config.t,
+  ~persistence: Persistence.t,
+) => {
+  let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
+  let shouldUseTui = !(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.
+  let isDevelopmentMode = Env.Db.password === "testing"
+
+  let registrations = await registerAllHandlers()
+  let config = makeGeneratedConfig()
+  let ctx = {
+    Ctx.registrations,
+    config,
+    persistence,
+  }
+
+  let envioVersion = Utils.EnvioPackage.value.version
+  Prometheus.Info.set(~version=envioVersion)
+  Prometheus.RollbackEnabled.set(~enabled=ctx.config.shouldRollbackOnReorg)
+
+  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,
+    ~persistence=ctx.persistence,
+  )
+  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,289 @@
+// 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 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(registerAllHandlers, makeGeneratedConfig, persistence) {
+  var mainArgs = Yargs(Helpers.hideBin(process.argv)).argv;
+  var shouldUseTui = !Belt_Option.getWithDefault(mainArgs["tui-off"], Env.tuiOffEnvVar);
+  var isDevelopmentMode = Env.Db.password === "testing";
+  var registrations = await registerAllHandlers();
+  var config = makeGeneratedConfig();
+  var ctx = {
+    registrations: registrations,
+    config: config,
+    persistence: persistence
+  };
+  var envioVersion = Utils.EnvioPackage.value.version;
+  Prometheus.Info.set(envioVersion);
+  Prometheus.RollbackEnabled.set(config.shouldRollbackOnReorg);
+  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.multichain;
+          var tmp;
+          tmp = match === "ordered" ? false : true;
+          return {
+                  status: "active",
+                  envioVersion: envioVersion,
+                  chains: chains,
+                  indexerStartTime: state.indexerStartTime,
+                  isPreRegisteringDynamicContracts: false,
+                  isUnorderedMultichainMode: tmp,
+                  rollbackOnReorg: config.shouldRollbackOnReorg
+                };
+        }), ctx, isDevelopmentMode);
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), undefined);
+  var chainManager = await ChainManager.makeFromDbState(Persistence.getInitializedState(persistence), config, registrations, persistence);
+  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/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;

package/src/PgStorage.res

@@ -1,5 +1,28 @@
 let getCacheRowCountFnName = "get_cache_row_count"
 
+// Only needed for some old tests
+// Remove @genType in the future
+@genType
+let makeClient = () => {
+  Postgres.makeSql(
+    ~config={
+      host: Env.Db.host,
+      port: Env.Db.port,
+      username: Env.Db.user,
+      password: Env.Db.password,
+      database: Env.Db.database,
+      ssl: Env.Db.ssl,
+      // TODO: think how we want to pipe these logs to pino.
+      onnotice: ?(
+        Env.userLogLevel == #warn || Env.userLogLevel == #error ? None : Some(_str => ())
+      ),
+      transform: {undefined: Null},
+      max: 2,
+      // debug: (~connection, ~query, ~params as _, ~types as _) => Js.log2(connection, query),
+    },
+  )
+}
+
 let makeCreateIndexQuery = (~tableName, ~indexFields, ~pgSchema) => {
   let indexName = tableName ++ "_" ++ indexFields->Js.Array2.joinWith("_")
   let index = indexFields->Belt.Array.map(idx => `"${idx}"`)->Js.Array2.joinWith(", ")
@@ -1056,8 +1079,7 @@ let make = (
   }
 
   let cacheDirPath = NodeJs.Path.resolve([
-    // Right outside of the generated directory
-    "..",
+    // Right at the project root
     ".envio",
     "cache",
   ])

package/src/PgStorage.res.d.mts

@@ -0,0 +1,5 @@
+// This is to prevent tsc --noEmit from failing
+// when importing code from .res.mjs files in genType .ts files
+// After we upgrade GenType and it starts to include ts-ignore,
+// the line can be removed.
+export const makeClient: any;