envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/Main.res.mjs

@@ -6,13 +6,14 @@ import * as Envio from "./Envio.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Metrics from "./Metrics.res.mjs";
 import Express from "express";
 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 EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as PromClient from "prom-client";
@@ -20,8 +21,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";
@@ -63,28 +62,24 @@ let stateSchema = S$RescriptSchema.union([
   }))
 ]);
 
-let blockRangeSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
-  _gte: s.f("_gte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _lte: s.f("_lte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _every: s.f("_every", S$RescriptSchema.Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.int, 1, undefined)), 1))
-})));
+function getIndexerState() {
+  return EnvioGlobal.value.indexerState;
+}
 
-let defaultBlockRange = {
-  _gte: undefined,
-  _lte: undefined,
-  _every: 1
-};
+function setIndexerState(state) {
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
+}
 
-let indexerStateRef = {
-  contents: undefined
-};
+function getGlobalPersistence() {
+  return EnvioGlobal.value.persistence;
+}
 
-let globalPersistenceRef = {
-  contents: undefined
-};
+function setGlobalPersistence(persistence) {
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence);
+}
 
 function getInitialChainState(chainId) {
-  let persistence = globalPersistenceRef.contents;
+  let persistence = EnvioGlobal.value.persistence;
   if (persistence === undefined) {
     return;
   }
@@ -136,7 +131,7 @@ function buildChainsObject(config) {
     }), "isRealtime", {
       enumerable: true,
       get: () => {
-        let state = indexerStateRef.contents;
+        let state = EnvioGlobal.value.indexerState;
         if (state !== undefined) {
           return IndexerState.isRealtime(Primitive_option.valFromOption(state));
         } else if (Env.updateSyncTimeOnRestart) {
@@ -164,33 +159,24 @@ function buildChainsObject(config) {
       }), "addresses", {
         enumerable: true,
         get: () => {
-          let state = indexerStateRef.contents;
+          let state = EnvioGlobal.value.indexerState;
           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 addresses = [];
-            let values = Object.values(indexingAddresses);
-            for (let idx = 0, idx_finish = values.length; idx < idx_finish; ++idx) {
-              let indexingContract = values[idx];
-              if (indexingContract.contractName === contract.name) {
-                addresses.push(indexingContract.address);
-              }
-            }
-            return addresses;
+            return ChainState.contractAddresses(chainState, contract.name);
           }
           let chainState$1 = getInitialChainState(chainConfig.id);
           if (chainState$1 === undefined) {
             return contract.addresses;
           }
-          let addresses$1 = contract.addresses.slice();
+          let addresses = contract.addresses.slice();
           chainState$1.indexingAddresses.forEach(dc => {
             if (dc.contractName === contract.name) {
-              addresses$1.push(dc.address);
+              addresses.push(dc.address);
               return;
             }
           });
-          return addresses$1;
+          return addresses;
         }
       });
       Object.defineProperty(chainObj, contract.name, {
@@ -289,69 +275,9 @@ function getGlobalIndexer() {
     HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
     RollbackCommit.register(callback);
   };
-  let extractRange = (filter, name, ecosystem) => {
-    try {
-      let inner = S$RescriptSchema.parseOrThrow(filter, ecosystem.onBlockFilterSchema);
-      if (inner !== undefined) {
-        return S$RescriptSchema.parseOrThrow(Primitive_option.valFromOption(inner), blockRangeSchema);
-      } else {
-        return defaultBlockRange;
-      }
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
-        return Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` returned an invalid filter: ` + Utils.prettifyExn(exn._1));
-      }
-      throw exn;
-    }
-  };
   let onBlockFn = (rawOptions, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onBlock");
-    let config = Config.loadWithoutRegistrations();
-    let ecosystem = config.ecosystem;
-    let match = buildChainsObject(config);
-    let chains = match[0];
-    let name = rawOptions.name;
-    let logger = Logging.createChild({
-      onBlock: name
-    });
-    let w = rawOptions.where;
-    let where = w === undefined || w === null ? undefined : (
-        typeof w === "function" ? rawOptions.where : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` expected \`where\` to be a function or omitted, but got ` + typeof w + `.`)
-      );
-    let matchedAny = {
-      contents: false
-    };
-    ChainMap.values(config.chainMap).forEach(chainConfig => {
-      let chainId = chainConfig.id;
-      let chainObj = chains[chainId.toString()];
-      let result = where !== undefined ? where({
-          chain: chainObj
-        }) : true;
-      let match = result === true ? [
-          true,
-          defaultBlockRange
-        ] : (
-          result === false ? [
-              false,
-              defaultBlockRange
-            ] : (
-              typeof result === "object" && !Array.isArray(result) && result !== null ? [
-                  true,
-                  extractRange(result, name, ecosystem)
-                ] : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` predicate returned an invalid value of type ` + typeof result + `. Expected boolean or a filter object.`)
-            )
-        );
-      if (!match[0]) {
-        return;
-      }
-      let range = match[1];
-      matchedAny.contents = true;
-      HandlerRegister.registerOnBlock(name, chainId, range._every, range._gte, range._lte, handler);
-    });
-    if (!matchedAny.contents) {
-      return Logging.childWarn(logger, `\`indexer.` + ecosystem.onBlockMethodName + `\` matched 0 chains. Check the \`where\` predicate.`);
-    }
+    HandlerRegister.registerOnBlock(rawOptions.name, rawOptions.where, handler, config => buildChainsObject(config)[0]);
   };
   let keysMemo = {
     contents: undefined
@@ -361,7 +287,7 @@ function getGlobalIndexer() {
     if (k !== undefined) {
       return k;
     }
-    let match = Config.loadWithoutRegistrations().ecosystem.name;
+    let match = Config.load().ecosystem.name;
     let keys;
     let exit = 0;
     switch (match) {
@@ -399,15 +325,15 @@ function getGlobalIndexer() {
   let get = prop => {
     switch (prop) {
       case "chainIds" :
-        return buildChainsObject(Config.loadWithoutRegistrations())[1];
+        return buildChainsObject(Config.load())[1];
       case "chains" :
-        return buildChainsObject(Config.loadWithoutRegistrations())[0];
+        return buildChainsObject(Config.load())[0];
       case "contractRegister" :
         return contractRegisterFn;
       case "description" :
-        return Config.loadWithoutRegistrations().description;
+        return Config.load().description;
       case "name" :
-        return Config.loadWithoutRegistrations().name;
+        return Config.load().name;
       case "onEvent" :
         return onEventFn;
       case "onInstruction" :
@@ -489,7 +415,7 @@ function startServer(getState, persistence, isDevelopmentMode) {
   });
   app.get("/metrics", (_req, res) => {
     res.set("Content-Type", PromClient.register.contentType);
-    PromClient.register.metrics().then(metrics => res.end(metrics));
+    Metrics.collect(EnvioGlobal.value.indexerState).then(metrics => res.end(metrics));
   });
   app.get("/metrics/runtime", (_req, res) => {
     res.set("Content-Type", runtimeRegistry.contentType);
@@ -512,19 +438,21 @@ function getEnvioInfo() {
 }
 
 async function migrate(reset) {
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
   await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset);
   return await persistence.storage.close();
 }
 
 async function dropSchema() {
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
   await persistence.storage.reset();
   return await persistence.storage.close();
 }
 
+let FatalError = /* @__PURE__ */Primitive_exceptions.create("Main.FatalError");
+
 async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockOpt, patchConfig) {
   let reset = resetOpt !== undefined ? resetOpt : false;
   let isTest = isTestOpt !== undefined ? isTestOpt : false;
@@ -535,14 +463,12 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let shouldUseTui = isTest ? false : (
       explicitTui !== undefined ? explicitTui : !Envio.isNonInteractive()
     );
-  let configWithoutRegistrations = Config.loadWithoutRegistrations();
-  let isDevelopmentMode = !isTest && configWithoutRegistrations.isDev;
-  let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(configWithoutRegistrations, undefined);
-  globalPersistenceRef.contents = persistence$1;
-  await Persistence.init(persistence$1, ChainMap.values(configWithoutRegistrations.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
-  let match = await HandlerLoader.registerAllHandlers(configWithoutRegistrations);
-  let registrations = match[1];
-  let config = match[0];
+  let config = Config.load();
+  let isDevelopmentMode = !isTest && config.isDev;
+  let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
+  await Persistence.init(persistence$1, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
+  let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1 = isTest ? ({
       name: config.name,
       description: config.description,
@@ -564,14 +490,19 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       allEntities: config.allEntities,
       allEnums: config.allEnums
     }) : config;
-  let config$2 = patchConfig !== undefined ? patchConfig(config$1, registrations) : config$1;
+  let config$2 = patchConfig !== undefined ? patchConfig(config$1, registrationsByChainId) : config$1;
+  let onErrorReject = {
+    contents: undefined
+  };
+  let runUntilFatalError = new Promise((_resolve, reject) => {
+    onErrorReject.contents = reject;
+  });
   let onError = errHandler => {
     ErrorHandling.log(errHandler);
-    if (isTest) {
-      setImmediate(() => ErrorHandling.raiseExn(errHandler));
-    } else {
-      Process.exit(1);
-    }
+    onErrorReject.contents({
+      RE_EXN_ID: FatalError,
+      _1: Utils.prettifyExn(errHandler.exn)
+    });
   };
   let envioVersion = Utils.EnvioPackage.value.version;
   Prometheus.Info.set(envioVersion);
@@ -579,32 +510,14 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   Prometheus.RollbackEnabled.set(config$2.shouldRollbackOnReorg);
   if (!isTest) {
     startServer(() => {
-      let state = indexerStateRef.contents;
+      let state = EnvioGlobal.value.indexerState;
       if (state === undefined) {
         return {
           status: "initializing"
         };
       }
       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,
@@ -615,21 +528,22 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       };
     }, persistence$1, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrations, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
   if (shouldUseTui) {
     Tui.start(() => state);
   }
-  indexerStateRef.contents = Primitive_option.some(state);
-  return IndexerLoop.start(state);
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
+  IndexerLoop.start(state);
+  return await runUntilFatalError;
 }
 
 export {
   chainDataSchema,
   stateSchema,
-  blockRangeSchema,
-  defaultBlockRange,
-  indexerStateRef,
-  globalPersistenceRef,
+  getIndexerState,
+  setIndexerState,
+  getGlobalPersistence,
+  setGlobalPersistence,
   getInitialChainState,
   buildChainsObject,
   getGlobalIndexer,
@@ -637,6 +551,7 @@ export {
   getEnvioInfo,
   migrate,
   dropSchema,
+  FatalError,
   start,
 }
 /* chainDataSchema Not a pure module */

package/src/Metrics.res

@@ -0,0 +1,74 @@
+// Pull-based metrics computed from live indexer state at scrape time, merged with
+// the imperatively-updated prom-client default registry. Used because the address
+// index is mutated in place (no single update site to fire a gauge from).
+
+let indexingAddressesName = "envio_indexing_addresses"
+let indexingAddressesHelp = "The number of addresses indexed on chain. Includes both static and dynamic addresses."
+
+// Render a gauge straight from the per-chain dict, one sample per key, without
+// materialising an intermediate samples array. Accumulate into one string rather
+// than building a lines array to join: `++` compiles to JS `+=`, which V8 grows
+// as a ConsString instead of recopying.
+let renderGauge = (~name, ~help, ~chains: dict<'a>, ~value: 'a => int) => {
+  let out = ref(`# HELP ${name} ${help}\n# TYPE ${name} gauge`)
+  let prefix = `\n${name}{chainId="`
+  chains->Utils.Dict.forEachWithKey((chain, chainId) => {
+    out := out.contents ++ prefix ++ chainId ++ `"} ` ++ value(chain)->Int.toString
+  })
+  out.contents
+}
+
+let sourceRequestTotalName = "envio_source_request_total"
+let sourceRequestTotalHelp = "The number of requests made to data sources."
+let sourceRequestSecondsTotalName = "envio_source_request_seconds_total"
+let sourceRequestSecondsTotalHelp = "Cumulative time spent on data source requests."
+
+// Hand-rolls both HELP/TYPE blocks and their samples straight from
+// SourceManager's aggregates — fully our own state, no prom-client registry
+// involved. A leading "\n" on each block since, unlike prom-client's own
+// metrics() output, renderGauge's output right before this doesn't end in one.
+// Skips a method's seconds line when it has no timing (e.g. heightSubscription,
+// which only ever records a count), and skips both blocks entirely when there's
+// nothing to report at all.
+let renderSourceRequests = (~samples: array<SourceManager.requestStatSample>) => {
+  if samples->Utils.Array.isEmpty {
+    ""
+  } else {
+    let countOut = ref(
+      `\n# HELP ${sourceRequestTotalName} ${sourceRequestTotalHelp}\n# TYPE ${sourceRequestTotalName} counter`,
+    )
+    let secondsOut = ref(
+      `\n# HELP ${sourceRequestSecondsTotalName} ${sourceRequestSecondsTotalHelp}\n# TYPE ${sourceRequestSecondsTotalName} counter`,
+    )
+    samples->Array.forEach(sample => {
+      let labels = `{source="${sample.sourceName}",chainId="${sample.chainId->Int.toString}",method="${sample.method}"}`
+      countOut :=
+        countOut.contents ++ `\n${sourceRequestTotalName}${labels} ${sample.count->Int.toString}`
+      if sample.seconds !== 0. {
+        secondsOut :=
+          secondsOut.contents ++
+          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toFixed(~digits=3)}`
+      }
+    })
+    countOut.contents ++ secondsOut.contents
+  }
+}
+
+let collect = async (~state: option<IndexerState.t>) => {
+  let base = await PromClient.defaultRegister->PromClient.metrics
+  switch state {
+  | None => base
+  | Some(state) =>
+    let chainStates = state->IndexerState.chainStates
+    let sourceRequestSamples =
+      chainStates
+      ->Dict.valuesToArray
+      ->Array.flatMap(cs => cs->ChainState.sourceManager->SourceManager.getRequestStatSamples)
+    `${base}${renderGauge(
+        ~name=indexingAddressesName,
+        ~help=indexingAddressesHelp,
+        ~chains=chainStates,
+        ~value=cs => (cs->ChainState.toChainData).numAddresses,
+      )}${renderSourceRequests(~samples=sourceRequestSamples)}\n`
+  }
+}

package/src/Metrics.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as PromClient from "prom-client";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let indexingAddressesName = "envio_indexing_addresses";
+
+let indexingAddressesHelp = "The number of addresses indexed on chain. Includes both static and dynamic addresses.";
+
+function renderGauge(name, help, chains, value) {
+  let out = {
+    contents: `# HELP ` + name + ` ` + help + `\n# TYPE ` + name + ` gauge`
+  };
+  let prefix = `\n` + name + `{chainId="`;
+  Utils.Dict.forEachWithKey(chains, (chain, chainId) => {
+    out.contents = out.contents + prefix + chainId + `"} ` + value(chain).toString();
+  });
+  return out.contents;
+}
+
+let sourceRequestTotalName = "envio_source_request_total";
+
+let sourceRequestTotalHelp = "The number of requests made to data sources.";
+
+let sourceRequestSecondsTotalName = "envio_source_request_seconds_total";
+
+let sourceRequestSecondsTotalHelp = "Cumulative time spent on data source requests.";
+
+function renderSourceRequests(samples) {
+  if (Utils.$$Array.isEmpty(samples)) {
+    return "";
+  }
+  let countOut = {
+    contents: `\n# HELP ` + sourceRequestTotalName + ` ` + sourceRequestTotalHelp + `\n# TYPE ` + sourceRequestTotalName + ` counter`
+  };
+  let secondsOut = {
+    contents: `\n# HELP ` + sourceRequestSecondsTotalName + ` ` + sourceRequestSecondsTotalHelp + `\n# TYPE ` + sourceRequestSecondsTotalName + ` counter`
+  };
+  samples.forEach(sample => {
+    let labels = `{source="` + sample.sourceName + `",chainId="` + sample.chainId.toString() + `",method="` + sample.method + `"}`;
+    countOut.contents = countOut.contents + (`\n` + sourceRequestTotalName + labels + ` ` + sample.count.toString());
+    if (sample.seconds !== 0) {
+      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toFixed(3));
+      return;
+    }
+  });
+  return countOut.contents + secondsOut.contents;
+}
+
+async function collect(state) {
+  let base = await PromClient.register.metrics();
+  if (state === undefined) {
+    return base;
+  }
+  let chainStates = IndexerState.chainStates(Primitive_option.valFromOption(state));
+  let sourceRequestSamples = Object.values(chainStates).flatMap(cs => SourceManager.getRequestStatSamples(ChainState.sourceManager(cs)));
+  return base + renderGauge(indexingAddressesName, indexingAddressesHelp, chainStates, cs => ChainState.toChainData(cs).numAddresses) + renderSourceRequests(sourceRequestSamples) + `\n`;
+}
+
+export {
+  indexingAddressesName,
+  indexingAddressesHelp,
+  renderGauge,
+  sourceRequestTotalName,
+  sourceRequestTotalHelp,
+  sourceRequestSecondsTotalName,
+  sourceRequestSecondsTotalHelp,
+  renderSourceRequests,
+  collect,
+}
+/* Utils Not a pure module */

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 {