envio 3.0.2 → 3.1.0-rc.1

package/src/EventConfigBuilder.res

@@ -1,24 +1,14 @@
-// Types moved to `Internal` so `Internal.evmEventConfig` can retain
-// `indexedParams: array<eventParam>` for post-registration filter rebuild.
-// Re-exported here as aliases for existing call sites.
-type eventParamComponent = Internal.eventParamComponent
-type eventParam = Internal.eventParam
-
-let eventParamComponentSchema = S.recursive(self =>
-  S.object((s): eventParamComponent => {
+type paramMeta = Internal.paramMeta
+
+let paramMetaSchema = S.recursive(self =>
+  S.object((s): paramMeta => {
     name: s.field("name", S.string),
     abiType: s.field("abiType", S.string),
+    indexed: s.fieldOr("indexed", S.bool, false),
     components: ?s.field("components", S.option(S.array(self))),
   })
 )
 
-let eventParamSchema = S.object((s): eventParam => {
-  name: s.field("name", S.string),
-  abiType: s.field("abiType", S.string),
-  indexed: s.fieldOr("indexed", S.bool, false),
-  components: ?s.field("components", S.option(S.array(eventParamComponentSchema))),
-})
-
 // Normalize a value that could be a single item or an array into an array
 let normalizeOrThrow: 'a => array<'a> = value => {
   if Array.isArray(value->Obj.magic) {
@@ -151,7 +141,7 @@ let rec abiTypeToDefaultValue = (abiType: string): unknown => {
 let rec componentsToObjectSchema = (
   ~leafSchema: string => S.t<unknown>,
   abiType: string,
-  components: array<eventParamComponent>,
+  components: array<paramMeta>,
 ): S.t<unknown> => {
   if abiType->String.endsWith("]") {
     let bracketIdx = abiType->String.lastIndexOf("[")
@@ -174,10 +164,7 @@ let rec componentsToObjectSchema = (
 
 // Default simulate value for a component tree — mirrors `abiTypeToDefaultValue`
 // but emits objects with named fields for tuples.
-let rec componentsToDefaultValue = (
-  abiType: string,
-  components: array<eventParamComponent>,
-): unknown => {
+let rec componentsToDefaultValue = (abiType: string, components: array<paramMeta>): unknown => {
   if abiType->String.endsWith("]") {
     []->(Utils.magic: array<unknown> => unknown)
   } else {
@@ -193,41 +180,9 @@ let rec componentsToDefaultValue = (
   }
 }
 
-// Build a post-processor that converts the raw positional tuple values
-// produced by the HyperSync decoder into objects with named fields. Walks
-// through array wrappers so `struct[]` becomes `array<{...}>`. Returns `None`
-// for leaf params where no remapping is needed.
-let rec componentsToRemapper = (
-  abiType: string,
-  components: array<eventParamComponent>,
-  value: unknown,
-): unknown => {
-  if abiType->String.endsWith("]") {
-    let bracketIdx = abiType->String.lastIndexOf("[")
-    let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
-    let arr = value->(Utils.magic: unknown => array<unknown>)
-    arr
-    ->Array.map(item => componentsToRemapper(baseType, components, item))
-    ->(Utils.magic: array<unknown> => unknown)
-  } else {
-    // Must be a tuple at this level: build an object keyed by component names.
-    let arr = value->(Utils.magic: unknown => array<unknown>)
-    let dict = Dict.make()
-    components->Array.forEachWithIndex((c, i) => {
-      let raw = arr->Array.getUnsafe(i)
-      let mapped = switch c.components {
-      | Some(sub) => componentsToRemapper(c.abiType, sub, raw)
-      | None => raw
-      }
-      dict->Dict.set(c.name, mapped)
-    })
-    dict->(Utils.magic: dict<unknown> => unknown)
-  }
-}
-
 // ============== Build paramsRawEventSchema ==============
 
-let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> => {
+let buildParamsSchema = (params: array<paramMeta>): S.t<Internal.eventParams> => {
   if params->Array.length == 0 {
     S.literal(%raw(`null`))
     ->S.shape(_ => ())
@@ -256,7 +211,7 @@ let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> =
 // Uses S.schema + s.matches with S.null->S.Option.getOr to fill missing fields with defaults.
 // When a param carries component metadata (Solidity struct), we accept and emit a
 // record with named fields rather than a positional tuple.
-let buildSimulateParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> => {
+let buildSimulateParamsSchema = (params: array<paramMeta>): S.t<Internal.eventParams> => {
   if params->Array.length == 0 {
     S.unknown
     ->S.shape(_ => ())
@@ -279,71 +234,6 @@ let buildSimulateParamsSchema = (params: array<eventParam>): S.t<Internal.eventP
   }
 }
 
-// ============== Build HyperSync decoder via new Function() ==============
-
-// Param names from ABI are valid Solidity identifiers ([a-zA-Z_$][a-zA-Z0-9_$]*),
-// so they're safe to use in quoted property names within new Function() body.
-@new @variadic
-external makeFunction: array<string> => 'a = "Function"
-
-let buildHyperSyncDecoder = (params: array<eventParam>): (
-  HyperSyncClient.Decoder.decodedEvent => Internal.eventParams
-) => {
-  if params->Array.length == 0 {
-    _ => ()->(Utils.magic: unit => Internal.eventParams)
-  } else {
-    let indexedParams = params->Array.filter(p => p.indexed)
-    let bodyParams = params->Array.filter(p => !p.indexed)
-
-    let fields = []
-    indexedParams->Array.forEachWithIndex((p, i) => {
-      fields->Array.push(`"${p.name}": t(d.indexed[${i->Int.toString}])`)->ignore
-    })
-    bodyParams->Array.forEachWithIndex((p, i) => {
-      fields->Array.push(`"${p.name}": t(d.body[${i->Int.toString}])`)->ignore
-    })
-    // Generate: function(t) { return function(d) { return { ... } } }
-    let body = `return function(d) { return {${fields->Array.joinUnsafe(", ")}} }`
-
-    let factory: (
-      HyperSyncClient.Decoder.decodedRaw => HyperSyncClient.Decoder.decodedUnderlying
-    ) => HyperSyncClient.Decoder.decodedEvent => Internal.eventParams =
-      makeFunction(["t", body])->(
-        Utils.magic: 'a => (
-          HyperSyncClient.Decoder.decodedRaw => HyperSyncClient.Decoder.decodedUnderlying
-        ) => HyperSyncClient.Decoder.decodedEvent => Internal.eventParams
-      )
-
-    let baseDecode = factory(HyperSyncClient.Decoder.toUnderlying)
-
-    // For any param that has tuple component metadata, rewrite its value from a
-    // positional array into a named record post-decode. We pre-collect the
-    // params that need remapping so the hot path only walks those. Indexed
-    // struct/tuple params arrive as keccak256 topic hashes (single hex strings)
-    // rather than positional arrays, so they must be skipped here — running
-    // componentsToRemapper on a hash would treat the hex string as an array
-    // and read garbage.
-    let paramsToRemap = params->Array.filter(p => !p.indexed && p.components->Option.isSome)
-
-    if paramsToRemap->Array.length == 0 {
-      baseDecode
-    } else {
-      decoded => {
-        let result = baseDecode(decoded)
-        let dict = result->(Utils.magic: Internal.eventParams => dict<unknown>)
-        paramsToRemap->Array.forEach(p => {
-          switch (p.components, dict->Dict.get(p.name)) {
-          | (Some(components), Some(raw)) =>
-            dict->Dict.set(p.name, componentsToRemapper(p.abiType, components, raw))
-          | _ => ()
-          }
-        })
-        dict->(Utils.magic: dict<unknown> => Internal.eventParams)
-      }
-    }
-  }
-}
-
 // ============== Build topic filter getters ==============
 
 let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
@@ -386,7 +276,7 @@ let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
   }
 }
 
-let buildTopicGetter = (p: eventParam) => {
+let buildTopicGetter = (p: paramMeta) => {
   let encoder = getTopicEncoder(p.abiType)
   (eventFilter: dict<JSON.t>) =>
     eventFilter
@@ -425,7 +315,7 @@ let buildEvmEventConfig = (
   ~contractName: string,
   ~eventName: string,
   ~sighash: string,
-  ~params: array<eventParam>,
+  ~params: array<paramMeta>,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
@@ -486,11 +376,11 @@ let buildEvmEventConfig = (
     filterByAddresses,
     dependsOnAddresses: !isWildcard || filterByAddresses,
     startBlock: resolvedStartBlock,
-    convertHyperSyncEventArgs: buildHyperSyncDecoder(params),
     selectedBlockFields,
     selectedTransactionFields,
     sighash,
-    indexedParams,
+    topicCount,
+    paramsMetadata: params,
   }
 }
 

package/src/EventConfigBuilder.res.mjs

@@ -9,23 +9,16 @@ import * as LogSelection from "./LogSelection.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-let eventParamComponentSchema = S$RescriptSchema.recursive(self => S$RescriptSchema.object(s => ({
+let paramMetaSchema = S$RescriptSchema.recursive(self => S$RescriptSchema.object(s => ({
   name: s.f("name", S$RescriptSchema.string),
   abiType: s.f("abiType", S$RescriptSchema.string),
+  indexed: s.fieldOr("indexed", S$RescriptSchema.bool, false),
   components: s.f("components", S$RescriptSchema.option(S$RescriptSchema.array(self)))
 })));
 
-let eventParamSchema = S$RescriptSchema.object(s => ({
-  name: s.f("name", S$RescriptSchema.string),
-  abiType: s.f("abiType", S$RescriptSchema.string),
-  indexed: s.fieldOr("indexed", S$RescriptSchema.bool, false),
-  components: s.f("components", S$RescriptSchema.option(S$RescriptSchema.array(eventParamComponentSchema)))
-}));
-
 function normalizeOrThrow(value) {
   if (Array.isArray(value)) {
     return value;
@@ -174,22 +167,6 @@ function componentsToDefaultValue(abiType, components) {
   return dict;
 }
 
-function componentsToRemapper(abiType, components, value) {
-  if (abiType.endsWith("]")) {
-    let bracketIdx = abiType.lastIndexOf("[");
-    let baseType = abiType.slice(0, bracketIdx);
-    return value.map(item => componentsToRemapper(baseType, components, item));
-  }
-  let dict = {};
-  components.forEach((c, i) => {
-    let raw = value[i];
-    let sub = c.components;
-    let mapped = sub !== undefined ? componentsToRemapper(c.abiType, sub, raw) : raw;
-    dict[c.name] = mapped;
-  });
-  return dict;
-}
-
 function buildParamsSchema(params) {
   if (params.length === 0) {
     return S$RescriptSchema.shape(S$RescriptSchema.literal(null), param => {});
@@ -228,47 +205,6 @@ function buildSimulateParamsSchema(params) {
   }
 }
 
-function buildHyperSyncDecoder(params) {
-  if (params.length === 0) {
-    return param => {};
-  }
-  let indexedParams = params.filter(p => p.indexed);
-  let bodyParams = params.filter(p => !p.indexed);
-  let fields = [];
-  indexedParams.forEach((p, i) => {
-    fields.push(`"` + p.name + `": t(d.indexed[` + i.toString() + `])`);
-  });
-  bodyParams.forEach((p, i) => {
-    fields.push(`"` + p.name + `": t(d.body[` + i.toString() + `])`);
-  });
-  let body = `return function(d) { return {` + fields.join(", ") + `} }`;
-  let factory = new Function("t", body);
-  let baseDecode = factory(HyperSyncClient.Decoder.toUnderlying);
-  let paramsToRemap = params.filter(p => {
-    if (p.indexed) {
-      return false;
-    } else {
-      return Stdlib_Option.isSome(p.components);
-    }
-  });
-  if (paramsToRemap.length === 0) {
-    return baseDecode;
-  } else {
-    return decoded => {
-      let result = baseDecode(decoded);
-      paramsToRemap.forEach(p => {
-        let match = p.components;
-        let match$1 = result[p.name];
-        if (match !== undefined && match$1 !== undefined) {
-          result[p.name] = componentsToRemapper(p.abiType, match, Primitive_option.valFromOption(match$1));
-          return;
-        }
-      });
-      return result;
-    };
-  }
-}
-
 function getTopicEncoder(abiType) {
   if (abiType.endsWith("]") || abiType.startsWith("(")) {
     return TopicFilter.castToHexUnsafe;
@@ -344,11 +280,11 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
     simulateParamsSchema: buildSimulateParamsSchema(params),
     startBlock: resolvedStartBlock,
     getEventFiltersOrThrow: match.getEventFiltersOrThrow,
-    convertHyperSyncEventArgs: buildHyperSyncDecoder(params),
     selectedBlockFields: match$1[0],
     selectedTransactionFields: match$1[1],
     sighash: sighash,
-    indexedParams: indexedParams
+    topicCount: topicCount,
+    paramsMetadata: params
   };
 }
 
@@ -412,8 +348,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
 }
 
 export {
-  eventParamComponentSchema,
-  eventParamSchema,
+  paramMetaSchema,
   normalizeOrThrow,
   splitTupleComponents,
   abiTypeToSchema,
@@ -421,10 +356,8 @@ export {
   abiTypeToDefaultValue,
   componentsToObjectSchema,
   componentsToDefaultValue,
-  componentsToRemapper,
   buildParamsSchema,
   buildSimulateParamsSchema,
-  buildHyperSyncDecoder,
   getTopicEncoder,
   buildTopicGetter,
   alwaysIncludedBlockFields,
@@ -432,4 +365,4 @@ export {
   buildEvmEventConfig,
   buildFuelEventConfig,
 }
-/* eventParamComponentSchema Not a pure module */
+/* paramMetaSchema Not a pure module */

package/src/EventProcessing.res

@@ -93,9 +93,7 @@ let addItemToRawEvents = (
     params,
   }
 
-  let eventIdStr = eventId->BigInt.toString
-
-  inMemoryStore.rawEvents->InMemoryTable.set({chainId, eventId: eventIdStr}, rawEvent)
+  inMemoryStore.rawEvents->Array.push(rawEvent)
 }
 
 exception ProcessingError({message: string, exn: exn, item: Internal.item})
@@ -107,7 +105,6 @@ let runEventHandlerOrThrow = async (
   ~inMemoryStore,
   ~loadManager,
   ~persistence,
-  ~shouldSaveHistory,
   ~chains: Internal.chains,
   ~config: Config.t,
 ) => {
@@ -123,7 +120,6 @@ let runEventHandlerOrThrow = async (
       inMemoryStore,
       loadManager,
       persistence,
-      shouldSaveHistory,
       isPreload: false,
       chains,
       config,
@@ -162,7 +158,6 @@ let runHandlerOrThrow = async (
   ~inMemoryStore,
   ~loadManager,
   ~ctx: Ctx.t,
-  ~shouldSaveHistory,
   ~chains: Internal.chains,
 ) => {
   switch item {
@@ -173,7 +168,6 @@ let runHandlerOrThrow = async (
         inMemoryStore,
         loadManager,
         persistence: ctx.persistence,
-        shouldSaveHistory,
         checkpointId,
         isPreload: false,
         chains,
@@ -207,7 +201,6 @@ let runHandlerOrThrow = async (
           ~inMemoryStore,
           ~loadManager,
           ~persistence=ctx.persistence,
-          ~shouldSaveHistory,
           ~chains,
           ~config=ctx.config,
         )
@@ -265,7 +258,6 @@ let preloadBatchOrThrow = async (
                   persistence,
                   checkpointId,
                   isPreload: true,
-                  shouldSaveHistory: false,
                   chains,
                   isResolved: false,
                   config,
@@ -300,7 +292,6 @@ let preloadBatchOrThrow = async (
                   persistence,
                   checkpointId,
                   isPreload: true,
-                  shouldSaveHistory: false,
                   chains,
                   isResolved: false,
                   config,
@@ -325,7 +316,6 @@ let runBatchHandlersOrThrow = async (
   ~inMemoryStore,
   ~loadManager,
   ~ctx,
-  ~shouldSaveHistory,
   ~chains: Internal.chains,
 ) => {
   let itemIdx = ref(0)
@@ -337,15 +327,7 @@ let runBatchHandlersOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
 
-      await runHandlerOrThrow(
-        item,
-        ~checkpointId,
-        ~inMemoryStore,
-        ~loadManager,
-        ~ctx,
-        ~shouldSaveHistory,
-        ~chains,
-      )
+      await runHandlerOrThrow(item, ~checkpointId, ~inMemoryStore, ~loadManager, ~ctx, ~chains)
     }
     itemIdx := itemIdx.contents + checkpointEventsProcessed
   }
@@ -414,22 +396,16 @@ let processEventBatch = async (
     let elapsedTimeAfterLoaders = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
     if batch.items->Utils.Array.notEmpty {
-      await batch->runBatchHandlersOrThrow(
-        ~inMemoryStore,
-        ~loadManager,
-        ~ctx,
-        ~shouldSaveHistory=ctx.config->Config.shouldSaveHistory(~isInReorgThreshold),
-        ~chains,
-      )
+      await batch->runBatchHandlersOrThrow(~inMemoryStore, ~loadManager, ~ctx, ~chains)
     }
 
     let elapsedTimeAfterProcessing = timeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
     try {
-      await ctx.persistence->Persistence.writeBatch(
+      await inMemoryStore->InMemoryStore.writeBatch(
+        ~persistence=ctx.persistence,
         ~batch,
         ~config=ctx.config,
-        ~inMemoryStore,
         ~isInReorgThreshold,
       )
 

package/src/EventProcessing.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Config from "./Config.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
@@ -12,7 +11,7 @@ import * as Persistence from "./Persistence.res.mjs";
 import * as UserContext from "./UserContext.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
-import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -51,7 +50,6 @@ function addItemToRawEvents(eventItem, inMemoryStore, config) {
   let block = event.block;
   let logIndex = event.logIndex;
   let blockNumber = eventItem.blockNumber;
-  let chain = eventItem.chain;
   let eventConfig = eventItem.eventConfig;
   let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
   let blockFields = convertFieldsToJson(block);
@@ -59,13 +57,14 @@ function addItemToRawEvents(eventItem, inMemoryStore, config) {
   config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
   let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
   let params$1 = params === null ? "null" : params;
+  let rawEvent_chain_id = eventItem.chain;
   let rawEvent_event_name = eventConfig.name;
   let rawEvent_contract_name = eventConfig.contractName;
   let rawEvent_src_address = event.srcAddress;
   let rawEvent_block_hash = config.ecosystem.getId(block);
   let rawEvent_block_timestamp = eventItem.timestamp;
   let rawEvent = {
-    chain_id: chain,
+    chain_id: rawEvent_chain_id,
     event_id: eventId,
     event_name: rawEvent_event_name,
     contract_name: rawEvent_contract_name,
@@ -78,16 +77,12 @@ function addItemToRawEvents(eventItem, inMemoryStore, config) {
     transaction_fields: transactionFields,
     params: params$1
   };
-  let eventIdStr = eventId.toString();
-  InMemoryTable.set(inMemoryStore.rawEvents, {
-    chainId: chain,
-    eventId: eventIdStr
-  }, rawEvent);
+  inMemoryStore.rawEvents.push(rawEvent);
 }
 
 let ProcessingError = /* @__PURE__ */Primitive_exceptions.create("EventProcessing.ProcessingError");
 
-async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, persistence, shouldSaveHistory, chains, config) {
+async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, persistence, chains, config) {
   let timeBeforeHandler = Hrtime.makeTimer();
   try {
     let contextParams = {
@@ -97,7 +92,6 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore
       loadManager: loadManager,
       persistence: persistence,
       isPreload: false,
-      shouldSaveHistory: shouldSaveHistory,
       chains: chains,
       config: config,
       isResolved: false
@@ -121,11 +115,11 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore
   return Prometheus.ProcessingHandler.increment(item.eventConfig.contractName, item.eventConfig.name, handlerDuration);
 }
 
-async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains) {
+async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, chains) {
   if (item.kind === 0) {
     let handler = item.eventConfig.handler;
     if (handler !== undefined) {
-      await runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, ctx.persistence, shouldSaveHistory, chains, ctx.config);
+      await runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, ctx.persistence, chains, ctx.config);
     }
     if (ctx.config.enableRawEvents) {
       return addItemToRawEvents(item, inMemoryStore, ctx.config);
@@ -141,7 +135,6 @@ async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager,
       loadManager: loadManager,
       persistence: ctx.persistence,
       isPreload: false,
-      shouldSaveHistory: shouldSaveHistory,
       chains: chains,
       config: ctx.config,
       isResolved: false
@@ -186,7 +179,6 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
                 loadManager: loadManager,
                 persistence: persistence,
                 isPreload: true,
-                shouldSaveHistory: false,
                 chains: chains,
                 config: config,
                 isResolved: false
@@ -205,7 +197,6 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
             loadManager: loadManager,
             persistence: persistence,
             isPreload: true,
-            shouldSaveHistory: false,
             chains: chains,
             config: config,
             isResolved: false
@@ -220,14 +211,14 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
   await Promise.all(promises);
 }
 
-async function runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains) {
+async function runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, chains) {
   let itemIdx = 0;
   for (let checkpointIdx = 0, checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx) {
     let checkpointId = batch.checkpointIds[checkpointIdx];
     let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpointIdx];
     for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
       let item = batch.items[itemIdx + idx | 0];
-      await runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains);
+      await runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, chains);
     }
     itemIdx = itemIdx + checkpointEventsProcessed | 0;
   }
@@ -262,11 +253,11 @@ async function processEventBatch(batch, inMemoryStore, isInReorgThreshold, loadM
     }
     let elapsedTimeAfterLoaders = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, Config.shouldSaveHistory(ctx.config, isInReorgThreshold), chains);
+      await runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, chains);
     }
     let elapsedTimeAfterProcessing = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
     try {
-      await Persistence.writeBatch(ctx.persistence, batch, ctx.config, inMemoryStore, isInReorgThreshold);
+      await InMemoryStore.writeBatch(inMemoryStore, ctx.persistence, batch, ctx.config, isInReorgThreshold);
       let elapsedTimeAfterDbWrite = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
       let handlerDuration = elapsedTimeAfterProcessing - elapsedTimeAfterLoaders;
       let dbWriteDuration = elapsedTimeAfterDbWrite - elapsedTimeAfterProcessing;

package/src/EventUtils.res

@@ -1,21 +1,3 @@
-//Comparator used when ordering multichain events
-let getOrderedBatchItemComparator = (item: Internal.item) => {
-  switch item {
-  | Internal.Event({timestamp, chain, blockNumber, logIndex}) => (
-      timestamp,
-      chain->ChainMap.Chain.toChainId,
-      blockNumber,
-      logIndex,
-    )
-  | Internal.Block(_) =>
-    JsError.throwWithMessage("Block handlers are not supported for ordered multichain mode.")
-  }
-}
-
-let isEarlier = (item1: (int, int, int, int), item2: (int, int, int, int)) => {
-  item1 < item2
-}
-
 let isEarlierUnordered = (item1: (int, int, int), item2: (int, int, int)) => {
   item1 < item2
 }
@@ -74,12 +56,3 @@ let packEventIndex = (~blockNumber, ~logIndex) => {
 // let packEventIndexFromRecord = (eventIndex: eventIndex) => {
 //   packEventIndex(~blockNumber=eventIndex.blockNumber, ~logIndex=eventIndex.logIndex)
 // }
-
-//Returns unique string id for an event using its chain id combined with event id
-//Used in IO for the key in the in mem rawEvents table
-let getEventIdKeyString = (~chainId: int, ~eventId: string) => {
-  let chainIdStr = chainId->Belt.Int.toString
-  let key = chainIdStr ++ "_" ++ eventId
-
-  key
-}

package/src/EventUtils.res.mjs

@@ -1,23 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 
-function getOrderedBatchItemComparator(item) {
-  if (item.kind === 0) {
-    return [
-      item.timestamp,
-      item.chain,
-      item.blockNumber,
-      item.logIndex
-    ];
-  } else {
-    return Stdlib_JsError.throwWithMessage("Block handlers are not supported for ordered multichain mode.");
-  }
-}
-
-let isEarlier = Primitive_object.lessthan;
-
 let isEarlierUnordered = Primitive_object.lessthan;
 
 function packEventIndex(blockNumber, logIndex) {
@@ -27,16 +11,8 @@ function packEventIndex(blockNumber, logIndex) {
   return blockNumber$2 | logIndex$1;
 }
 
-function getEventIdKeyString(chainId, eventId) {
-  let chainIdStr = String(chainId);
-  return chainIdStr + "_" + eventId;
-}
-
 export {
-  getOrderedBatchItemComparator,
-  isEarlier,
   isEarlierUnordered,
   packEventIndex,
-  getEventIdKeyString,
 }
 /* No side effect */