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

package/evm.schema.json

@@ -548,6 +548,16 @@
             "null"
           ]
         },
+        "headers": {
+          "description": "Optional HTTP headers sent with every request to this RPC endpoint, e.g. an Authorization bearer token for gated endpoints. Values support ${ENV_VAR} interpolation.",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
         "initial_block_interval": {
           "description": "The starting interval in range of blocks per query",
           "type": [

package/index.d.ts

@@ -979,13 +979,24 @@ export type SvmInstructionParams = {
   readonly extraAccounts: readonly string[];
 };
 
-/** Block context for a matched instruction. */
+/** Permissive fallback shape for an instruction's `block`. The generated
+ * per-instruction type narrows this to `slot`/`hash` (always present) and
+ * `time` (always present but possibly `undefined`), plus the selected
+ * `field_selection.block_fields`. */
 export type SvmInstructionBlock = {
   /** Slot this instruction's block was matched in. */
   readonly slot: number;
-  readonly time: number;
-  /** Always empty for now — reserved for the future reorg-guard route. */
+  /** Unix block time (seconds). Absent when HyperSync/Solana doesn't report a
+   * block time for this slot. */
+  readonly time?: number;
+  /** Block hash. */
   readonly hash: string;
+  /** Block height. Select via `field_selection.block_fields`. */
+  readonly height?: number;
+  /** Parent slot. Select via `field_selection.block_fields`. */
+  readonly parentSlot?: number;
+  /** Parent block hash. Select via `field_selection.block_fields`. */
+  readonly parentHash?: string;
 };
 
 export type SvmTokenBalance = {
@@ -997,24 +1008,6 @@ export type SvmTokenBalance = {
   readonly postAmount?: string;
 };
 
-/** Parent transaction surfaced when an instruction's
- * `include_transaction` flag is `true`. */
-export type SvmTransaction = {
-  readonly signatures: readonly string[];
-  readonly feePayer?: string;
-  readonly success?: boolean;
-  readonly err?: string;
-  /** Lamports. */
-  readonly fee?: bigint;
-  readonly computeUnitsConsumed?: bigint;
-  readonly accountKeys: readonly string[];
-  readonly recentBlockhash?: string;
-  readonly version?: string;
-  /** SPL Token / Token-2022 balance snapshots for this transaction.
-   * Present when `include_token_balances` is `true`. */
-  readonly tokenBalances?: readonly SvmTokenBalance[];
-};
-
 export type SvmLog = {
   readonly kind: string;
   readonly message: string;
@@ -1033,6 +1026,8 @@ export type SvmLog = {
  * are base58 strings. */
 export type SvmInstruction<
   Params extends SvmInstructionParams = SvmInstructionParams,
+  Tx = SvmTransaction,
+  Block = SvmInstructionBlock,
 > = {
   /** Program name as declared under `programs[].name` in `config.yaml`. */
   readonly programName: string;
@@ -1050,12 +1045,20 @@ export type SvmInstruction<
   readonly d8?: string;
   /** Borsh-decoded params. Present when a schema is configured and matched. */
   readonly params?: Params;
-  /** Present when the instruction's `include_transaction` is `true`. */
-  readonly transaction?: SvmTransaction;
+  /** Parent transaction. Carries only the fields selected via this
+   * instruction's `field_selection`; unselected fields are typed as
+   * `FieldNotSelected<...>` so reading them is a compile error. Always present
+   * (`{}` when no fields are selected). */
+  readonly transaction: Tx;
   /** Present when the instruction's `include_logs` is `true`; only logs
    * scoped to this exact instruction (matching `instruction_address`). */
   readonly logs?: readonly SvmLog[];
-  readonly block: SvmInstructionBlock;
+  /** The block this instruction's slot belongs to. Carries `slot`/`hash`
+   * (always present) and `time` (always present but possibly `undefined`),
+   * plus the fields selected via this instruction's
+   * `field_selection.block_fields`; unselected fields are typed as
+   * `FieldNotSelected<...>`. */
+  readonly block: Block;
 };
 
 /** Arguments passed to handlers registered via `indexer.onInstruction`. */
@@ -1327,7 +1330,11 @@ type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
                   handler: (
                     args: SvmOnInstructionHandlerArgs<
                       Config,
-                      SvmInstruction<SvmParamsFromProgramTable<Programs[P][I]>>
+                      SvmInstruction<
+                        SvmParamsFromProgramTable<Programs[P][I]>,
+                        Programs[P][I]["transaction"],
+                        Programs[P][I]["block"]
+                      >
                     >,
                   ) => Promise<void>,
                 ) => void;
@@ -1695,6 +1702,7 @@ type EvmContractsT  = GlobalConfig extends { evm:  { contracts: infer X extends
 type FuelChainsT    = GlobalConfig extends { fuel: { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
 type FuelContractsT = GlobalConfig extends { fuel: { contracts: infer X extends Record<string, Record<string, any>> } } ? X : {};
 type SvmChainsT     = GlobalConfig extends { svm:  { chains:    infer X extends Record<string, { id: number }> } } ? X : {};
+type SvmProgramsT   = GlobalConfig extends { svm:  { programs:  infer X extends Record<string, Record<string, any>> } } ? X : {};
 type EntitiesT      = GlobalConfig extends { entities: infer X extends Record<string, object> } ? X : {};
 type EnumsT         = GlobalConfig extends { enums: infer X extends Record<string, any> } ? X : {};
 
@@ -1716,6 +1724,18 @@ export type FuelChainId = IsEmptyObject<FuelChainsT> extends true ? NotConfigure
 /** Union of all configured SVM chain IDs. */
 export type SvmChainId  = IsEmptyObject<SvmChainsT>  extends true ? NotConfigured<"SvmChainId",  "Configure SVM chains">  : SvmChainsT [keyof SvmChainsT ]["id"];
 
+/** The SVM parent-transaction type generated from this project's
+ *  `field_selection`: the union of every instruction's `transaction` shape,
+ *  with unselected fields typed as `FieldNotSelected<...>`. Resolves to a
+ *  `NotConfigured` hint until `envio codegen` augments {@link Global}. */
+export type SvmTransaction = IsEmptyObject<SvmProgramsT> extends true
+  ? NotConfigured<"SvmTransaction", "Configure SVM programs">
+  : {
+      [P in keyof SvmProgramsT]: {
+        [I in keyof SvmProgramsT[P]]: SvmProgramsT[P][I]["transaction"];
+      }[keyof SvmProgramsT[P]];
+    }[keyof SvmProgramsT];
+
 /** Lookup an EVM event type by contract and event name. Without generics,
  *  resolves to the discriminated union of every EVM event in the project. */
 export type EvmEvent<

package/licenses/CLA.md

@@ -0,0 +1,35 @@
+# Contributor License Agreement (CLA)
+
+## 1. Introduction
+
+Thank you for your interest in contributing to this project ("Project"). We value your time and effort, and we appreciate all contributions made by the community. By submitting any work (a "Contribution"), you agree to the terms below.
+
+## 2. Automatic Acceptance
+
+By submitting a Pull Request or making any contribution to this project, you automatically agree to and accept all terms outlined in this Contributor License Agreement. This includes all future contributions you may make to the project.
+
+## 3. Your Contributions
+
+3.1 A "Contribution" includes any original work you share with the Project, such as code, documentation, or other creative content.
+
+3.2 You confirm that each Contribution is either your own original work or that you have all necessary rights and permissions to submit it under this CLA.
+
+## 4. License Grant
+
+4.1 By submitting a Contribution, you grant Envio (the "Maintainer") an irrevocable, worldwide, non-exclusive, royalty-free, perpetual license to use, reproduce, modify, distribute, prepare derivative works of, publicly display, perform, sublicense, and otherwise exploit your Contribution as part of the Project.
+
+4.2 You agree that the Maintainer may license or re-license your Contribution under terms compatible with those of the Project.
+
+## 5. Ongoing Use
+
+5.1 Once provided, Contributions cannot be retracted; however, the Maintainer is not obligated to include or continue using your Contribution.
+
+5.2 You understand that this CLA helps ensure your work remains compatible with the Project's licensing, now and in the future.
+
+## 6. Disclaimer
+
+6.1 You provide your Contributions on an "as is" basis, without warranties of any kind. This includes, but is not limited to, warranties of merchantability, fitness for a particular purpose, and non-infringement.
+
+## 7. Governing Law
+
+7.1 This CLA is governed by and construed in accordance with the laws of England. Any disputes will be subject to the exclusive jurisdiction of the English courts.

package/licenses/EULA.md

@@ -0,0 +1,67 @@
+## HyperIndex End-User License Agreement (EULA)
+
+This agreement describes the users' rights and the conditions upon which the Software and Generated Code may be used. The user should review the entire agreement, including any supplemental license terms that accompany the Software, since all of the terms are important and together create this agreement that applies to them.
+
+### 1. Definitions
+
+**Software:** HyperIndex, a copyrightable work created by Envio and licensed under this End User License Agreement (“EULA”).
+
+**Generated Code:** In the context of this license agreement, the term "generated code" refers to computer programming code that is produced automatically by the Software based on input provided by the user.
+
+**Licensed Material:** The Software and Generated Code defined here will be collectively referred to as “Licensed Material”.
+
+### 2. Installation and User Rights
+
+**License:** The Software is provided under this EULA. By agreeing to the EULA terms, you are granted the right to install and operate one instance of the Software on your device (referred to as the licensed device), for the use of one individual at a time, on the condition that you adhere to all terms outlined in this agreement.
+The licensor provides you with a non-exclusive, royalty-free, worldwide license that is non-sublicensable and non-transferable. This license allows you to use the Software subject to the limitations and conditions outlined in this EULA.
+With one license, the user can only use the Software on a single device.
+
+**Device:** In this agreement, "device" refers to a hardware system, whether physical or virtual, equipped with an internal storage device capable of executing the Software. This includes hardware partitions, which are considered as individual devices for the purposes of this agreement. Updates may be provided to the Software, and these updates may alter the minimum hardware requirements necessary for the Software. It is the responsibility of users to comply with any changing hardware requirements.
+
+**Updates:** The Software may be updated automatically. With each update, the EULA may be amended, and it is the users' responsibility to comply with the amendments.
+
+**Limitations:** Envio reserves all rights, including those under intellectual property laws, not expressly granted in this agreement. For instance, this license does not confer upon you the right to, and you are prohibited from:
+
+(i) Publishing, copying (other than the permitted backup copy), renting, leasing, or lending the Software;
+
+(ii) Transferring the Software (except as permitted by this agreement);
+
+(iii) Circumventing any technical restrictions or limitations in the Software;
+
+(iv) Using the Software as server Software, for commercial hosting, making the Software available for simultaneous use by multiple users over a network, installing the Software on a server and allowing users to access it remotely, or installing the Software on a device solely for remote user use;
+
+(v) Reverse engineering, decompiling, or disassembling the Software, or attempting to do so, except and only to the extent that the foregoing restriction is (a) permitted by applicable law; (b) permitted by licensing terms governing the use of open-source components that may be included with the Software and
+
+(vi) When using the Software, you may not use any features in any manner that could interfere with anyone else's use of them, or attempt to gain unauthorized access to or use of any service, data, account, or network.
+
+These limitations apply specifically to the Software and do not extend to the Generated Code. Details regarding the use of the Generated Code, including associated limitations, are provided below.
+
+### 3. Use of the Generated Code
+
+**Limitations:** Users can use, copy, distribute, make available, and create derivative works of the Generated Code freely, subject to the limitations and conditions specified below.
+
+(i) The user is prohibited from offering the Generated Code or any software that includes the Generated Code to third parties as a hosted or managed service, where the service grants users access to a significant portion of the Software's features or functionality.
+
+(ii) The user is not permitted to tamper with, alter, disable, or bypass the functionality of the license key in the Software. Additionally, the user may not eliminate or conceal any functionality within the Software that is safeguarded by the license key.
+
+(iii) Any modification, removal, or concealment of licensing, copyright, or other notices belonging to the licensor in the Software is strictly forbidden. The use of the licensor's trademarks is subject to relevant laws.
+
+**Credit:** If the user utilizes the Generated Code to develop and release a new software, product or service, the license agreement for said software, product or service must include proper credit to HyperIndex.
+
+**Liability:** Envio does not provide any assurance that the Generated Code functions correctly, nor does it assume any responsibility in this regard.
+
+Additionally, it will be the responsibility of the user to assess whether the Generated Code is suitable for the products and services provided by the user. Envio will not bear any responsibility if the Generated Code is found unsuitable for the products and services provided by the user.
+
+### 4. Additional Terms
+
+**Disclaimer of Warranties and Limitation of Liability:**
+
+(i) Unless expressly undertaken by the Licensor separately, the Licensed Material is provided on an as-is, as-available basis, and the Licensor makes no representations or warranties of any kind regarding the Licensed Material, whether express, implied, statutory, or otherwise. This encompasses, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether known or discoverable. If disclaimers of warranties are not permitted in whole or in part, this disclaimer may not apply to You.
+
+(ii) To the fullest extent permitted by law, under no circumstances shall the Licensor be liable to You under any legal theory (including, but not limited to, negligence) for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising from the use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. If limitations of liability are not permitted in whole or in part, this limitation may not apply to You.
+
+(iii) The disclaimers of warranties and limitations of liability outlined above shall be construed in a manner that most closely approximates an absolute disclaimer and waiver of all liability, to the fullest extent permitted by law.
+
+**Applicable Law and Competent Courts:** This EULA and shall be governed by and construed in accordance with the laws of England. The courts of England shall have exclusive jurisdiction to settle any dispute arising out of or in connection with this EULA.
+
+**Additional Agreements:** If the user chooses to use the Software, it may be required to agree to additional terms or agreements outside of this EULA.

package/licenses/LICENSE.md

@@ -0,0 +1,45 @@
+# Standard SaaS End User License Agreement (EULA)
+
+## End User License Agreement (EULA)
+
+This End User License Agreement ("Agreement") is between Envio ("Company") and the user ("User") who downloads, installs, or uses the Software as a Service (SaaS) provided by the Company.
+
+### 1. License Grant
+
+1.1 Company grants User a non-exclusive, non-transferable, limited license to access and use the SaaS for business or personal purposes in accordance with this Agreement.
+
+### 2. Restrictions
+
+2.1 User shall not:
+
+- Modify, copy, or create derivative works based on the SaaS.
+- Reverse engineer, decompile, or disassemble the SaaS.
+- Rent, lease, lend, sell, redistribute, or sublicense the SaaS.
+- Use the SaaS for any unlawful purpose.
+
+### 3. Ownership
+
+3.1 The Company retains all rights, title, and interest in and to the SaaS, including all intellectual property rights.
+
+### 4. Term and Termination
+
+4.1 This Agreement is effective until terminated. User’s rights under this Agreement will terminate automatically without notice if User fails to comply with any term(s) of this Agreement.
+4.2 Upon termination, User must cease all use of the SaaS and destroy all copies of any related documentation.
+
+### 5. Disclaimer of Warranties
+
+5.1 The SaaS is provided "AS IS" without warranty of any kind, either express or implied, including, but not limited to, implied warranties of merchantability and fitness for a particular purpose.
+
+### 6. Limitation of Liability
+
+6.1 In no event shall Company be liable for any special, incidental, indirect, or consequential damages whatsoever arising out of the use of or inability to use the SaaS.
+
+### 7. Governing Law
+
+7.1 This Agreement shall be governed by and construed in accordance with the laws of the United Kingdom.
+
+### 8. Entire Agreement
+
+8.1 This Agreement constitutes the entire agreement between the parties with respect to the use of the SaaS and supersedes all prior or contemporaneous understandings regarding such subject matter.
+
+**By using the SaaS, the User agrees to be bound by this Agreement.**

package/licenses/README.md

@@ -0,0 +1,35 @@
+# Licensing Information
+
+## Overview
+
+Envio's licensing reflects open source ethos but is not OSI recognized. Developers can use Envio's services without vendor lock-in, either by self-hosting or specifying an RPC URL. The generated code is open and public and so is this repository that generates the generated code.
+
+Our licenses allows self-hosting but restricts third-party hosting with Envio's hosted service. Envio may consider open-sourcing in the future but prioritizes stakeholder interests and market traction. Please reach out to us on discord if you would like to explore hosting indexers as a third-party.
+
+## TL;DR
+
+- **Envio's licensing** mirrors open source benefits but is not OSI recognized.
+- **Developers** can use Envio's services without vendor lock-in by:
+  - Self-hosting.
+  - Specifying an RPC URL.
+- **Code** is open and public.
+- **Generated license** allows self-hosting but restricts third-party competition.
+- **Code generator license** is a commercial license.
+  - **non-comercial use** is allowed.
+  - **forking and modifying code** is not allowed. However, if you have specific needs or use cases, please contact us to discuss potential exceptions.
+- **Future considerations** for open-sourcing are dependent on market traction and stakeholder interests.
+- **Contributors** must agree to our Contributor License Agreement (CLA).
+
+## Our Position
+
+We're developers who value the open source ethos, which is why our licensing mirrors many benefits of open source licensing. However, Envio and its products do not use a recognized open source license by the OSI. We are public and open, and our licensing reflects this.
+
+Our future business model lies in our hosted service and HyperSync requests, and we are protecting this. To ensure continuity and avoid vendor lock-in, developers can run and develop on their indexer without our hosted service. This can be achieved either by self-hosting, which our license permits, or by specifying an RPC URL in their indexer configuration, thus bypassing HyperSync.
+
+Envio is in its formative stages. Although we may consider open-sourcing the software in the future, we are committed to ensuring the best interests of all stakeholders. Going open source is somewhat of a one-way function; it's easier to open source than to go "closed source." Once we have gained more market traction, we will review our position on going open source.
+
+## Our Licenses
+
+- [EULA](./EULA.md) - The license in your indexer pertaining to the generated code
+- [LICENSE](./LICENSE.md) - The non-commercial use license pertaining to this code base which is used to template & generate the indexing code
+- [CLA](./CLA.md) - The Contributor License Agreement for those who wish to contribute to the project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.1",
+  "version": "3.3.0-alpha.11",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -11,7 +11,7 @@
     "url": "git+https://github.com/enviodev/hyperindex.git"
   },
   "author": "envio contributors <about@envio.dev>",
-  "license": "GPL-3.0",
+  "license": "SEE LICENSE IN licenses/README.md",
   "bugs": {
     "url": "https://github.com/enviodev/hyperindex/issues"
   },
@@ -37,7 +37,8 @@
     "rescript.json",
     "index.d.ts",
     "index.js",
-    "src"
+    "src",
+    "licenses"
   ],
   "dependencies": {
     "@clickhouse/client": "1.17.0",
@@ -57,7 +58,7 @@
     "yargs": "17.7.2",
     "@rescript/runtime": "12.2.0",
     "rescript-schema": "9.5.1",
-    "viem": "2.46.2",
+    "viem": "2.54.0",
     "dotenv": "16.4.5",
     "date-fns": "3.3.1",
     "@rescript/react": "0.14.1",
@@ -69,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.1",
-    "envio-linux-x64-musl": "3.3.0-alpha.1",
-    "envio-linux-arm64": "3.3.0-alpha.1",
-    "envio-darwin-x64": "3.3.0-alpha.1",
-    "envio-darwin-arm64": "3.3.0-alpha.1"
+    "envio-linux-x64": "3.3.0-alpha.11",
+    "envio-linux-x64-musl": "3.3.0-alpha.11",
+    "envio-linux-arm64": "3.3.0-alpha.11",
+    "envio-darwin-x64": "3.3.0-alpha.11",
+    "envio-darwin-arm64": "3.3.0-alpha.11"
   }
 }

package/src/Address.res

@@ -11,8 +11,11 @@ module Evm = {
   external fromStringOrThrow: string => t = "getAddress"
 
   // NOTE: the function is named to be overshadowed by the one below, so that we don't have to import viem in the handler code
+  // strict:false checks only the 20-byte hex shape, not EIP-55 checksum casing —
+  // since we're about to lowercase it anyway, an all-uppercase or wrongly-cased
+  // input address is just as valid as one that's already lowercase.
   @module("viem")
-  external fromStringLowercaseOrThrow: string => bool = "isAddress"
+  external fromStringLowercaseOrThrow: (string, {"strict": bool}) => bool = "isAddress"
 
   // Reassign since the function might be used in the handler code
   // and we don't want to have a "viem" import there. It's needed to keep "viem" a dependency
@@ -20,7 +23,7 @@ module Evm = {
   // Also, we want a custom error message, which is searchable in our codebase.
   // Validate that the string is a proper address but return a lowercased value
   let fromStringLowercaseOrThrow = string => {
-    if fromStringLowercaseOrThrow(string) {
+    if fromStringLowercaseOrThrow(string, {"strict": false}) {
       unsafeFromString(string->String.toLowerCase)
     } else {
       JsError.throwWithMessage(

package/src/Address.res.mjs

@@ -7,7 +7,9 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 let schema = S$RescriptSchema.setName(S$RescriptSchema.string, "Address");
 
 function fromStringLowercaseOrThrow(string) {
-  if (Viem.isAddress(string)) {
+  if (Viem.isAddress(string, {
+      strict: false
+    })) {
     return string.toLowerCase();
   } else {
     return Stdlib_JsError.throwWithMessage(`Address "` + string + `" is invalid. Expected a 20-byte hex string starting with 0x.`);

package/src/Api.res

@@ -9,7 +9,7 @@ let createTestIndexer: unit => unknown = () => {
       NodeJs.Path.getDirname(NodeJs.ImportMeta.importMeta),
       "TestIndexerWorker.res.mjs",
     )->NodeJs.Path.toString
-  TestIndexer.makeCreateTestIndexer(~config=Config.loadWithoutRegistrations(), ~workerPath)()->(
+  TestIndexer.makeCreateTestIndexer(~config=Config.load(), ~workerPath)()->(
     Utils.magic: TestIndexer.t<'a> => unknown
   )
 }

package/src/Api.res.mjs

@@ -10,7 +10,7 @@ let indexer = Main.getGlobalIndexer();
 
 function createTestIndexer() {
   let workerPath = Path.join(NodeJs.Path.getDirname(import.meta), "TestIndexerWorker.res.mjs");
-  return TestIndexer.makeCreateTestIndexer(Config.loadWithoutRegistrations(), workerPath)();
+  return TestIndexer.makeCreateTestIndexer(Config.load(), workerPath)();
 }
 
 export {

package/src/Batch.res

@@ -34,12 +34,6 @@ type t = {
   checkpointEventsProcessed: array<int>,
 }
 
-let hasReadyItem = (fetchStates: array<FetchState.t>) => {
-  fetchStates->Array.some(fetchState => {
-    fetchState->FetchState.isActivelyIndexing && fetchState->FetchState.hasReadyItem
-  })
-}
-
 let getProgressedChainsById = {
   let getChainAfterBatchIfProgressed = (
     ~chainBeforeBatch: chainBeforeBatch,

package/src/Batch.res.mjs

@@ -4,16 +4,6 @@ import * as Utils from "./Utils.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
 import * as ReorgDetection from "./ReorgDetection.res.mjs";
 
-function hasReadyItem(fetchStates) {
-  return fetchStates.some(fetchState => {
-    if (FetchState.isActivelyIndexing(fetchState)) {
-      return FetchState.hasReadyItem(fetchState);
-    } else {
-      return false;
-    }
-  });
-}
-
 function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
   if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
     return {
@@ -37,7 +27,7 @@ function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressB
     let progressedChain;
     if (batchSize !== undefined) {
       let leftItems = fetchState.buffer.slice(batchSize);
-      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, leftItems, undefined, undefined), batchSize);
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, leftItems, undefined, undefined, undefined), batchSize);
     } else {
       progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
     }
@@ -208,7 +198,6 @@ function findLastEventItem(batch, chainId) {
 }
 
 export {
-  hasReadyItem,
   getProgressedChainsById,
   addReorgCheckpoints,
   prepareBatch,

package/src/BatchProcessing.res

@@ -77,15 +77,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     state
     ->IndexerState.chainStates
     ->Dict.valuesToArray
-    ->Array.every(cs => {
-      let fetchState = switch progressedChainsById->Utils.Dict.dangerouslyGetByIntNonOption(
-        (cs->ChainState.fetchState).chainId,
-      ) {
-      | Some(chainAfterBatch) => chainAfterBatch.fetchState
-      | None => cs->ChainState.fetchState
-      }
-      fetchState->FetchState.isReadyToEnterReorgThreshold
-    })
+    ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
 
   if shouldEnterReorgThreshold {
     IndexerState.enterReorgThreshold(state)
@@ -135,6 +127,11 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     | Ok() =>
       state->IndexerState.recordProcessedBatch
 
+      switch state->IndexerState.simulateDeadInputTracker {
+      | Some(tracker) => tracker->SimulateDeadInputTracker.recordProcessed(~batch)
+      | None => ()
+      }
+
       if state->IndexerState.isResolvingReorg {
         // A reorg landed while this batch was processing. Apply its progress so
         // the rollback diff is computed against up-to-date chain progress, but
@@ -171,9 +168,7 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
           state
           ->IndexerState.chainStates
           ->Dict.valuesToArray
-          ->Array.every(cs =>
-            cs->ChainState.isProgressAtHead && (cs->ChainState.fetchState).endBlock->Option.isNone
-          )
+          ->Array.every(ChainState.isAtHeadWithoutEndBlock)
         ) {
           IndexerState.errorExit(
             state,

package/src/BatchProcessing.res.mjs

@@ -4,16 +4,16 @@ import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as FetchState from "./FetchState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ChainMetadata from "./ChainMetadata.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as ExitOnCaughtUp from "./ExitOnCaughtUp.res.mjs";
 import * as EventProcessing from "./EventProcessing.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 function yieldTick() {
   return new Promise((resolve, param) => {
@@ -30,10 +30,7 @@ async function processNextBatch(state, scheduleFetch) {
   let batch = IndexerState.createBatch(state, IndexerState.processedCheckpointId(state), IndexerState.config(state).batchSize, isRollbackBatch);
   let progressedChainsById = batch.progressedChainsById;
   let isBelowReorgThreshold = !isInReorgThresholdBeforeUpdate && IndexerState.config(state).shouldRollbackOnReorg;
-  let shouldEnterReorgThreshold = isBelowReorgThreshold && Object.values(IndexerState.chainStates(state)).every(cs => {
-    let chainAfterBatch = progressedChainsById[ChainState.fetchState(cs).chainId];
-    return FetchState.isReadyToEnterReorgThreshold(chainAfterBatch !== undefined ? chainAfterBatch.fetchState : ChainState.fetchState(cs));
-  });
+  let shouldEnterReorgThreshold = isBelowReorgThreshold && Object.values(IndexerState.chainStates(state)).every(cs => ChainState.isReadyToEnterReorgThresholdAfterBatch(cs, batch));
   if (shouldEnterReorgThreshold) {
     IndexerState.enterReorgThreshold(state);
   }
@@ -60,6 +57,10 @@ async function processNextBatch(state, scheduleFetch) {
     return IndexerState.errorExit(state, errHandler._0);
   }
   IndexerState.recordProcessedBatch(state);
+  let tracker = IndexerState.simulateDeadInputTracker(state);
+  if (tracker !== undefined) {
+    SimulateDeadInputTracker.recordProcessed(Primitive_option.valFromOption(tracker), batch);
+  }
   if (IndexerState.isResolvingReorg(state)) {
     return IndexerState.applyBatchProgress(state, batch);
   }
@@ -75,7 +76,7 @@ async function processNextBatch(state, scheduleFetch) {
   }
   if (allCaughtUp && !IndexerState.keepProcessAlive(state)) {
     return await ExitOnCaughtUp.run(state);
-  } else if (!allCaughtUp && IndexerState.exitAfterFirstEventBlock(state) && Object.values(IndexerState.chainStates(state)).every(cs => ChainState.isProgressAtHead(cs) ? Stdlib_Option.isNone(ChainState.fetchState(cs).endBlock) : false)) {
+  } else if (!allCaughtUp && IndexerState.exitAfterFirstEventBlock(state) && Object.values(IndexerState.chainStates(state)).every(ChainState.isAtHeadWithoutEndBlock)) {
     return IndexerState.errorExit(state, ErrorHandling.make(new Error("No events found between startBlock and chain head. Cannot auto-detect endBlock."), undefined, undefined));
   } else {
     ChainMetadata.stage(state);

package/src/Bin.res

@@ -71,6 +71,9 @@ let run = async args => {
       }
     }
   } catch {
+  | Main.FatalError(_) =>
+    // Already logged with full context by Main.start's onError; just exit.
+    NodeJs.process->NodeJs.exitWithCode(Failure)
   | exn =>
     // Log just the exception's own message — wrapping it in "Failed at
     // initialization" and pino's err serializer buries the real cause under

package/src/Bin.res.mjs

@@ -79,6 +79,10 @@ async function run(args) {
     }
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID === Main.FatalError) {
+      Process.exit(1);
+      return;
+    }
     let e = Primitive_exceptions.internalToException(exn);
     let message = e.RE_EXN_ID === "JsExn" ? Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "Failed at initialization") : "Failed at initialization";
     Logging.error(message);