envio 3.13.0-rc.0 → 3.14.0-subgraph

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)),
@@ -450,7 +450,8 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   svm: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
   enums: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(S$RescriptSchema.array(S$RescriptSchema.string)))),
-  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema)))
+  entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema))),
+  subgraph: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
 }));
 
 function contractMappingOf(chainConfigs) {
@@ -495,6 +496,42 @@ 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));
+    Utils.Dict.deleteInPlace(envioInfo, "subgraph");
+    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 +838,10 @@ 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_subgraph = publicConfig.subgraph;
   let config = {
     name: config_name,
     description: config_description,
@@ -823,11 +863,14 @@ 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,
+    subgraph: config_subgraph
   };
   let chainIds = publicConfig.isolatedChains;
   if (chainIds !== undefined) {
@@ -933,44 +976,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 +1093,8 @@ function diffPaths(stored, current) {
       [
         "evm",
         "fuel",
-        "svm"
+        "svm",
+        "chains"
       ],
       ["entities"]
     ];
@@ -1113,10 +1119,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 +1131,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 +1185,10 @@ export {
   getChain,
   isPerChain,
   isolate,
+  commandFields,
+  withProjectFlags,
+  ecosystemFields,
+  toEnvioInfo,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
@@ -1202,12 +1196,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 = {
@@ -27,12 +28,25 @@ type fromUserApiResult = {
   indexerCode: Null.t<string>,
 }
 
+type fromSubgraphOptions = {
+  name?: string,
+  env?: dict<string>,
+  files?: dict<string>,
+  root?: string,
+}
+
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
+  fromSubgraph: (string, string, fromSubgraphOptions) => fromUserApiResult,
+  subgraphFileToJavascript: (string, string) => string,
   encodeIndexedTopic: (~abiType: string, ~value: unknown) => EvmTypes.Hex.t,
   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 +63,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 +115,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 +193,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 +244,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)
     }
@@ -265,6 +314,18 @@ let fromUserApi = (~schema=?, ~env=?, ~files=?, ~withIndexerTypes=false, yaml) =
   )
 }
 
+/// Parses a subgraph project without touching the filesystem: subgraph.yaml and
+/// its schema inline, ABI bodies through `files`.
+let fromSubgraph = (~name=?, ~env=?, ~files=?, ~root=?, ~manifest, ~schema) => {
+  let addon = getAddon()
+  addon.fromSubgraph(manifest, schema, {?name, ?env, ?files, ?root})
+}
+
+let subgraphFileToJavascript = (~source, ~path) => {
+  let addon = getAddon()
+  addon.subgraphFileToJavascript(source, path)
+}
+
 let runCli = args => {
   let addon = getAddon()
   addon.runCli(~args, ~envioPackageDir=Null.make(envioPackageDir))

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 = {
@@ -199,6 +232,21 @@ function fromUserApi(schema, env, files, withIndexerTypesOpt, yaml) {
   });
 }
 
+function fromSubgraph(name, env, files, root, manifest, schema) {
+  let addon = getAddon();
+  return addon.fromSubgraph(manifest, schema, {
+    name: name,
+    env: env,
+    files: files,
+    root: root
+  });
+}
+
+function subgraphFileToJavascript(source, path) {
+  let addon = getAddon();
+  return addon.subgraphFileToJavascript(source, path);
+}
+
 function runCli(args) {
   let addon = getAddon();
   return addon.runCli(args, envioPackageDir);
@@ -211,11 +259,17 @@ export {
   envioPackageDir,
   loadDevAddon,
   rethrow,
+  requirePackageJson,
+  devVersion,
+  isGlibc,
+  addCommand,
   loadAddon,
   addonRef,
   getAddon,
   getConfigJson,
   fromUserApi,
+  fromSubgraph,
+  subgraphFileToJavascript,
   runCli,
 }
 /* envioPackageDir Not a pure module */

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/EventProcessing.res

@@ -51,7 +51,7 @@ let runEventHandlerOrThrow = async (
       isPreload: false,
       chains,
       config,
-      isResolved: false,
+      sync: UserContext.makeSyncState(),
     }
     await handler(
       (
@@ -61,7 +61,7 @@ let runEventHandlerOrThrow = async (
         }: Internal.handlerArgs
       ),
     )
-    contextParams.isResolved = true
+    contextParams.sync.status = Resolved
   } catch {
   | exn =>
     throw(
@@ -102,7 +102,7 @@ let runHandlerOrThrow = async (
         isPreload: false,
         chains,
         config,
-        isResolved: false,
+        sync: UserContext.makeSyncState(),
       }
       await handler(
         Ecosystem.makeOnBlockArgs(
@@ -111,7 +111,7 @@ let runHandlerOrThrow = async (
           ~context=UserContext.getHandlerContext(contextParams),
         ),
       )
-      contextParams.isResolved = true
+      contextParams.sync.status = Resolved
     } catch {
     | exn =>
       throw(
@@ -186,7 +186,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  isResolved: false,
+                  sync: UserContext.makeSyncState(),
                   config,
                 }),
               })
@@ -221,7 +221,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  isResolved: false,
+                  sync: UserContext.makeSyncState(),
                   config,
                 }),
               )