envio 3.14.1 → 3.15.0-sidecars.2

package/evm.schema.json

@@ -56,6 +56,40 @@
         "null"
       ]
     },
+    "sidecar": {
+      "description": "A sidecar: your own long-running TypeScript process, run next to the indexer by `envio sidecar` (and started by `envio dev`). Handlers call its functions through `context.sidecar.<name>(input)` without waiting.",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/SidecarConfig"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "resolvers": {
+      "description": "Extra root query fields in the GraphQL API, answered by your sidecar or a webhook. Each one is published as a Hasura action, so Hasura and envio serve call the handler with Hasura's action payload.",
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "$ref": "#/$defs/ResolverConfig"
+      }
+    },
+    "types": {
+      "description": "Output object types for `resolvers:`: type name to a map of field name to GraphQL type string (for example `address: \"String!\"`).",
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "string"
+        }
+      }
+    },
     "ecosystem": {
       "description": "Ecosystem of the project.",
       "anyOf": [
@@ -273,6 +307,68 @@
         }
       ]
     },
+    "SidecarConfig": {
+      "type": "object",
+      "properties": {
+        "contract": {
+          "description": "Relative path to the contract module: `export default defineSidecar({ functions, webhooks })`. Schemas only, since both the indexer and the sidecar load it. Types `context.sidecar`.",
+          "type": "string"
+        },
+        "entry": {
+          "description": "Relative path to the sidecar entry module, which default-exports the `createSidecar(contract, {...})` result. Keep it outside the handlers directory, which the indexer auto-loads.",
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "contract",
+        "entry"
+      ]
+    },
+    "ResolverConfig": {
+      "type": "object",
+      "properties": {
+        "description": {
+          "description": "Shown as the field's description in the GraphQL schema.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "args": {
+          "description": "Argument name to GraphQL type string, for example `limit: \"Int!\"`. Scalars or lists of scalars.",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "output": {
+          "description": "GraphQL type string of the result, for example `\"[TopTrader!]!\"`. Scalars or types declared under `types:`.",
+          "type": "string"
+        },
+        "handler": {
+          "description": "`sidecar` (answered by the `resolvers` of your `createSidecar`) or an http(s):// URL that accepts Hasura's action payload.",
+          "type": "string"
+        },
+        "timeoutMs": {
+          "description": "How long the GraphQL layer waits for the handler. (default: 30000)",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "output",
+        "handler"
+      ]
+    },
     "EcosystemTag": {
       "type": "string",
       "enum": [

package/fuel.schema.json

@@ -56,6 +56,40 @@
         "null"
       ]
     },
+    "sidecar": {
+      "description": "A sidecar: your own long-running TypeScript process, run next to the indexer by `envio sidecar` (and started by `envio dev`). Handlers call its functions through `context.sidecar.<name>(input)` without waiting.",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/SidecarConfig"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "resolvers": {
+      "description": "Extra root query fields in the GraphQL API, answered by your sidecar or a webhook. Each one is published as a Hasura action, so Hasura and envio serve call the handler with Hasura's action payload.",
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "$ref": "#/$defs/ResolverConfig"
+      }
+    },
+    "types": {
+      "description": "Output object types for `resolvers:`: type name to a map of field name to GraphQL type string (for example `address: \"String!\"`).",
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "string"
+        }
+      }
+    },
     "ecosystem": {
       "description": "Ecosystem of the project.",
       "$ref": "#/$defs/EcosystemTag"
@@ -231,6 +265,68 @@
         }
       ]
     },
+    "SidecarConfig": {
+      "type": "object",
+      "properties": {
+        "contract": {
+          "description": "Relative path to the contract module: `export default defineSidecar({ functions, webhooks })`. Schemas only, since both the indexer and the sidecar load it. Types `context.sidecar`.",
+          "type": "string"
+        },
+        "entry": {
+          "description": "Relative path to the sidecar entry module, which default-exports the `createSidecar(contract, {...})` result. Keep it outside the handlers directory, which the indexer auto-loads.",
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "contract",
+        "entry"
+      ]
+    },
+    "ResolverConfig": {
+      "type": "object",
+      "properties": {
+        "description": {
+          "description": "Shown as the field's description in the GraphQL schema.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "args": {
+          "description": "Argument name to GraphQL type string, for example `limit: \"Int!\"`. Scalars or lists of scalars.",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "output": {
+          "description": "GraphQL type string of the result, for example `\"[TopTrader!]!\"`. Scalars or types declared under `types:`.",
+          "type": "string"
+        },
+        "handler": {
+          "description": "`sidecar` (answered by the `resolvers` of your `createSidecar`) or an http(s):// URL that accepts Hasura's action payload.",
+          "type": "string"
+        },
+        "timeoutMs": {
+          "description": "How long the GraphQL layer waits for the handler. (default: 30000)",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "output",
+        "handler"
+      ]
+    },
     "EcosystemTag": {
       "type": "string",
       "enum": [

package/index.d.ts

@@ -1,5 +1,13 @@
 import * as Sury from "rescript-schema";
 import type { default as BigDecimalT } from "bignumber.js";
+import type {
+  SidecarCaller,
+  SidecarContract,
+  SidecarFunctionInput,
+  SidecarFunctionName,
+  SidecarWebhookBody,
+  SidecarWebhookName,
+} from "./src/sidecar/contract.js";
 export { default as BigDecimal } from "bignumber.js";
 
 // Runtime value stubs used by the `S.*` namespace declarations further down
@@ -307,6 +315,65 @@ type GlobalConfig = Global extends { config: infer C extends IndexerConfigTypes
   ? C
   : {};
 
+/** `context.sidecar` for the `sidecar.contract` module codegen binds. The
+ *  contract is matched with `infer C extends SidecarContract`: testing an alias
+ *  with `extends SidecarContract` and passing it on can hand `SidecarCaller`
+ *  its intersection with `SidecarContract`, whose index signature lets any
+ *  function name through. */
+type GlobalSidecarCaller = Global extends { sidecar: infer C extends SidecarContract }
+  ? SidecarCaller<C>
+  : NotConfigured<"context.sidecar", "Add `sidecar: { contract, entry }`">;
+
+/** The webhooks the indexer itself posts about `context.sidecar` calls. */
+export type SidecarBuiltinWebhookName = "sidecar.ack" | "sidecar.dropped";
+
+/** A name `indexer.onWebhook` accepts: the contract's webhooks, the built-ins,
+ *  or any other name `emit.raw` may post. The contract is inferred where it is
+ *  used, as for `GlobalSidecarCaller`, so its index signature never leaks in. */
+export type WebhookName =
+  | (Global extends { sidecar: infer C extends SidecarContract } ? SidecarWebhookName<C> : never)
+  | SidecarBuiltinWebhookName
+  | (string & {});
+
+/** The call a built-in webhook is about, with its input decoded. */
+type SidecarCallRefOf<C extends SidecarContract> = {
+  [K in SidecarFunctionName<C>]: {
+    readonly callId: string;
+    readonly fn: K;
+    readonly input: SidecarFunctionInput<C, K>;
+  };
+}[SidecarFunctionName<C>];
+
+type WebhookBodyFrom<C extends SidecarContract, N extends string> = N extends "sidecar.ack"
+  ? SidecarCallRefOf<C>
+  : N extends "sidecar.dropped"
+    ? SidecarCallRefOf<C> & { readonly reason: string }
+    : N extends SidecarWebhookName<C>
+      ? SidecarWebhookBody<C, N>
+      : unknown;
+
+type WebhookBodyOf<N extends string> = Global extends { sidecar: infer C extends SidecarContract }
+  ? WebhookBodyFrom<C, N>
+  : N extends SidecarBuiltinWebhookName
+    ? { readonly callId: string; readonly fn: string; readonly input: unknown; readonly reason?: string }
+    : unknown;
+
+/** What an `indexer.onWebhook` handler is handed about the webhook. */
+export type OnWebhookEvent<N extends string = string> = {
+  readonly name: N;
+  /** Decoded with the contract's `webhooks.<name>.body` schema. */
+  readonly body: WebhookBodyOf<N>;
+  /** The id the listener answered the sidecar with. */
+  readonly id: string;
+  readonly chainId: number;
+  /** When the listener accepted it, in milliseconds since the epoch. */
+  readonly receivedAt: number;
+  readonly idempotencyKey?: string;
+  /** The block the webhook's writes are recorded at: where its chain's batch
+   *  left the chain. */
+  readonly block: { readonly number: number; readonly timestamp?: number };
+};
+
 /** Error-message string returned by project-bound aliases when codegen has
  *  not run yet. Resolves to `string` so handler signatures stay assignable.
  *  Wording is package-manager-neutral — `envio init` lets users pick pnpm,
@@ -581,6 +648,10 @@ type BaseHandlerContext<Config extends IndexerConfigTypes = GlobalConfig, ChainI
     readonly id: ChainId;
     readonly isRealtime: boolean;
   };
+  /** Call the sidecar declared by `sidecar:` in config.yaml. A call returns its
+   *  id synchronously, is skipped in preload, and is delivered after the batch
+   *  commits. */
+  readonly sidecar: GlobalSidecarCaller;
 } & {
   readonly [K in keyof ConfigEntities<Config>]: EntityOperations<ConfigEntities<Config>[K]>;
 };
@@ -1861,6 +1932,20 @@ export type IndexerFromConfig<Config extends IndexerConfigTypes = GlobalConfig>
         readonly rollbackToBlock: number;
       }) => Promise<void>,
     ) => void;
+    /**
+     * Handle a webhook the sidecar posts with `emit.<name>(body)`, or a
+     * built-in one about a `context.sidecar` call (`sidecar.ack`,
+     * `sidecar.dropped`). It runs once, in the next batch of its chain after
+     * that batch's events, with a normal handler context. A webhook undone by
+     * a reorg is not replayed.
+     */
+    readonly onWebhook: <const N extends WebhookName>(
+      options: { readonly name: N },
+      handler: (args: {
+        readonly webhook: OnWebhookEvent<N>;
+        readonly context: BaseHandlerContext<Config, number>;
+      }) => Promise<void>,
+    ) => void;
   } & SingleEcosystemChains<Config>
 >;
 
@@ -2066,6 +2151,11 @@ type EntityChange<Config extends IndexerConfigTypes = GlobalConfig> = {
   readonly addresses?: {
     readonly sets?: readonly AddressRegistration[];
   };
+  /** `context.sidecar` calls made in this block, in call order. `input` is the
+   *  JSON form the sidecar receives (bigint as a string). */
+  readonly sidecar?: {
+    readonly calls: readonly { readonly id: string; readonly fn: string; readonly input: unknown }[];
+  };
 } & {
   readonly [K in keyof ConfigEntities<Config>]?: EntityChangeValue<
     ConfigEntities<Config>[K]
@@ -2209,6 +2299,32 @@ type SingleEcosystemTestChains<Config extends IndexerConfigTypes = GlobalConfig>
     ? SvmTestEcosystem<Config>
     : CodegenRequiredFallback;
 
+/** A `context.sidecar` call as the test indexer records it, with `input` as the
+ *  handler passed it (a bigint stays a bigint). */
+export type TestIndexerSidecarCall<C extends SidecarContract> = {
+  [K in SidecarFunctionName<C>]: {
+    readonly id: string;
+    readonly fn: K;
+    readonly chainId: number;
+    readonly blockNumber: number;
+    /** Absent for block handlers. */
+    readonly blockTimestamp?: number;
+    readonly input: SidecarFunctionInput<C, K>;
+  };
+}[SidecarFunctionName<C>];
+
+/** `indexer.sidecar` on a test indexer. The test indexer never talks to a
+ *  sidecar: it records the calls instead. */
+type TestIndexerSidecar = Global extends { sidecar: infer C extends SidecarContract }
+  ? {
+      /** Every call the handlers made, across `process` runs, in call order.
+       *  Calls made during preload are not recorded. */
+      readonly calls: readonly TestIndexerSidecarCall<C>[];
+      /** Forget the recorded calls. */
+      readonly clear: () => void;
+    }
+  : NotConfigured<"indexer.sidecar", "Add `sidecar: { contract, entry }`">;
+
 /**
  * Test indexer type resolved from config.
  * Allows running the indexer for specific block ranges and inspecting results.
@@ -2221,6 +2337,8 @@ export type TestIndexerFromConfig<Config extends IndexerConfigTypes = GlobalConf
     /** Changes happened during the processing. */
     readonly changes: readonly EntityChange<Config>[];
   }>;
+  /** The `context.sidecar` calls the handlers made. */
+  readonly sidecar: TestIndexerSidecar;
 } & SingleEcosystemTestChains<Config> & {
   /** Entity operations for direct manipulation outside of handlers. */
   readonly [K in keyof ConfigEntities<Config>]: TestIndexerEntityOperations<
@@ -2306,3 +2424,14 @@ export const indexer: Indexer;
 
 /** Construct a {@link TestIndexer} for use in unit tests. */
 export const createTestIndexer: () => TestIndexer;
+
+// ============== Sidecars ==============
+
+export {
+  defineSidecar,
+  type SidecarContract,
+  type SidecarContractDef,
+  type SidecarCaller,
+  type SidecarFunctionInput,
+  type SidecarWebhookBody,
+} from "./src/sidecar/contract.js";

package/index.js

@@ -46,3 +46,5 @@ export const S = {
   assertOrThrow: Sury.assertOrThrow,
   parseOrThrow: Sury.parseOrThrow,
 };
+
+export { defineSidecar } from "./src/sidecar/contract.js";

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "envio",
-  "version": "3.14.1",
+  "version": "3.15.0-sidecars.2",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
   "main": "./index.js",
   "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./sidecar": {
+      "types": "./sidecar.d.ts",
+      "default": "./sidecar.js"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/enviodev/hyperindex.git"
@@ -37,27 +49,29 @@
     "rescript.json",
     "index.d.ts",
     "index.js",
+    "sidecar.d.ts",
+    "sidecar.js",
     "src",
     "licenses"
   ],
   "dependencies": {
     "@elastic/ecs-pino-format": "1.4.0",
+    "@rescript/runtime": "12.2.0",
     "bignumber.js": "9.3.1",
+    "dotenv": "16.4.5",
     "eventsource": "4.1.0",
     "express": "4.19.2",
     "pino": "10.3.1",
     "pino-pretty": "13.1.3",
-    "@rescript/runtime": "12.2.0",
+    "postgres": "3.4.8",
     "rescript-schema": "9.5.1",
-    "viem": "2.54.0",
-    "dotenv": "16.4.5",
-    "postgres": "3.4.8"
+    "viem": "2.54.0"
   },
   "optionalDependencies": {
-    "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"
+    "envio-linux-x64": "3.15.0-sidecars.2",
+    "envio-linux-x64-musl": "3.15.0-sidecars.2",
+    "envio-linux-arm64": "3.15.0-sidecars.2",
+    "envio-darwin-x64": "3.15.0-sidecars.2",
+    "envio-darwin-arm64": "3.15.0-sidecars.2"
   }
 }

package/sidecar.d.ts

@@ -0,0 +1 @@
+export * from "./src/sidecar/index.js";

package/sidecar.js

@@ -0,0 +1 @@
+export * from "./src/sidecar/index.js";

package/src/Batch.res

@@ -14,6 +14,8 @@ type chainAfterBatch = {
   totalEventsProcessed: float,
   fetchState: FetchState.t,
   isProgressAtHeadWhenBatchCreated: bool,
+  // Taken off the chain's webhook queue.
+  webhooksCount?: int,
 }
 
 // A per-chain snapshot of the scanned block hashes still inside the reorg
@@ -38,6 +40,7 @@ type chainBeforeBatch = {
   sourceBlockNumber: int,
   totalEventsProcessed: float,
   chainConfig: Config.chain,
+  pendingWebhooks: array<Internal.pendingWebhook>,
 }
 
 type t = {
@@ -58,6 +61,9 @@ type t = {
   // event, however many items it made.
   checkpointEventsProcessed: array<int>,
   registeredAddresses: array<AddressRows.staged>,
+  // `context.sidecar` calls the handlers made, in call order. Handed to the
+  // sidecar only once the batch has committed.
+  sidecarCalls: array<SidecarCall.t>,
 }
 
 // What a chain contributed to the batch: items taken off its buffer, and the
@@ -70,11 +76,12 @@ let getProgressedChainsById = {
     ~progressBlockNumberAfterBatch,
     ~fetchStateAfterBatch,
     ~counts: chainBatchCounts,
+    ~webhooksCount,
   ) => {
     // The check is sufficient, since we guarantee to include a full block in a batch
     // Also, this might be true even if batchSize is 0,
     // eg when indexing at the head and chain doesn't have items in a block
-    if chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch {
+    if chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch || webhooksCount > 0 {
       Some(
         (
           {
@@ -85,8 +92,13 @@ let getProgressedChainsById = {
             totalEventsProcessed: chainBeforeBatch.totalEventsProcessed +.
             counts.eventsProcessed->Int.toFloat,
             fetchState: fetchStateAfterBatch,
-            isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >=
-            chainBeforeBatch.sourceBlockNumber - chainBeforeBatch.chainConfig.blockLag,
+            // A batch of webhooks alone can come before the source has
+            // answered the height, while it still reads 0: nothing is at a
+            // head that isn't known yet.
+            isProgressAtHeadWhenBatchCreated: chainBeforeBatch.sourceBlockNumber > 0 &&
+              progressBlockNumberAfterBatch >=
+              chainBeforeBatch.sourceBlockNumber - chainBeforeBatch.chainConfig.blockLag,
+            webhooksCount,
           }: chainAfterBatch
         ),
       )
@@ -99,6 +111,7 @@ let getProgressedChainsById = {
     ~chainsBeforeBatch: dict<chainBeforeBatch>,
     ~countsPerChain: dict<chainBatchCounts>,
     ~progressBlockNumberPerChain: dict<int>,
+    ~webhooksCountPerChain: dict<int>,
   ) => {
     let progressedChainsById = Dict.make()
 
@@ -117,6 +130,10 @@ let getProgressedChainsById = {
       | Some(progressBlockNumber) => progressBlockNumber
       | None => chainBeforeBatch.progressBlockNumber
       }
+      let webhooksCount =
+        webhooksCountPerChain
+        ->Utils.Dict.dangerouslyGetNonOption(fetchState.chainId->ChainId.toString)
+        ->Option.getOr(0)
 
       switch switch countsPerChain->Utils.Dict.dangerouslyGetNonOption(
         fetchState.chainId->ChainId.toString,
@@ -128,6 +145,7 @@ let getProgressedChainsById = {
           ~counts,
           ~fetchStateAfterBatch=fetchState->FetchState.updateInternal(~mutItems=leftItems),
           ~progressBlockNumberAfterBatch,
+          ~webhooksCount,
         )
       // Skip not affected chains
       | None =>
@@ -136,6 +154,7 @@ let getProgressedChainsById = {
           ~counts={size: 0, eventsProcessed: 0},
           ~fetchStateAfterBatch=chainBeforeBatch.fetchState,
           ~progressBlockNumberAfterBatch,
+          ~webhooksCount,
         )
       } {
       | Some(progressedChain) =>
@@ -230,6 +249,7 @@ let make = (
   let cursor = sequence->CheckpointSequence.cursor(~frontier)
   let mutCountsPerChain = Dict.make()
   let mutProgressBlockNumberPerChain = Dict.make()
+  let mutWebhooksCountPerChain = Dict.make()
 
   let items = []
   let checkpointIds = []
@@ -263,8 +283,7 @@ let make = (
         // The buffer is sorted, so a log's items are consecutive: the first of
         // them is the only one that counts as an event.
         let isNewEvent =
-          idx === 0 ||
-            !(fetchState.buffer->Array.getUnsafe(idx - 1)->FetchState.isSameLog(item))
+          idx === 0 || !(fetchState.buffer->Array.getUnsafe(idx - 1)->FetchState.isSameLog(item))
         if isNewEvent {
           chainEventsProcessed := chainEventsProcessed.contents + 1
         }
@@ -345,6 +364,56 @@ let make = (
       ~mutCheckpointEventsProcessed=checkpointEventsProcessed,
     )
 
+    let webhooksCount = chainBeforeBatch.pendingWebhooks->Array.length
+    if webhooksCount > 0 {
+      let lastIndex = checkpointIds->Array.length - 1
+
+      // On a checkpoint of their own block, so a rollback to below it undoes
+      // them along with it, and one to it or above keeps them.
+      if (
+        lastIndex >= 0 &&
+        checkpointChainIds->Array.getUnsafe(lastIndex) === fetchState.chainId &&
+        checkpointBlockNumbers->Array.getUnsafe(lastIndex) === progressBlockNumberAfterBatch
+      ) {
+        checkpointItemsCount->Array.setUnsafe(
+          lastIndex,
+          checkpointItemsCount->Array.getUnsafe(lastIndex) + webhooksCount,
+        )
+      } else {
+        checkpointIds
+        ->Array.push(cursor->CheckpointSequence.next(~chainId=fetchState.chainId))
+        ->ignore
+        checkpointChainIds->Array.push(fetchState.chainId)->ignore
+        checkpointBlockNumbers->Array.push(progressBlockNumberAfterBatch)->ignore
+        checkpointBlockHashes
+        ->Array.push(
+          switch chainBeforeBatch.scannedHashes.hashByBlockNumber->Utils.Dict.dangerouslyGetByIntNonOption(
+            progressBlockNumberAfterBatch,
+          ) {
+          | Some(hash) => Null.Value(hash)
+          | None => Null.Null
+          },
+        )
+        ->ignore
+        checkpointItemsCount->Array.push(webhooksCount)->ignore
+        checkpointEventsProcessed->Array.push(0)->ignore
+      }
+      let blockTimestamp = chainBeforeBatch.blockTimeAt(progressBlockNumberAfterBatch)
+      chainBeforeBatch.pendingWebhooks->Array.forEach(pendingWebhook =>
+        items
+        ->Array.push(
+          Internal.Webhook({
+            pendingWebhook,
+            chainId: fetchState.chainId,
+            blockNumber: progressBlockNumberAfterBatch,
+            blockTimestamp,
+          }),
+        )
+        ->ignore
+      )
+      mutWebhooksCountPerChain->ChainId.Dict.set(fetchState.chainId, webhooksCount)
+    }
+
     mutProgressBlockNumberPerChain->ChainId.Dict.set(
       fetchState.chainId,
       progressBlockNumberAfterBatch,
@@ -360,6 +429,7 @@ let make = (
       ~chainsBeforeBatch,
       ~countsPerChain=mutCountsPerChain,
       ~progressBlockNumberPerChain=mutProgressBlockNumberPerChain,
+      ~webhooksCountPerChain=mutWebhooksCountPerChain,
     ),
     history,
     checkpointIds,
@@ -369,6 +439,7 @@ let make = (
     checkpointItemsCount,
     checkpointEventsProcessed,
     registeredAddresses: [],
+    sidecarCalls: [],
   }
 }
 
@@ -390,7 +461,7 @@ let findFirstEventBlockNumber = (batch: t, ~chainId) => {
     let checkpointChainId = batch.checkpointChainIds->Array.getUnsafe(idx.contents)
     if (
       checkpointChainId === chainId &&
-        batch.checkpointItemsCount->Array.getUnsafe(idx.contents) > 0
+        batch.checkpointEventsProcessed->Array.getUnsafe(idx.contents) > 0
     ) {
       result := Some(batch.checkpointBlockNumbers->Array.getUnsafe(idx.contents))
     } else {
@@ -414,7 +485,7 @@ let findLastEventItem = (batch: t, ~chainId) => {
           idx := idx.contents - 1
         }
       }
-    | Internal.Block(_) => idx := idx.contents - 1
+    | Internal.Block(_) | Internal.Webhook(_) => idx := idx.contents - 1
     }
   }
   result.contents