envio 3.14.0 → 3.14.1

package/evm.schema.json

@@ -543,7 +543,7 @@
       "type": "object",
       "properties": {
         "url": {
-          "description": "The RPC endpoint URL.",
+          "description": "The RPC endpoint URL. An entry whose url is empty, for example `${RPC_URL:-}` with the variable unset, is ignored.",
           "type": "string"
         },
         "for": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.14.0",
+  "version": "3.14.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -54,10 +54,10 @@
     "postgres": "3.4.8"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.14.0",
-    "envio-linux-x64-musl": "3.14.0",
-    "envio-linux-arm64": "3.14.0",
-    "envio-darwin-x64": "3.14.0",
-    "envio-darwin-arm64": "3.14.0"
+    "envio-linux-x64": "3.14.1",
+    "envio-linux-x64-musl": "3.14.1",
+    "envio-linux-arm64": "3.14.1",
+    "envio-darwin-x64": "3.14.1",
+    "envio-darwin-arm64": "3.14.1"
   }
 }

package/src/HandlerLoader.res

@@ -77,15 +77,6 @@ let getAutoLoadFiles = async (~config: Config.t) => {
   }
 }
 
-type typeCheckResult = {
-  skipped?: string,
-  errors?: string,
-}
-
-@module("./HandlerTypeCheck.mjs")
-external checkTypesInWorker: (~cwd: string, ~files: array<string>) => promise<typeCheckResult> =
-  "check"
-
 let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
   // A contract's `handler:` may also be an auto-loaded file.
   let files =
@@ -96,10 +87,13 @@ let typeCheck = async (~config: Config.t, ~autoLoadFiles) => {
     ->Utils.Set.fromArray
     ->Utils.Set.toArray
   if files->Array.length > 0 {
-    switch await checkTypesInWorker(~cwd=NodeJs.Process.cwd(), ~files) {
-    | {errors} => JsError.throwWithMessage(`Handler files have type errors:\n\n${errors}`)
-    | {skipped} => Logging.warn(skipped)
-    | _ => ()
+    switch await HandlerTypeCheck.check(~cwd=NodeJs.Process.cwd(), ~files) {
+    | TypeErrors(errors) =>
+      JsError.throwWithMessage(
+        `The handler type check found errors. Fix them to start the indexer:\n\n${errors}`,
+      )
+    | Skipped(warning) => Logging.warn(warning)
+    | Passed => ()
     }
   }
 }

package/src/HandlerLoader.res.mjs

@@ -10,10 +10,10 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
+import * as HandlerTypeCheck from "./HandlerTypeCheck.res.mjs";
 import * as Promises from "node:fs/promises";
 import * as TsModuleHooksMjs from "./TsModuleHooks.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as HandlerTypeCheckMjs from "./HandlerTypeCheck.mjs";
 
 function registerTsHooksWith(prim) {
   TsModuleHooksMjs.register(prim);
@@ -70,24 +70,18 @@ async function getAutoLoadFiles(config) {
   }
 }
 
-function checkTypesInWorker(prim0, prim1) {
-  return HandlerTypeCheckMjs.check(prim0, prim1);
-}
-
 async function typeCheck(config, autoLoadFiles) {
   let files = Array.from(new Set(autoLoadFiles.concat(Stdlib_Array.filterMap(config.contractHandlers, param => param.handler)).filter(isTypeScript).map(toAbsolutePath)));
   if (files.length === 0) {
     return;
   }
-  let match = await HandlerTypeCheckMjs.check(Process.cwd(), files);
-  let skipped = match.skipped;
-  let errors = match.errors;
-  if (errors !== undefined) {
-    return Stdlib_JsError.throwWithMessage(`Handler files have type errors:\n\n` + errors);
-  } else if (skipped !== undefined) {
-    return Logging.warn(skipped);
-  } else {
+  let errors = await HandlerTypeCheck.check(Process.cwd(), files);
+  if (typeof errors !== "object") {
     return;
+  } else if (errors.TAG === "TypeErrors") {
+    return Stdlib_JsError.throwWithMessage(`The handler type check found errors. Fix them to start the indexer:\n\n` + errors._0);
+  } else {
+    return Logging.warn(errors._0);
   }
 }
 
@@ -111,7 +105,6 @@ export {
   importHandler,
   registerContractHandlers,
   getAutoLoadFiles,
-  checkTypesInWorker,
   typeCheck,
   registerAllHandlers,
 }

package/src/HandlerTypeCheck.res

@@ -0,0 +1,207 @@
+type result =
+  | Passed
+  | TypeErrors(string)
+  | Skipped(string)
+
+let timeoutSeconds = 30
+
+// tsc's pretty output reads the same from TypeScript 5 to 7: a diagnostic
+// starts unindented with its location, its code frame and related locations
+// follow indented, and `--listFiles` prints the program's files after the
+// last one, before the closing summary.
+let fileDiagnostic = /^(.+):\d+:\d+ - error TS(\d+): /
+let globalDiagnostic = /^error TS(\d+): /
+let summary = /^Found \d+ errors?\b/
+let thrownError = /^\w*Error: /
+
+let lines = output => output->String.replaceAll("\r\n", "\n")->String.split("\n")
+
+let rec findUp = (directory, name) => {
+  let candidate = NodeJs.Path.resolve([directory, name])->NodeJs.Path.toString
+  if NodeJs.Fs.existsSync(candidate) {
+    Some(candidate)
+  } else {
+    let parent = NodeJs.Path.dirname(directory)->NodeJs.Path.toString
+    parent === directory ? None : findUp(parent, name)
+  }
+}
+
+// The `tsc` the project's own scripts run. TypeScript 7 has no JavaScript API
+// to call instead, only this command.
+let resolveTsc = (~cwd) =>
+  try {
+    let manifest =
+      NodeJs.Module.createRequire(
+        NodeJs.Path.resolve([cwd, "package.json"])->NodeJs.Path.toString,
+      )->NodeJs.Module.resolve("typescript/package.json")
+    let bin = switch NodeJs.Fs.readFileSync(manifest)->JSON.parseOrThrow {
+    | JSON.Object(fields) =>
+      switch fields->Dict.get("bin") {
+      | Some(JSON.String(bin)) => Some(bin)
+      | Some(JSON.Object(bins)) =>
+        switch bins->Dict.get("tsc") {
+        | Some(JSON.String(bin)) => Some(bin)
+        | _ => None
+        }
+      | _ => None
+      }
+    | _ => None
+    }
+    bin->Option.map(bin =>
+      NodeJs.Path.resolve([
+        NodeJs.Path.dirname(manifest)->NodeJs.Path.toString,
+        bin,
+      ])->NodeJs.Path.toString
+    )
+  } catch {
+  | _ => None
+  }
+
+type run = {error: option<NodeJs.ChildProcess.execFileError>, output: string}
+
+let runTsc = (~tsc, ~cwd, args) =>
+  Promise.make((resolve, _) =>
+    NodeJs.ChildProcess.execFile(
+      NodeJs.Process.process->NodeJs.Process.execPath,
+      [tsc]->Array.concat(args),
+      {cwd, timeout: timeoutSeconds * 1000, maxBuffer: Float.Constants.positiveInfinity},
+      (error, stdout, stderr) =>
+        resolve({
+          error: error->Null.toOption,
+          output: NodeJs.Util.stripVTControlCharacters(stdout ++ stderr),
+        }),
+    )
+  )
+
+type diagnostic = {file: option<string>, code: int, lines: array<string>}
+
+// tsc type-checks nothing after a syntax error, an options error or a global
+// error, and an options error is reported at its line in tsconfig.json.
+let canStopTypeChecking = ({file, code}) =>
+  file->Option.isNone || code < 2000 || (code >= 5000 && code < 7000)
+
+// Paths compare relative to the project, which on Windows also ignores the
+// case of a drive letter tsc may print differently.
+let parse = (output, ~cwd) => {
+  let relative = file =>
+    NodeJs.Path.relative(cwd, NodeJs.Path.resolve([cwd, file])->NodeJs.Path.toString)
+  let diagnostics = []
+  let programFiles = Utils.Set.make()
+  let current = ref(None)
+  let start = (~file, ~code, line) => {
+    let diagnostic = {
+      file,
+      code: code->Int.fromString->Option.getOr(0),
+      lines: [line],
+    }
+    diagnostics->Array.push(diagnostic)
+    current := Some(diagnostic)
+  }
+  output
+  ->lines
+  ->Array.forEach(line =>
+    switch (
+      fileDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+      globalDiagnostic->RegExp.exec(line)->Option.map(RegExp.Result.matches),
+    ) {
+    | (Some([Some(file), Some(code)]), _) => start(~file=Some(relative(file)), ~code, line)
+    | (_, Some([Some(code)])) => start(~file=None, ~code, line)
+    | _ if NodeJs.Path.isAbsolute(line) =>
+      programFiles->Utils.Set.add(relative(line))->ignore
+      current := None
+    | _ if summary->RegExp.test(line) => current := None
+    | _ => current.contents->Option.forEach(diagnostic => diagnostic.lines->Array.push(line))
+    }
+  )
+  (diagnostics, programFiles)
+}
+
+// Exit codes say nothing here: TypeScript 5 and 6 exit with 2 on type errors,
+// 7 with 1, and 1 is also how its launcher fails when the native compiler
+// isn't installed.
+let failure = ({error, output}) =>
+  switch error {
+  | Some({killed: true}) =>
+    `Skipped the handler type check: tsc didn't finish within ${timeoutSeconds->Int.toString} seconds.`
+  | _ =>
+    let reason =
+      output
+      ->lines
+      ->Array.find(line => thrownError->RegExp.test(line))
+      ->Option.getOr(output->String.trim)
+    `Skipped the handler type check: tsc failed to run:\n\n${reason}`
+  }
+
+let check = async (~cwd, ~files) => {
+  // The ReScript compiler checks a ReScript project's handlers, so it has no
+  // reason to set up TypeScript, and the warning would only be noise there.
+  // `rescript.json` at the root is what makes codegen treat it as ReScript.
+  let skip = warning =>
+    NodeJs.Fs.existsSync(NodeJs.Path.resolve([cwd, "rescript.json"])->NodeJs.Path.toString)
+      ? Passed
+      : Skipped(warning)
+
+  switch (resolveTsc(~cwd), findUp(cwd, "tsconfig.json")) {
+  | (None, _) =>
+    skip(
+      "Skipped the handler type check: typescript isn't installed. Add it to devDependencies to type-check handlers on start.",
+    )
+  | (_, None) =>
+    skip(
+      "Skipped the handler type check: no tsconfig.json found. Add one, like the one envio init creates, to type-check handlers on start.",
+    )
+  | (Some(tsc), Some(tsconfig)) =>
+    // The project's own `tsc --noEmit`, minus the build info it would write.
+    // `explainFiles` would replace the listed files' absolute paths with
+    // relative ones and the reasons each is included.
+    let run = await runTsc(
+      ~tsc,
+      ~cwd,
+      [
+        "--project",
+        tsconfig,
+        "--noEmit",
+        "--incremental",
+        "false",
+        "--composite",
+        "false",
+        "--listFiles",
+        "--explainFiles",
+        "false",
+        "--pretty",
+      ],
+    )
+    let (diagnostics, programFiles) = run.output->parse(~cwd)
+    let report = diagnostics =>
+      diagnostics
+      ->Array.map(({lines}) => lines->Array.join("\n")->String.trimEnd)
+      ->Array.join("\n\n")
+    let handlers = files->Array.map(file => NodeJs.Path.relative(cwd, file))
+    let isHandler = ({file}) => file->Option.mapOr(false, file => handlers->Array.includes(file))
+    let errors = diagnostics->Array.filter(isHandler)
+    let stopping =
+      diagnostics->Array.filter(diagnostic =>
+        !isHandler(diagnostic) && canStopTypeChecking(diagnostic)
+      )
+    let unchecked = handlers->Array.filter(file => !(programFiles->Utils.Set.has(file)))
+    if run.error->Option.isSome && diagnostics->Array.length === 0 {
+      Skipped(failure(run))
+    } else if errors->Array.length > 0 {
+      TypeErrors(report(errors))
+    } else if stopping->Array.length > 0 {
+      let reason = report(stopping)
+      Skipped(
+        `Skipped the handler type check: tsc can't check the handlers until these errors are fixed:\n\n${reason}`,
+      )
+    } else if unchecked->Array.length > 0 {
+      let names = unchecked->Array.join(", ")
+      let tsconfig = NodeJs.Path.relative(cwd, tsconfig)
+      let pronoun = unchecked->Array.length === 1 ? "it" : "them"
+      Skipped(
+        `Skipped the handler type check: ${tsconfig} doesn't include ${names}. Add ${pronoun} to "include" to type-check ${pronoun} on start.`,
+      )
+    } else {
+      Passed
+    }
+  }
+}

package/src/HandlerTypeCheck.res.mjs

@@ -0,0 +1,262 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Path from "path";
+import * as Util from "util";
+import * as Module from "module";
+import * as Process from "process";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Child_process from "child_process";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let fileDiagnostic = /^(.+):\d+:\d+ - error TS(\d+): /;
+
+let globalDiagnostic = /^error TS(\d+): /;
+
+let summary = /^Found \d+ errors?\b/;
+
+let thrownError = /^\w*Error: /;
+
+function lines(output) {
+  return output.replaceAll("\r\n", "\n").split("\n");
+}
+
+function findUp(_directory, name) {
+  while (true) {
+    let directory = _directory;
+    let candidate = Path.resolve(directory, name);
+    if (Fs.existsSync(candidate)) {
+      return candidate;
+    }
+    let parent = Path.dirname(directory);
+    if (parent === directory) {
+      return;
+    }
+    _directory = parent;
+    continue;
+  };
+}
+
+function resolveTsc(cwd) {
+  try {
+    let manifest = Module.createRequire(Path.resolve(cwd, "package.json")).resolve("typescript/package.json");
+    let fields = JSON.parse(Fs.readFileSync(manifest, "utf8"));
+    let bin;
+    if (typeof fields === "object" && fields !== null && !Array.isArray(fields)) {
+      let match = fields["bin"];
+      if (match !== undefined && !(match === null || Array.isArray(match))) {
+        switch (typeof match) {
+          case "string" :
+            bin = match;
+            break;
+          case "object" :
+            let match$1 = match["tsc"];
+            bin = typeof match$1 === "string" ? match$1 : undefined;
+            break;
+          default:
+            bin = undefined;
+        }
+      } else {
+        bin = undefined;
+      }
+    } else {
+      bin = undefined;
+    }
+    return Stdlib_Option.map(bin, bin => Path.resolve(Path.dirname(manifest), bin));
+  } catch (exn) {
+    return;
+  }
+}
+
+function runTsc(tsc, cwd, args) {
+  return new Promise((resolve, param) => {
+    Child_process.execFile(Process.execPath, [tsc].concat(args), {
+      cwd: cwd,
+      timeout: 30000,
+      maxBuffer: Number.POSITIVE_INFINITY
+    }, (error, stdout, stderr) => resolve({
+      error: error === null ? undefined : Primitive_option.some(error),
+      output: Util.stripVTControlCharacters(stdout + stderr)
+    }));
+  });
+}
+
+function canStopTypeChecking(param) {
+  let code = param.code;
+  if (Stdlib_Option.isNone(param.file) || code < 2000) {
+    return true;
+  } else if (code >= 5000) {
+    return code < 7000;
+  } else {
+    return false;
+  }
+}
+
+function parse(output, cwd) {
+  let relative = file => Path.relative(cwd, Path.resolve(cwd, file));
+  let diagnostics = [];
+  let programFiles = new Set();
+  let current = {
+    contents: undefined
+  };
+  let start = (file, code, line) => {
+    let diagnostic_code = Stdlib_Option.getOr(Stdlib_Int.fromString(code, undefined), 0);
+    let diagnostic_lines = [line];
+    let diagnostic = {
+      file: file,
+      code: diagnostic_code,
+      lines: diagnostic_lines
+    };
+    diagnostics.push(diagnostic);
+    current.contents = diagnostic;
+  };
+  lines(output).forEach(line => {
+    let match = Stdlib_Option.map(Primitive_option.fromNullable(fileDiagnostic.exec(line)), prim => prim.slice(1));
+    let match$1 = Stdlib_Option.map(Primitive_option.fromNullable(globalDiagnostic.exec(line)), prim => prim.slice(1));
+    let exit = 0;
+    if (match !== undefined && match.length === 2) {
+      let file = match[0];
+      if (file !== undefined) {
+        let code = match[1];
+        if (code !== undefined) {
+          return start(relative(file), code, line);
+        }
+        exit = 2;
+      } else {
+        exit = 2;
+      }
+    } else {
+      exit = 2;
+    }
+    if (exit === 2 && match$1 !== undefined && match$1.length === 1) {
+      let code$1 = match$1[0];
+      if (code$1 !== undefined) {
+        return start(undefined, code$1, line);
+      }
+    }
+    if (Path.isAbsolute(line)) {
+      programFiles.add(relative(line));
+      current.contents = undefined;
+      return;
+    } else if (summary.test(line)) {
+      current.contents = undefined;
+      return;
+    } else {
+      return Stdlib_Option.forEach(current.contents, diagnostic => {
+        diagnostic.lines.push(line);
+      });
+    }
+  });
+  return [
+    diagnostics,
+    programFiles
+  ];
+}
+
+function failure(param) {
+  let output = param.output;
+  let error = param.error;
+  if (error !== undefined && error.killed) {
+    return `Skipped the handler type check: tsc didn't finish within ` + (30).toString() + ` seconds.`;
+  }
+  let reason = Stdlib_Option.getOr(lines(output).find(line => thrownError.test(line)), output.trim());
+  return `Skipped the handler type check: tsc failed to run:\n\n` + reason;
+}
+
+async function check(cwd, files) {
+  let skip = warning => {
+    if (Fs.existsSync(Path.resolve(cwd, "rescript.json"))) {
+      return "Passed";
+    } else {
+      return {
+        TAG: "Skipped",
+        _0: warning
+      };
+    }
+  };
+  let match = resolveTsc(cwd);
+  let match$1 = findUp(cwd, "tsconfig.json");
+  if (match === undefined) {
+    return skip("Skipped the handler type check: typescript isn't installed. Add it to devDependencies to type-check handlers on start.");
+  }
+  if (match$1 === undefined) {
+    return skip("Skipped the handler type check: no tsconfig.json found. Add one, like the one envio init creates, to type-check handlers on start.");
+  }
+  let run = await runTsc(match, cwd, [
+    "--project",
+    match$1,
+    "--noEmit",
+    "--incremental",
+    "false",
+    "--composite",
+    "false",
+    "--listFiles",
+    "--explainFiles",
+    "false",
+    "--pretty"
+  ]);
+  let match$2 = parse(run.output, cwd);
+  let programFiles = match$2[1];
+  let diagnostics = match$2[0];
+  let report = diagnostics => diagnostics.map(param => param.lines.join("\n").trimEnd()).join("\n\n");
+  let handlers = files.map(file => Path.relative(cwd, file));
+  let isHandler = param => Stdlib_Option.mapOr(param.file, false, file => handlers.includes(file));
+  let errors = diagnostics.filter(isHandler);
+  let stopping = diagnostics.filter(diagnostic => {
+    if (isHandler(diagnostic)) {
+      return false;
+    } else {
+      return canStopTypeChecking(diagnostic);
+    }
+  });
+  let unchecked = handlers.filter(file => !programFiles.has(file));
+  if (Stdlib_Option.isSome(run.error) && diagnostics.length === 0) {
+    return {
+      TAG: "Skipped",
+      _0: failure(run)
+    };
+  }
+  if (errors.length !== 0) {
+    return {
+      TAG: "TypeErrors",
+      _0: report(errors)
+    };
+  }
+  if (stopping.length !== 0) {
+    let reason = report(stopping);
+    return {
+      TAG: "Skipped",
+      _0: `Skipped the handler type check: tsc can't check the handlers until these errors are fixed:\n\n` + reason
+    };
+  }
+  if (unchecked.length === 0) {
+    return "Passed";
+  }
+  let names = unchecked.join(", ");
+  let tsconfig = Path.relative(cwd, match$1);
+  let pronoun = unchecked.length === 1 ? "it" : "them";
+  return {
+    TAG: "Skipped",
+    _0: `Skipped the handler type check: ` + tsconfig + ` doesn't include ` + names + `. Add ` + pronoun + ` to "include" to type-check ` + pronoun + ` on start.`
+  };
+}
+
+let timeoutSeconds = 30;
+
+export {
+  timeoutSeconds,
+  fileDiagnostic,
+  globalDiagnostic,
+  summary,
+  thrownError,
+  lines,
+  findUp,
+  resolveTsc,
+  runTsc,
+  canStopTypeChecking,
+  parse,
+  failure,
+  check,
+}
+/* fs Not a pure module */

package/src/bindings/NodeJs.res

@@ -39,6 +39,15 @@ module Util = {
   @module("util") external inspect: ('a, inspectOptions) => string = "inspect"
 
   let inspectObj = a => inspect(a, {showHidden: false, depth: Null, colors: true})
+
+  @module("util") external stripVTControlCharacters: string => string = "stripVTControlCharacters"
+}
+
+module Module = {
+  type require
+
+  @module("module") external createRequire: string => require = "createRequire"
+  @send external resolve: (require, string) => string = "resolve"
 }
 
 module Process = {
@@ -165,6 +174,23 @@ module ChildProcess = {
   @module("child_process")
   external execWithOptions: (string, execOptions, callback) => unit = "exec"
 
+  type execFileOptions = {
+    cwd?: string,
+    timeout?: int,
+    maxBuffer?: float,
+  }
+
+  // `killed` is set when the timeout stopped the child.
+  type execFileError = {killed: bool}
+
+  @module("child_process")
+  external execFile: (
+    string,
+    array<string>,
+    execFileOptions,
+    (Null.t<execFileError>, string, string) => unit,
+  ) => unit = "execFile"
+
   // One of a child's stdio slots, present only for a slot the parent asked to
   // pipe rather than inherit.
   module Stream = {
@@ -225,6 +251,8 @@ module Path = {
 
   @module("path") external join: (t, string) => t = "join"
   @module("path") external dirname: string => t = "dirname"
+  @module("path") external relative: (string, string) => string = "relative"
+  @module("path") external isAbsolute: string => bool = "isAbsolute"
 
   external toString: t => string = "%identity"
 
@@ -275,6 +303,9 @@ module Fs = {
     mode?: int,
   }
 
+  @module("fs") external existsSync: string => bool = "existsSync"
+  @module("fs") external readFileSync: (string, @as("utf8") _) => string = "readFileSync"
+
   module Promises = {
     @module("fs") @scope("promises")
     external writeFile: (

package/src/bindings/NodeJs.res.mjs

@@ -16,6 +16,8 @@ let Util$1 = {
   inspectObj: inspectObj
 };
 
+let Module = {};
+
 let Process = {};
 
 let empty = globalThis.Buffer.alloc(0);
@@ -59,6 +61,7 @@ let Fs = {
 
 export {
   Util$1 as Util,
+  Module,
   Process,
   Buffer,
   V8,

package/src/sources/EvmRpcClient.res

@@ -28,6 +28,7 @@ type pageOutcome =
   | @as("SuggestedToBlock") SuggestedToBlock
   | @as("Backoff") Backoff
   | @as("FieldSelection") FieldSelection
+  | @as("BehindHead") BehindHead
 
 type nextPageResult = {
   kind: pageOutcome,
@@ -45,6 +46,7 @@ type nextPageResult = {
 // alongside it is empty.
 type blockHashResult = {
   message: option<string>,
+  behindHeadBlock: option<int>,
   requestStats: array<Source.requestStat>,
 }
 

package/src/sources/RpcSource.res

@@ -99,7 +99,8 @@ let make = (
 
     // The cause travels as a real error so it reaches the logs the way every
     // other source's does. Absent where the message is the whole story.
-    let exn = result.providerMessage->Option.map(message => JsError.make(message)->JsExn.anyToExnInternal)
+    let exn =
+      result.providerMessage->Option.map(message => JsError.make(message)->JsExn.anyToExnInternal)
 
     let failedGettingItems = (decision): exn => Source.GetItemsError(
       FailedGettingItems({
@@ -134,6 +135,16 @@ let make = (
           }),
         ),
       )
+    | BehindHead =>
+      throw(
+        Source.SourceBehindHead({
+          blockNumber: switch result.blockNumber {
+          | Some(blockNumber) => blockNumber
+          | None => missing("blockNumber")
+          },
+          requestStats: result.requestStats,
+        }),
+      )
     | SuggestedToBlock =>
       throw(
         failedGettingItems(
@@ -185,9 +196,11 @@ let make = (
   let getBlockHashes = async (~blockNumbers, ~logger as _) => {
     let (result, pageBlockStore) = await rpcClient.getBlockHashes(blockNumbers)
     {
-      Source.result: switch result.message {
-      | None => Ok(pageBlockStore)
-      | Some(message) => Error(JsError.make(message)->JsExn.anyToExnInternal)
+      Source.result: switch (result.message, result.behindHeadBlock) {
+      | (None, _) => Ok(pageBlockStore)
+      | (Some(_), Some(blockNumber)) =>
+        Error(Source.SourceBehindHead({blockNumber, requestStats: result.requestStats}))
+      | (Some(message), None) => Error(JsError.make(message)->JsExn.anyToExnInternal)
       },
       requestStats: result.requestStats,
     }

package/src/sources/RpcSource.res.mjs

@@ -93,6 +93,14 @@ function make(param) {
           },
           Error: new Error()
         };
+      case "BehindHead" :
+        let blockNumber$1 = result.blockNumber;
+        throw {
+          RE_EXN_ID: Source.SourceBehindHead,
+          blockNumber: blockNumber$1 !== undefined ? blockNumber$1 : missing("blockNumber"),
+          requestStats: result.requestStats,
+          Error: new Error()
+        };
     }
     let parsingTimeRef = Performance.now();
     let parsedQueueItems = EvmEventItem.toInternalItems(result.items, onEventRegistrations, chainId);
@@ -114,12 +122,22 @@ function make(param) {
   let getBlockHashes = async (blockNumbers, param) => {
     let match = await rpcClient.getBlockHashes(blockNumbers);
     let result = match[0];
-    let message = result.message;
+    let match$1 = result.message;
+    let match$2 = result.behindHeadBlock;
     return {
-      result: message !== undefined ? ({
-          TAG: "Error",
-          _0: Primitive_exceptions.internalToException(new Error(message))
-        }) : ({
+      result: match$1 !== undefined ? (
+          match$2 !== undefined ? ({
+              TAG: "Error",
+              _0: {
+                RE_EXN_ID: Source.SourceBehindHead,
+                blockNumber: match$2,
+                requestStats: result.requestStats
+              }
+            }) : ({
+              TAG: "Error",
+              _0: Primitive_exceptions.internalToException(new Error(match$1))
+            })
+        ) : ({
           TAG: "Ok",
           _0: match[1]
         }),

package/src/sources/SourceManager.res

@@ -24,7 +24,7 @@ let recordStatsInto = (
   aggregates: dict<requestStatAgg>,
   requestStats: array<Source.requestStat>,
 ) => {
-  requestStats->Array.forEach(({method, seconds, responseBlocks: ?responseBlocks}) => {
+  requestStats->Array.forEach(({method, seconds, ?responseBlocks}) => {
     let agg = switch aggregates->Utils.Dict.dangerouslyGetNonOption(method) {
     | Some(agg) => agg
     | None =>
@@ -577,11 +577,14 @@ let backoffBeforeRetry = async (
   ~isRealtime,
   ~backoffMillis,
   ~minBackoffMillis=0,
+  ~failoverAfterRetries=2,
   ~excludedSources=?,
 ) => {
-  // Give the source two attempts before demoting it, then re-try a failover
+  // Give the source a few attempts before demoting it, then re-try a failover
   // every second attempt.
-  let switchedToWorkingSource = if retry >= 2 && retry->mod(2) === 0 {
+  let switchedToWorkingSource = if (
+    retry >= failoverAfterRetries && (retry - failoverAfterRetries)->mod(2) === 0
+  ) {
     let now = Date.now()
     sourceState.lastFailedAt = Some(now)
     switch sourceManager->getNextSource(~isRealtime, ~excludedSources?) {
@@ -608,6 +611,25 @@ let backoffBeforeRetry = async (
   }
 }
 
+// A replica behind its siblings usually catches up within seconds, and failing
+// over demotes an otherwise healthy source for the whole recovery timeout. So
+// the source keeps the query for about 10s (100ms doubling, capped at 1s per
+// attempt) before a failover is tried. Past that window the source is behind
+// for real, and with nowhere to fail over to it is polled less and less often,
+// doubling from 1s up to the shared cap.
+let behindHeadFailoverRetries = 12
+
+let behindHeadBackoffMillis = retry =>
+  if retry < behindHeadFailoverRetries {
+    Utils.expBackoff(~base=100, ~exp=retry, ~maxMillis=1_000)
+  } else {
+    Utils.expBackoff(
+      ~base=1_000,
+      ~exp=retry - behindHeadFailoverRetries,
+      ~maxMillis=maxRetryBackoffMillis,
+    )
+  }
+
 // The queried block hasn't reached the backend instance that served the
 // request. Expected around the head of a load-balanced backend, so early
 // attempts stay quiet and short; a source that stays behind fails over like any
@@ -619,18 +641,28 @@ let retryBehindHead = async (
   ~isRealtime,
   ~logger: Pino.t,
   ~blockNumber: int,
-  ~method: string,
-  ~err: exn,
   ~excludedSources=?,
 ) => {
-  let backoffMillis = retry->retryBackoffMillis
-  let log = retry >= 4 ? Logging.childWarn : Logging.childTrace
+  let backoffMillis = retry->behindHeadBackoffMillis
+  let source = sourceState.source.name
+  let block = blockNumber->Int.toString
+  // The condition is routine and resolves without the user doing anything, so
+  // the wording says so; the error object would only add internals.
+  let (log, msg) = if retry < behindHeadFailoverRetries {
+    (
+      Logging.childTrace,
+      `${source} hasn't reached block ${block} on all of its servers yet. This is normal near the latest block and resolves by itself - retrying shortly.`,
+    )
+  } else {
+    (
+      Logging.childWarn,
+      `${source} is still catching up to block ${block}. This is a delay on the provider's side; indexing will continue automatically, using another data source if one is configured.`,
+    )
+  }
   logger->log({
-    "msg": `Block #${blockNumber->Int.toString} is not available on the ${sourceState.source.name} source yet. Instances of a load-balanced backend drift slightly around the head, so this is expected - indexing continues after an automatic retry.`,
-    "method": method,
+    "msg": msg,
     "retry": retry,
     "backOffMilliseconds": backoffMillis,
-    "err": err->Utils.prettifyExn,
   })
   await sourceManager->backoffBeforeRetry(
     sourceState,
@@ -638,6 +670,7 @@ let retryBehindHead = async (
     ~isRealtime,
     ~backoffMillis,
     ~minBackoffMillis=minRecoverableBackoffMillis,
+    ~failoverAfterRetries=behindHeadFailoverRetries,
     ~excludedSources?,
   )
 }
@@ -861,8 +894,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
       // Re-armed because distrusting a stream is a one-shot — the next height it
       // delivers takes it back at its word — and the silence that earned it can
       // come straight back.
-      let rec armPokeTimeout = () =>
-        pokeTimeoutId := Some(setTimeout(() => {
+      let rec armPokeTimeout = () => pokeTimeoutId := Some(setTimeout(() => {
               pokeTimeoutId := None
               if !settled.contents {
                 watched->Array.forEach(subscription => subscription.distrustStream())
@@ -879,8 +911,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
       // operator about when they hear about a quiet chain, and spreading that
       // would report it early. Fires once — the warning is worth saying once per
       // wait, and a fallback stays recruited.
-      let armStallTimeout = () =>
-        stallTimeoutId := Some(setTimeout(() => {
+      let armStallTimeout = () => stallTimeoutId := Some(setTimeout(() => {
               stallTimeoutId := None
               if !settled.contents {
                 stalled := true
@@ -917,9 +948,7 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
                 }
 
                 // Recruited to poll, not to stream: see `watch`.
-                fallbackSources->Array.forEach(
-                  sourceState => sourceState->watch(~withStream=false),
-                )
+                fallbackSources->Array.forEach(sourceState => sourceState->watch(~withStream=false))
 
                 // A fallback recruited here can still be holding a stream from an
                 // earlier wait that made it a primary, and a live stream is not
@@ -940,7 +969,6 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
   })
 }
 
-
 let executeQuery = async (
   sourceManager: t,
   ~query: FetchState.query,
@@ -949,11 +977,12 @@ let executeQuery = async (
 ) => {
   // Read when the manager actually runs out of sources, not on the way in: the
   // reason is recorded by the failure that disabled the last one.
-  let noSourcesError = () => switch sourceManager.disableReason {
-  | Some(reason) =>
-    `The indexer doesn't have data-sources which can continue fetching. The last one was disabled because ${reason}`
-  | None => "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team."
-  }
+  let noSourcesError = () =>
+    switch sourceManager.disableReason {
+    | Some(reason) =>
+      `The indexer doesn't have data-sources which can continue fetching. The last one was disabled because ${reason}`
+    | None => "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team."
+    }
 
   // Sources where the query is impossible - lazily allocated, excluded for the duration of this query
   let excludedSourcesRef = ref(None)
@@ -1030,7 +1059,7 @@ let executeQuery = async (
       await sourceManager->waitForRateLimitReset(~resetMs, ~retry, ~logger)
       retryRef := retryRef.contents + 1
 
-    | Source.SourceBehindHead({blockNumber, requestStats}) as err =>
+    | Source.SourceBehindHead({blockNumber, requestStats}) =>
       sourceState->recordRequestStats(requestStats)
       await sourceManager->retryBehindHead(
         sourceState,
@@ -1038,8 +1067,6 @@ let executeQuery = async (
         ~isRealtime,
         ~logger,
         ~blockNumber,
-        ~method="getItems",
-        ~err,
         ~excludedSources=?excludedSourcesRef.contents,
       )
       retryRef := retryRef.contents + 1
@@ -1135,7 +1162,11 @@ let executeQuery = async (
         })
         retryRef := 0
 
-      | FailedGettingItems({?exn, attemptedToBlock, retry: WithBackoff({message, backoffMillis})}) =>
+      | FailedGettingItems({
+          ?exn,
+          attemptedToBlock,
+          retry: WithBackoff({message, backoffMillis}),
+        }) =>
         await sourceManager->retryFailedPage(
           sourceState,
           ~retry,
@@ -1200,22 +1231,14 @@ let getBlockHashes = async (sourceManager: t, ~blockNumbers: array<int>, ~isReal
       | Error(exn) => throw(exn)
       }
     } catch {
-    | Source.RateLimited({resetMs, requestStats}) =>
-      sourceState->recordRequestStats(requestStats)
+    // A failure arrives as `res.result`, whose `res.requestStats` is already
+    // recorded above, so the stats the error carries are not recorded again.
+    | Source.RateLimited({resetMs}) =>
       await sourceManager->waitForRateLimitReset(~resetMs, ~retry, ~logger)
       retryRef := retryRef.contents + 1
 
-    | Source.SourceBehindHead({blockNumber, requestStats}) as err =>
-      sourceState->recordRequestStats(requestStats)
-      await sourceManager->retryBehindHead(
-        sourceState,
-        ~retry,
-        ~isRealtime,
-        ~logger,
-        ~blockNumber,
-        ~method="getBlockHashes",
-        ~err,
-      )
+    | Source.SourceBehindHead({blockNumber}) =>
+      await sourceManager->retryBehindHead(sourceState, ~retry, ~isRealtime, ~logger, ~blockNumber)
       retryRef := retryRef.contents + 1
 
     | Source.InconsistentResponse(_) as err =>

package/src/sources/SourceManager.res.mjs

@@ -470,10 +470,11 @@ function getNextSource(sourceManager, isRealtime, excludedSources) {
   }
 }
 
-async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, excludedSources) {
+async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, failoverAfterRetriesOpt, excludedSources) {
   let minBackoffMillis = minBackoffMillisOpt !== undefined ? minBackoffMillisOpt : 0;
+  let failoverAfterRetries = failoverAfterRetriesOpt !== undefined ? failoverAfterRetriesOpt : 2;
   let switchedToWorkingSource;
-  if (retry >= 2 && retry % 2 === 0) {
+  if (retry >= failoverAfterRetries && (retry - failoverAfterRetries | 0) % 2 === 0) {
     let now = Date.now();
     sourceState.lastFailedAt = now;
     let next = getNextSource(sourceManager, isRealtime, excludedSources);
@@ -497,17 +498,31 @@ async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime,
   }
 }
 
-async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger, blockNumber, method, err, excludedSources) {
-  let backoffMillis = Utils.expBackoff(100, retry, 60000);
-  let log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
-  log(logger, {
-    msg: `Block #` + blockNumber.toString() + ` is not available on the ` + sourceState.source.name + ` source yet. Instances of a load-balanced backend drift slightly around the head, so this is expected - indexing continues after an automatic retry.`,
-    method: method,
+function behindHeadBackoffMillis(retry) {
+  if (retry < 12) {
+    return Utils.expBackoff(100, retry, 1000);
+  } else {
+    return Utils.expBackoff(1000, retry - 12 | 0, 60000);
+  }
+}
+
+async function retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger, blockNumber, excludedSources) {
+  let backoffMillis = behindHeadBackoffMillis(retry);
+  let source = sourceState.source.name;
+  let block = blockNumber.toString();
+  let match = retry < 12 ? [
+      Logging.childTrace,
+      source + ` hasn't reached block ` + block + ` on all of its servers yet. This is normal near the latest block and resolves by itself - retrying shortly.`
+    ] : [
+      Logging.childWarn,
+      source + ` is still catching up to block ` + block + `. This is a delay on the provider's side; indexing will continue automatically, using another data source if one is configured.`
+    ];
+  match[0](logger, {
+    msg: match[1],
     retry: retry,
-    backOffMilliseconds: backoffMillis,
-    err: Utils.prettifyExn(err)
+    backOffMilliseconds: backoffMillis
   });
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, 12, excludedSources);
 }
 
 function stalledLog(retry, warnAfter, msg, stalled) {
@@ -536,7 +551,7 @@ async function retryInconsistentResponse(sourceManager, sourceState, retry, isRe
     err: Utils.prettifyExn(err)
   });
   Stdlib_Option.forEach(sourceState.source.onReorg, cb => cb());
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined, excludedSources);
 }
 
 async function retryFailedPage(sourceManager, sourceState, retry, isRealtime, logger, msg, attemptedToBlock, backoffMillis, minBackoffMillisOpt, err, excludedSources) {
@@ -549,7 +564,7 @@ async function retryFailedPage(sourceManager, sourceState, retry, isRealtime, lo
     retry: retry,
     err: Stdlib_Option.map(err, Utils.prettifyExn)
   });
-  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillis, excludedSources);
+  return await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillis, undefined, excludedSources);
 }
 
 function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling) {
@@ -736,7 +751,7 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
         recordStatsInto(sourceState.requestStats, err.requestStats);
-        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$2, err.blockNumber, "getItems", err, excludedSourcesRef);
+        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$2, err.blockNumber, excludedSourcesRef);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
         await retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger$2, "getItems", err, excludedSourcesRef);
@@ -866,13 +881,10 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
       if (err.RE_EXN_ID === Source.RateLimited) {
-        let match = err._1;
-        recordStatsInto(sourceState.requestStats, match.requestStats);
-        await waitForRateLimitReset(sourceManager, match.resetMs, retry, logger$1);
+        await waitForRateLimitReset(sourceManager, err._1.resetMs, retry, logger$1);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.SourceBehindHead) {
-        recordStatsInto(sourceState.requestStats, err.requestStats);
-        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$1, err.blockNumber, "getBlockHashes", err, undefined);
+        await retryBehindHead(sourceManager, sourceState, retry, isRealtime, logger$1, err.blockNumber, undefined);
         retryRef = retryRef + 1 | 0;
       } else if (err.RE_EXN_ID === Source.InconsistentResponse) {
         await retryInconsistentResponse(sourceManager, sourceState, retry, isRealtime, logger$1, "getBlockHashes", err, undefined);
@@ -886,7 +898,7 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
           backOffMilliseconds: backoffMillis,
           err: Utils.prettifyExn(err)
         });
-        await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined);
+        await backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, 50, undefined, undefined);
         retryRef = retryRef + 1 | 0;
       }
     }

package/src/HandlerTypeCheck.mjs

@@ -1,14 +0,0 @@
-import { Worker } from "node:worker_threads";
-
-// The compiler blocks the thread it runs on, so it gets its own and the
-// database setup carries on meanwhile.
-export const check = (cwd, files) =>
-  new Promise((resolve, reject) => {
-    const worker = new Worker(new URL("./HandlerTypeCheckWorker.mjs", import.meta.url), {
-      workerData: { cwd, files },
-    });
-    worker.once("message", resolve);
-    worker.once("error", reject);
-    // Settles nothing once the result has arrived.
-    worker.once("exit", () => reject(new Error("The handler type check exited without a result.")));
-  });

package/src/HandlerTypeCheckWorker.mjs

@@ -1,68 +0,0 @@
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { stripVTControlCharacters } from "node:util";
-import { parentPort, workerData } from "node:worker_threads";
-
-const check = ({ cwd, files }) => {
-  // The ReScript compiler checks a ReScript project's handlers, so it has no
-  // reason to set up TypeScript, and the warning would only be noise there.
-  // `rescript.json` at the root is what makes codegen treat it as ReScript.
-  const skip = (warning) => (existsSync(path.join(cwd, "rescript.json")) ? {} : { skipped: warning });
-
-  let ts;
-  try {
-    // The project's own compiler, so handlers are checked exactly as the
-    // user's editor and `tsc` check them.
-    ts = createRequire(path.join(cwd, "package.json"))("typescript");
-  } catch {
-    return skip("Skipped the handler type check: the project doesn't depend on typescript.");
-  }
-
-  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists);
-  if (configPath === undefined) {
-    return skip(
-      "Skipped the handler type check: no tsconfig.json found. Add one to type-check handlers on start, like the one envio init creates."
-    );
-  }
-
-  const host = {
-    getCanonicalFileName: (file) => file,
-    getCurrentDirectory: () => cwd,
-    getNewLine: () => "\n",
-  };
-  const format = (diagnostics) =>
-    stripVTControlCharacters(ts.formatDiagnosticsWithColorAndContext(diagnostics, host)).trimEnd();
-
-  const parsed = ts.getParsedCommandLineOfConfigFile(
-    configPath,
-    { noEmit: true },
-    {
-      ...ts.sys,
-      onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
-        throw new Error(format([diagnostic]));
-      },
-    }
-  );
-
-  // The tsconfig's files are roots, as tsc makes them, since any of them can
-  // declare globals a handler relies on. Only the handlers' errors count.
-  const handlerFiles = files.map((file) => path.resolve(cwd, file));
-  const program = ts.createProgram({
-    rootNames: [...parsed.fileNames, ...handlerFiles],
-    options: parsed.options,
-    projectReferences: parsed.projectReferences,
-  });
-
-  // Every file is a root, so each has a source file. Without one,
-  // `getSemanticDiagnostics` would check the whole program.
-  const diagnostics = handlerFiles
-    .map((file) => program.getSourceFile(file))
-    .flatMap((sourceFile) => [
-      ...program.getSyntacticDiagnostics(sourceFile),
-      ...program.getSemanticDiagnostics(sourceFile),
-    ]);
-  return diagnostics.length === 0 ? {} : { errors: format(diagnostics) };
-};
-
-parentPort.postMessage(check(workerData));