envio 3.13.0-rc.0 → 3.14.0

package/src/Config.res.mjs

@@ -18,7 +18,6 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as ContractMapping from "./ContractMapping.res.mjs";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -439,6 +438,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   handlers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   isDev: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   isolatedChains: s.m(S$RescriptSchema.option(S$RescriptSchema.array(ChainId.schema))),
+  projectFlags: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   fullBatchSize: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   saveFullHistory: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
@@ -495,6 +495,41 @@ function isolate(config, chainIds) {
   return newrecord;
 }
 
+let commandFields = [
+  "isDev",
+  "isolatedChains",
+  "projectFlags"
+];
+
+function withProjectFlags(command, config) {
+  let flags = config.projectFlags;
+  if (flags === "") {
+    return command;
+  } else {
+    return command + ` ` + flags;
+  }
+}
+
+let ecosystemFields = [
+  "evm",
+  "fuel",
+  "svm"
+];
+
+function toEnvioInfo(publicConfigJson) {
+  let envioInfo = JSON.parse(JSON.stringify(publicConfigJson));
+  if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
+    commandFields.forEach(field => Utils.Dict.deleteInPlace(envioInfo, field));
+    ecosystemFields.forEach(ecosystem => {
+      let match = envioInfo[ecosystem];
+      if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+        return Utils.Dict.deleteInPlace(match, "chains");
+      }
+    });
+  }
+  return envioInfo;
+}
+
 function fromPublic(publicConfigJson) {
   let publicConfig;
   try {
@@ -801,7 +836,9 @@ function fromPublic(publicConfigJson) {
   let config_enableRawEvents = Stdlib_Option.getOr(publicConfig.rawEvents, false);
   let config_batchSize = Stdlib_Option.getOr(publicConfig.fullBatchSize, 5000);
   let config_isDev = Stdlib_Option.getOr(publicConfig.isDev, false);
+  let config_projectFlags = Stdlib_Option.getOr(publicConfig.projectFlags, "");
   let config_checkpointSequence = CheckpointSequence.fromEntities(userEntities);
+  let config_envioInfo = toEnvioInfo(publicConfigJson);
   let config = {
     name: config_name,
     description: config_description,
@@ -823,11 +860,13 @@ function fromPublic(publicConfigJson) {
     reorgThresholdReadyTolerance: 100,
     lowercaseAddresses: lowercaseAddresses,
     isDev: config_isDev,
+    projectFlags: config_projectFlags,
     isolated: false,
     userEntitiesByName: userEntitiesByName,
     userEntities: userEntities,
     allEnums: allEnums,
-    checkpointSequence: config_checkpointSequence
+    checkpointSequence: config_checkpointSequence,
+    envioInfo: config_envioInfo
   };
   let chainIds = publicConfig.isolatedChains;
   if (chainIds !== undefined) {
@@ -933,44 +972,6 @@ function getPublicConfigJson() {
   }
 }
 
-function stripSensitiveData(json) {
-  let cloned = JSON.parse(JSON.stringify(json));
-  let stripChains = ecosystem => {
-    if (ecosystem === undefined) {
-      return;
-    }
-    if (typeof ecosystem !== "object" || ecosystem === null || Array.isArray(ecosystem)) {
-      return;
-    }
-    let match = ecosystem["chains"];
-    if (match === undefined) {
-      return;
-    }
-    if (typeof match !== "object" || match === null || Array.isArray(match)) {
-      return;
-    }
-    Object.values(match).forEach(chainJson => {
-      if (typeof chainJson !== "object" || chainJson === null || Array.isArray(chainJson)) {
-        return;
-      }
-      Utils.Dict.deleteInPlace(chainJson, "rpcs");
-      Utils.Dict.deleteInPlace(chainJson, "hypersync");
-    });
-  };
-  if (typeof cloned === "object" && cloned !== null && !Array.isArray(cloned)) {
-    Utils.Dict.deleteInPlace(cloned, "isDev");
-    Utils.Dict.deleteInPlace(cloned, "isolatedChains");
-    stripChains(cloned["evm"]);
-    stripChains(cloned["fuel"]);
-    stripChains(cloned["svm"]);
-  }
-  return cloned;
-}
-
-function envioInfo() {
-  return stripSensitiveData(getPublicConfigJson());
-}
-
 function canonicalJson(json) {
   if (Array.isArray(json)) {
     return json.map(canonicalJson);
@@ -1088,7 +1089,8 @@ function diffPaths(stored, current) {
       [
         "evm",
         "fuel",
-        "svm"
+        "svm",
+        "chains"
       ],
       ["entities"]
     ];
@@ -1113,10 +1115,7 @@ function diffPaths(stored, current) {
   return acc;
 }
 
-function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhouse) {
-  if (changedPaths.length === 0) {
-    return;
-  }
+function incompatibleMessage(changedPaths, resetCommand, runCommand, hasClickhouse) {
   let bullets = changedPaths.map(p => `    - ` + p).join("\n");
   let option1 = "Revert the changes above";
   let padTo = (s, col) => s + " ".repeat(Math.max(col - s.length | 0, 1));
@@ -1128,20 +1127,7 @@ function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhou
   } else {
     option3 = "";
   }
-  Stdlib_JsError.throwWithMessage(`The following config changes are incompatible with the existing indexer data:\n\n` + bullets + `\n\nPick one:\n  1. ` + padTo(option1, col) + `# resume indexing where it left off\n  2. ` + padTo(resetCommand, col) + `# delete all indexed data and start over` + option3);
-}
-
-function throwIfResumeIncompatible(storedEnvioInfo, storedContractMapping, envioInfo, contractMapping, resetCommand, runCommand) {
-  let changedPaths = storedEnvioInfo !== undefined ? diffPaths(storedEnvioInfo, envioInfo) : ["storage was initialized by an older envio version"];
-  let changedPaths$1 = ContractMapping.isEqual(storedContractMapping, contractMapping) ? changedPaths : changedPaths.concat(["contracts"]);
-  let hasClickhouse;
-  if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
-    let match = envioInfo["storage"];
-    hasClickhouse = typeof match === "object" && match !== null && !Array.isArray(match) ? Primitive_object.equal(match["clickhouse"], true) : false;
-  } else {
-    hasClickhouse = false;
-  }
-  throwIfIncompatible(changedPaths$1, resetCommand, runCommand, hasClickhouse);
+  return `The following config changes are incompatible with the existing indexer data:\n\n` + bullets + `\n\nPick one:\n  1. ` + padTo(option1, col) + `# resume indexing where it left off\n  2. ` + padTo(resetCommand, col) + `# delete all indexed data and start over` + option3;
 }
 
 function load() {
@@ -1195,6 +1181,10 @@ export {
   getChain,
   isPerChain,
   isolate,
+  commandFields,
+  withProjectFlags,
+  ecosystemFields,
+  toEnvioInfo,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
@@ -1202,12 +1192,9 @@ export {
   prime,
   withCommandFields,
   getPublicConfigJson,
-  stripSensitiveData,
-  envioInfo,
   canonicalJson,
   diffPaths,
-  throwIfIncompatible,
-  throwIfResumeIncompatible,
+  incompatibleMessage,
   load,
   getPgUserEntities,
 }

package/src/Core.res

@@ -12,6 +12,7 @@ type transactionStoreCtor
 type blockStoreCtor
 type clickHouseSinkCtor
 type addressStoreCtor
+type tuiCtor
 // Test-only: a local HyperSync server, bound by MockHyperSyncServer in envio-tests.
 type mockHyperSyncServerCtor
 type fromUserApiOptions = {
@@ -33,6 +34,10 @@ type addon = {
   isSvmPubkey: (~value: string) => bool,
   fromUserApi: (string, fromUserApiOptions) => fromUserApiResult,
   runCli: (~args: array<string>, ~envioPackageDir: Null.t<string>) => promise<Null.t<string>>,
+  loadTs: string => string,
+  tsCheckHandlerFormat: string => unit,
+  tsResolveCandidates: (string, Null.t<string>) => array<string>,
+  tsNotFoundCandidates: (string, Null.t<string>, string) => array<string>,
   @as("EvmHyperSyncClient")
   evmHyperSyncClient: evmHyperSyncClientCtor,
   @as("EvmRpcClient")
@@ -49,6 +54,8 @@ type addon = {
   addressStore: addressStoreCtor,
   @as("ClickHouseSink")
   clickHouseSink: clickHouseSinkCtor,
+  @as("Tui")
+  tui: tuiCtor,
   @as("MockHyperSyncServer")
   mockHyperSyncServer: mockHyperSyncServerCtor,
   encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
@@ -99,7 +106,7 @@ let callRequire: ({..}, string) => addon = %raw(`(req, id) => req(id)`)
 let envioPackageDir = pathDirname(pathDirname(fileURLToPath(importMetaUrl)))
 
 // Runs `cargo build` on every invocation (like `cargo run`).
-let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
+let loadDevAddon: ({..}, string) => Null.t<addon> = %raw(`function(req, envioDir) {
   var cp = Nodechild_process;
   var path = Nodepath;
   var fs = Nodefs;
@@ -177,6 +184,22 @@ let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
 // `code`, and any other fields a diagnostic might rely on.
 let rethrow: JsExn.t => 'a = %raw(`function(e) { throw e }`)
 
+type packageJson = {version: string}
+let requirePackageJson: ({..}, string) => packageJson = %raw(`(req, p) => req(p)`)
+let devVersion = "0.0.1-dev"
+
+let isGlibc: unit => bool = %raw(`() => Boolean(process.report?.getReport().header.glibcVersionRuntime)`)
+
+@val external npmUserAgent: option<string> = "process.env.npm_config_user_agent"
+
+let addCommand = () =>
+  switch npmUserAgent {
+  | Some(ua) if ua->String.startsWith("pnpm/") => "pnpm add"
+  | Some(ua) if ua->String.startsWith("yarn/") => "yarn add"
+  | Some(ua) if ua->String.startsWith("bun/") => "bun add"
+  | _ => "npm install"
+  }
+
 let loadAddon = () => {
   let req = createRequire(importMetaUrl)
 
@@ -212,15 +235,32 @@ let loadAddon = () => {
   switch tryRequire(0) {
   | Some(addon) => addon
   | None =>
-    // Dev build fallback (cargo build on every run)
-    switch loadDevAddon(req, envioPackageDir)->(Utils.magic: addon => option<addon>) {
+    let version = requirePackageJson(req, "../package.json").version
+    // Publishing stamps the real version, so only a monorepo checkout (or a
+    // `file:` link to one) can have a dev build to fall back to. Skipping it
+    // spares published installs a `pnpm list` spawn before the error below.
+    let devAddon = if version === devVersion {
+      loadDevAddon(req, envioPackageDir)->Null.toOption
+    } else {
+      None
+    }
+    switch devAddon {
     | Some(addon) => addon
     | None =>
       let host = `${processPlatform}-${processArch}`
-      let msg = if candidates->Array.length === 0 {
+      let msg = switch candidates {
+      | []
+        if processPlatform === "win32" => `envio doesn't run natively on Windows. Use WSL 2 instead: https://learn.microsoft.com/windows/wsl/install`
+      | [] =>
         `envio doesn't support ${host}. Supported: linux-x64 (glibc/musl), linux-arm64, darwin-x64, darwin-arm64.`
-      } else {
-        `Couldn't load the envio native addon for ${host}. Reinstall envio (ensure optional dependencies aren't skipped).`
+      | _ =>
+        let pkg = if processPlatform === "linux" && processArch === "x64" && !isGlibc() {
+          `envio-linux-x64-musl`
+        } else {
+          candidates->Array.getUnsafe(0)
+        }
+        `envio's native binary for ${host} isn't installed (package "${pkg}"). This happens when optional dependencies are skipped (--omit=optional, --no-optional) or the lockfile was generated on another platform.
+Reinstall dependencies, or add the package explicitly: ${addCommand()} ${pkg}@${version}`
       }
       JsError.throwWithMessage(msg)
     }

package/src/Core.res.mjs

@@ -6,6 +6,7 @@ import * as Nodepath from "node:path";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Nodemodule from "node:module";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Nodechild_process from "node:child_process";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -97,6 +98,29 @@ let loadDevAddon = (function(req, envioDir) {
 
 let rethrow = (function(e) { throw e });
 
+let requirePackageJson = ((req, p) => req(p));
+
+let devVersion = "0.0.1-dev";
+
+let isGlibc = (() => Boolean(process.report?.getReport().header.glibcVersionRuntime));
+
+function addCommand() {
+  let ua = process.env.npm_config_user_agent;
+  if (ua !== undefined) {
+    if (ua.startsWith("pnpm/")) {
+      return "pnpm add";
+    } else if (ua.startsWith("yarn/")) {
+      return "yarn add";
+    } else if (ua.startsWith("bun/")) {
+      return "bun add";
+    } else {
+      return "npm install";
+    }
+  } else {
+    return "npm install";
+  }
+}
+
 function loadAddon() {
   let req = Nodemodule.createRequire(import.meta.url);
   let match = process.platform;
@@ -161,12 +185,21 @@ function loadAddon() {
   if (addon !== undefined) {
     return addon;
   }
-  let addon$1 = loadDevAddon(req, envioPackageDir);
-  if (addon$1 !== undefined) {
-    return addon$1;
+  let version = requirePackageJson(req, "../package.json").version;
+  let devAddon = version === devVersion ? Primitive_option.fromNull(loadDevAddon(req, envioPackageDir)) : undefined;
+  if (devAddon !== undefined) {
+    return devAddon;
   }
   let host = process.platform + `-` + process.arch;
-  return Stdlib_JsError.throwWithMessage(candidates.length === 0 ? `envio doesn't support ` + host + `. Supported: linux-x64 (glibc/musl), linux-arm64, darwin-x64, darwin-arm64.` : `Couldn't load the envio native addon for ` + host + `. Reinstall envio (ensure optional dependencies aren't skipped).`);
+  let tmp;
+  if (candidates.length !== 0) {
+    let pkg = process.platform === "linux" && process.arch === "x64" && !isGlibc() ? `envio-linux-x64-musl` : candidates[0];
+    tmp = `envio's native binary for ` + host + ` isn't installed (package "` + pkg + `"). This happens when optional dependencies are skipped (--omit=optional, --no-optional) or the lockfile was generated on another platform.
+Reinstall dependencies, or add the package explicitly: ` + addCommand() + ` ` + pkg + `@` + version;
+  } else {
+    tmp = process.platform === "win32" ? `envio doesn't run natively on Windows. Use WSL 2 instead: https://learn.microsoft.com/windows/wsl/install` : `envio doesn't support ` + host + `. Supported: linux-x64 (glibc/musl), linux-arm64, darwin-x64, darwin-arm64.`;
+  }
+  return Stdlib_JsError.throwWithMessage(tmp);
 }
 
 let addonRef = {
@@ -211,6 +244,10 @@ export {
   envioPackageDir,
   loadDevAddon,
   rethrow,
+  requirePackageJson,
+  devVersion,
+  isGlibc,
+  addCommand,
   loadAddon,
   addonRef,
   getAddon,

package/src/CrossChainState.res

@@ -199,7 +199,7 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
   for i in 0 to chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(chainIds->Array.getUnsafe(i))
     cs->ChainState.applyBatchProgress(~batch, ~blockTimestampName)
-    if !(cs->ChainState.hasProcessedToEndblock || cs->ChainState.isProgressAtHead) {
+    if !(cs->ChainState.hasCaughtUp) {
       everyChainCaughtUp := false
     }
   }
@@ -254,7 +254,7 @@ let markCaughtUpOnResume = (crossChainState: t) => {
   let everyChainCaughtUp = ref(crossChainState.chainIds->Array.length > 0)
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    if !(cs->ChainState.isDurablyCaughtUp) {
+    if !(cs->ChainState.hasCaughtUp) {
       everyChainCaughtUp := false
     }
   }
@@ -284,11 +284,19 @@ let markReady = (crossChainState: t, ~readyAt) => {
   crossChainState.isRealtime = true
 }
 
+// What a caught-up chain is waiting on before its process can finalize: the run
+// holding the process back, or another chain it drives still behind. Read when
+// the chain speaks, so "waiting" is said only while it is true.
+let isWaitingOnOthers = (crossChainState: t, cs: ChainState.t) =>
+  crossChainState.holdRealtime ||
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.some(other => other !== cs && !(other->ChainState.hasCaughtUp))
+
 // Each chain that has just finished indexing, said once, by the chain it is
 // about — so a chain that finishes early says so then, rather than when the
 // last chain in its process catches up.
-let reportFinished = (crossChainState: t) => {
-  let waitingOnOthers = crossChainState.holdRealtime || crossChainState.chainIds->Array.length > 1
+let reportFinished = (crossChainState: t) =>
   crossChainState.chainStates
   ->Dict.valuesToArray
   ->Array.forEach(cs =>
@@ -301,7 +309,7 @@ let reportFinished = (crossChainState: t) => {
       cs
       ->ChainState.logger
       ->Logging.childInfo({
-        "msg": waitingOnOthers
+        "msg": crossChainState->isWaitingOnOthers(cs)
           ? "Finished backfill. Waiting for the other chains."
           : "Finished backfill.",
         "block": block,
@@ -309,7 +317,6 @@ let reportFinished = (crossChainState: t) => {
     | None => ()
     }
   )
-}
 
 // --- Fetch control. ---
 

package/src/CrossChainState.res.mjs

@@ -141,7 +141,7 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
   for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[chainIds[i]];
     ChainState.applyBatchProgress(cs, batch, blockTimestampName);
-    if (!(ChainState.hasProcessedToEndblock(cs) || ChainState.isProgressAtHead(cs))) {
+    if (!ChainState.hasCaughtUp(cs)) {
       everyChainCaughtUp = false;
     }
   }
@@ -169,7 +169,7 @@ function markCaughtUpOnResume(crossChainState) {
   let everyChainCaughtUp = crossChainState.chainIds.length !== 0;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
-    if (!ChainState.isDurablyCaughtUp(cs)) {
+    if (!ChainState.hasCaughtUp(cs)) {
       everyChainCaughtUp = false;
     }
   }
@@ -191,8 +191,21 @@ function markReady(crossChainState, readyAt) {
   crossChainState.isRealtime = true;
 }
 
+function isWaitingOnOthers(crossChainState, cs) {
+  if (crossChainState.holdRealtime) {
+    return true;
+  } else {
+    return Object.values(crossChainState.chainStates).some(other => {
+      if (other !== cs) {
+        return !ChainState.hasCaughtUp(other);
+      } else {
+        return false;
+      }
+    });
+  }
+}
+
 function reportFinished(crossChainState) {
-  let waitingOnOthers = crossChainState.holdRealtime || crossChainState.chainIds.length > 1;
   Object.values(crossChainState.chainStates).forEach(cs => {
     let match = ChainState.takeFinished(cs);
     if (match !== undefined) {
@@ -203,7 +216,7 @@ function reportFinished(crossChainState) {
         });
       } else {
         return Logging.childInfo(ChainState.logger(cs), {
-          msg: waitingOnOthers ? "Finished backfill. Waiting for the other chains." : "Finished backfill.",
+          msg: isWaitingOnOthers(crossChainState, cs) ? "Finished backfill. Waiting for the other chains." : "Finished backfill.",
           block: match._0
         });
       }

package/src/EventConfigBuilder.res

@@ -343,7 +343,7 @@ let validateFieldsShapeOrThrow = (
 }
 
 let selectionList = (fields: unknown, key: string): option<array<string>> =>
-  switch (fields->(Utils.magic: unknown => dict<unknown>))->Dict.get(key) {
+  switch fields->(Utils.magic: unknown => dict<unknown>)->Dict.get(key) {
   | None => None
   | Some(value) => Some(value->(Utils.magic: unknown => array<string>))
   }
@@ -371,8 +371,8 @@ let parseFieldsOrThrow = (
     if !(valid->Utils.Set.has(name)) {
       JsError.throwWithMessage(
         `Invalid "${name}" field in the fields.${kind} option of ${registration}. Valid ${kind} fields: ${Utils.Array.quotedJoin(
-          valid->Utils.Set.toArray,
-        )}.`,
+            valid->Utils.Set.toArray,
+          )}.`,
       )
     }
     if seen->Utils.Set.has(name) {
@@ -858,13 +858,7 @@ let buildFuelEventConfig = (
   ~rawAbi: JSON.t,
 ): Internal.fuelEventConfig => {
   let fuelKind = switch kind {
-  | "logData" =>
-    // Transpile raw Fuel ABI to the format expected by the vendored ABI coder
-    let abi = FuelSDK.transpileAbi(rawAbi)
-    Internal.LogData({
-      logId: sighash,
-      decode: FuelSDK.Receipt.getLogDataDecoder(~abi, ~logId=sighash),
-    })
+  | "logData" => Internal.LogData({logId: sighash, abi: rawAbi})
   | "mint" => Mint
   | "burn" => Burn
   | "transfer" => Transfer

package/src/EventConfigBuilder.res.mjs

@@ -6,7 +6,6 @@ import * as Core from "./Core.res.mjs";
 import * as Fuel from "./sources/Fuel.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
-import * as FuelSDK from "./sources/FuelSDK.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as LogSelection from "./LogSelection.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -590,11 +589,10 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
       fuelKind = "Call";
       break;
     case "logData" :
-      let abi = FuelSDK.transpileAbi(rawAbi);
       fuelKind = {
         TAG: "LogData",
         logId: sighash,
-        decode: FuelSDK.Receipt.getLogDataDecoder(abi, sighash)
+        abi: rawAbi
       };
       break;
     case "mint" :

package/src/ExitOnCaughtUp.res

@@ -14,7 +14,11 @@ let run = async (state: IndexerState.t) => {
       | Some(onExit) => onExit()
       | None =>
         Logging.info("Exiting with success")
-        NodeJs.process->NodeJs.exitWithCode(Success)
+        if Worker.isEnabled {
+          Worker.exitAfterReporting(~metrics=state->IndexerState.toMetrics)
+        } else {
+          NodeJs.process->NodeJs.exitWithCode(Success)
+        }
       }
     | Some(message) => state->IndexerState.errorExit(ErrorHandling.make(Utils.Error.make(message)))
     }

package/src/ExitOnCaughtUp.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Worker from "./Worker.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as Process from "process";
@@ -24,12 +25,16 @@ async function run(state) {
     return onExit();
   } else {
     Logging.info("Exiting with success");
-    Process.exit(0);
-    return;
+    if (Worker.isEnabled) {
+      return Worker.exitAfterReporting(IndexerState.toMetrics(state));
+    } else {
+      Process.exit(0);
+      return;
+    }
   }
 }
 
 export {
   run,
 }
-/* Logging Not a pure module */
+/* Worker Not a pure module */

package/src/FinalizeBackfill.res

@@ -11,15 +11,25 @@
 // `envio start --chain` process is indexing and never waits on one.
 
 let runOnce = async (state: IndexerState.t) => {
+  let chainIds = state->IndexerState.crossChainState->CrossChainState.chainIds
+
+  // Whatever brought the process here — a batch, a tick that progressed
+  // nothing, a supervisor's release — its chains say where they finished
+  // before it says what it does about that. Said here rather than left to each
+  // caller to order: a chain that has already spoken says nothing again.
+  state->IndexerState.reportFinished
+
   // Said by the process rather than by each of its chains: the indexes are one
   // build over the tables, and the pause is the whole process's. A chain has
   // already said it caught up, and says it is ready once this commits. The
   // chains are named because the pause is theirs, and a split run has a process
-  // saying this for each part of it.
-  Logging.info({
-    "msg": "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.",
-    "chainIds": state->IndexerState.crossChainState->CrossChainState.chainIds,
-  })
+  // saying this for each part of it — one of them, for a process driving a
+  // single chain.
+  let msg = "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database."
+  switch chainIds {
+  | [chainId] => Logging.info({"msg": msg, "chainId": chainId})
+  | chainIds => Logging.info({"msg": msg, "chainIds": chainIds})
+  }
 
   await Writing.flush(state)
 
@@ -30,11 +40,7 @@ let runOnce = async (state: IndexerState.t) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
     let readyAt = Date.make()
 
-    await storage.finalizeBackfill(
-      ~entities=persistence.allEntities,
-      ~chainIds=state->IndexerState.crossChainState->CrossChainState.chainIds,
-      ~readyAt,
-    )
+    await storage.finalizeBackfill(~entities=persistence.allEntities, ~chainIds, ~readyAt)
 
     // Only after the commit: in-memory readiness must never run ahead of the
     // `ready_at` a restart would read back.

package/src/FinalizeBackfill.res.mjs

@@ -7,10 +7,21 @@ import * as IndexerState from "./IndexerState.res.mjs";
 import * as CrossChainState from "./CrossChainState.res.mjs";
 
 async function runOnce(state) {
-  Logging.info({
-    msg: "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.",
-    chainIds: CrossChainState.chainIds(IndexerState.crossChainState(state))
-  });
+  let chainIds = CrossChainState.chainIds(IndexerState.crossChainState(state));
+  IndexerState.reportFinished(state);
+  let msg = "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.";
+  if (chainIds.length !== 1) {
+    Logging.info({
+      msg: msg,
+      chainIds: chainIds
+    });
+  } else {
+    let chainId = chainIds[0];
+    Logging.info({
+      msg: msg,
+      chainId: chainId
+    });
+  }
   await Writing.flush(state);
   if (IndexerState.hasFailedWrite(state)) {
     return;
@@ -18,7 +29,7 @@ async function runOnce(state) {
   let persistence = IndexerState.persistence(state);
   let storage = Persistence.getInitializedStorageOrThrow(persistence);
   let readyAt = new Date();
-  await storage.finalizeBackfill(persistence.allEntities, CrossChainState.chainIds(IndexerState.crossChainState(state)), readyAt);
+  await storage.finalizeBackfill(persistence.allEntities, chainIds, readyAt);
   return IndexerState.markReady(state, readyAt);
 }