envio 3.1.0-rc.2 → 3.1.1

package/index.d.ts

@@ -1201,6 +1201,18 @@ export type IndexerFromConfig<Config extends IndexerConfigTypes = GlobalConfig>
     readonly name: string;
     /** The indexer description from config.yaml. */
     readonly description: string | undefined;
+    /**
+     * Internal, unstable API that will be removed without notice. Registers a
+     * callback fired once per chain affected by a reorg rollback, after the
+     * rollback is durably written to the database. A throwing callback crashes
+     * the indexer through the same path as a failed write.
+     */
+    readonly "~internalAndWillBeRemovedSoon_onRollbackCommit": (
+      callback: (args: {
+        readonly chainId: number;
+        readonly rollbackToBlock: number;
+      }) => Promise<void>,
+    ) => void;
   } & SingleEcosystemChains<Config>
 >;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.1.0-rc.2",
+  "version": "3.1.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -70,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.1.0-rc.2",
-    "envio-linux-x64-musl": "3.1.0-rc.2",
-    "envio-linux-arm64": "3.1.0-rc.2",
-    "envio-darwin-x64": "3.1.0-rc.2",
-    "envio-darwin-arm64": "3.1.0-rc.2"
+    "envio-linux-x64": "3.1.1",
+    "envio-linux-x64-musl": "3.1.1",
+    "envio-linux-arm64": "3.1.1",
+    "envio-darwin-x64": "3.1.1",
+    "envio-darwin-arm64": "3.1.1"
   }
 }

package/src/GlobalState.res

@@ -1159,6 +1159,7 @@ let injectedTaskReducer = (
           ~persistence=state.ctx.persistence,
           ~rollbackTargetCheckpointId,
           ~rollbackDiffCheckpointId=state.ctx.inMemoryStore.committedCheckpointId->BigInt.add(1n),
+          ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
         )
 
         let chainManager = {

package/src/GlobalState.res.mjs

@@ -1151,7 +1151,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                 };
               });
               await InMemoryStore.flush(state.ctx.inMemoryStore);
-              let diff$1 = await InMemoryStore.prepareRollbackDiff(state.ctx.inMemoryStore, state.ctx.persistence, rollbackTargetCheckpointId, state.ctx.inMemoryStore.committedCheckpointId + 1n);
+              let diff$1 = await InMemoryStore.prepareRollbackDiff(state.ctx.inMemoryStore, state.ctx.persistence, rollbackTargetCheckpointId, state.ctx.inMemoryStore.committedCheckpointId + 1n, newProgressBlockNumberPerChain);
               let init = state.chainManager;
               let chainManager_isInReorgThreshold = init.isInReorgThreshold;
               let chainManager_isRealtime = init.isRealtime;

package/src/InMemoryStore.res

@@ -124,10 +124,19 @@ let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
   }
 }
 
-let getEffectOutput = (inMemTable: effectCacheInMemTable, key) =>
+let hasEffectOutput = (inMemTable: effectCacheInMemTable, key) =>
   switch inMemTable.dict->Utils.Dict.dangerouslyGetNonOption(key) {
-  | Some(Set({entity: output})) => Some(output)
-  | Some(Delete(_)) | None => None
+  | Some(Set(_)) => true
+  | Some(Delete(_)) | None => false
+  }
+
+// Returns the raw output. The output is itself an option for effects with an
+// optional output, so it must never be wrapped in another option here: Some(None)
+// is encoded as the nested-option sentinel and would leak to the handler.
+let getEffectOutputUnsafe = (inMemTable: effectCacheInMemTable, key): Internal.effectOutput =>
+  switch inMemTable.dict->Utils.Dict.dangerouslyGetNonOption(key) {
+  | Some(Set({entity: output})) => output
+  | Some(Delete(_)) | None => %raw(`undefined`)
   }
 
 // Records a handler output. Persisted on the next write only when shouldCache;
@@ -359,6 +368,12 @@ let runOneWrite = async (inMemoryStore: t, ~persistence: Persistence.t, ~config)
     )
 
     inMemoryStore.committedCheckpointId = upToCheckpointId
+
+    switch rollback {
+    | Some({progressBlockNumberByChainId}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
+      await RollbackCommit.fire(~progressBlockNumberByChainId)
+    | _ => ()
+    }
   }
 }
 
@@ -494,12 +509,14 @@ let prepareRollbackDiff = async (
   ~persistence: Persistence.t,
   ~rollbackTargetCheckpointId,
   ~rollbackDiffCheckpointId,
+  ~progressBlockNumberByChainId,
 ) => {
   inMemoryStore.entities = EntityTables.make(inMemoryStore.allEntities)
   inMemoryStore.effects = Dict.make()
   inMemoryStore.rollback = Some({
     targetCheckpointId: rollbackTargetCheckpointId,
     diffCheckpointId: rollbackDiffCheckpointId,
+    progressBlockNumberByChainId,
   })
 
   let deletedEntities = Dict.make()

package/src/InMemoryStore.res.mjs

@@ -11,6 +11,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -89,11 +90,21 @@ function getEffectInMemTable(inMemoryStore, effect) {
   return table$1;
 }
 
-function getEffectOutput(inMemTable, key) {
+function hasEffectOutput(inMemTable, key) {
+  let match = inMemTable.dict[key];
+  if (match !== undefined) {
+    return match.type === "SET";
+  } else {
+    return false;
+  }
+}
+
+function getEffectOutputUnsafe(inMemTable, key) {
   let match = inMemTable.dict[key];
   if (match !== undefined && match.type === "SET") {
-    return Primitive_option.some(match.entity);
+    return match.entity;
   }
+  return undefined;
 }
 
 function setEffectOutput(inMemTable, checkpointId, cacheKey, output, shouldCache) {
@@ -300,6 +311,9 @@ async function runOneWrite(inMemoryStore, persistence, config) {
   let updatedEffectsCache = snapshotEffects(inMemoryStore, cache);
   await persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData);
   inMemoryStore.committedCheckpointId = upToCheckpointId;
+  if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
+    return await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
+  }
 }
 
 function hasPendingWrite(inMemoryStore) {
@@ -401,12 +415,13 @@ async function flush(inMemoryStore) {
   }
 }
 
-async function prepareRollbackDiff(inMemoryStore, persistence, rollbackTargetCheckpointId, rollbackDiffCheckpointId) {
+async function prepareRollbackDiff(inMemoryStore, persistence, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId) {
   inMemoryStore.entities = make(inMemoryStore.allEntities);
   inMemoryStore.effects = {};
   inMemoryStore.rollback = {
     targetCheckpointId: rollbackTargetCheckpointId,
-    diffCheckpointId: rollbackDiffCheckpointId
+    diffCheckpointId: rollbackDiffCheckpointId,
+    progressBlockNumberByChainId: progressBlockNumberByChainId
   };
   let deletedEntities = {};
   let setEntities = {};
@@ -482,7 +497,8 @@ export {
   make$1 as make,
   keepLatestChangesLimit,
   getEffectInMemTable,
-  getEffectOutput,
+  hasEffectOutput,
+  getEffectOutputUnsafe,
   setEffectOutput,
   initEffectOutputFromDb,
   dropCommittedEffects,

package/src/LoadLayer.res

@@ -336,8 +336,8 @@ let loadEffect = (
     ~load,
     ~shouldGroup,
     ~hasher=args => args.cacheKey,
-    ~getUnsafeInMemory=hash => inMemTable->InMemoryStore.getEffectOutput(hash)->Option.getUnsafe,
-    ~hasInMemory=hash => inMemTable->InMemoryStore.getEffectOutput(hash)->Option.isSome,
+    ~getUnsafeInMemory=hash => inMemTable->InMemoryStore.getEffectOutputUnsafe(hash),
+    ~hasInMemory=hash => inMemTable->InMemoryStore.hasEffectOutput(hash),
     ~input=effectArgs,
   )
 }

package/src/LoadLayer.res.mjs

@@ -12,7 +12,6 @@ import * as TableIndices from "./TableIndices.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -187,7 +186,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, inMemoryStore,
       return await executeWithRateLimit(effect, argsToCall, inMemTable, onError, false);
     }
   };
-  return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => Stdlib_Option.isSome(InMemoryStore.getEffectOutput(inMemTable, hash)), hash => InMemoryStore.getEffectOutput(inMemTable, hash));
+  return LoadManager.call(loadManager, effectArgs, key, load, args => args.cacheKey, shouldGroup, hash => InMemoryStore.hasEffectOutput(inMemTable, hash), hash => InMemoryStore.getEffectOutputUnsafe(inMemTable, hash));
 }
 
 function loadByField(loadManager, persistence, operator, entityConfig, inMemoryStore, fieldName, fieldValueSchema, shouldGroup, item, fieldValue) {

package/src/Main.res

@@ -312,6 +312,13 @@ let getGlobalIndexer = (): 'indexer => {
     )
   }
 
+  let onRollbackCommitFn = (callback: 'a) => {
+    HandlerRegister.throwIfFinishedRegistration(
+      ~methodName="~internalAndWillBeRemovedSoon_onRollbackCommit",
+    )
+    let _ = RollbackCommit.register(callback->(Utils.magic: 'a => RollbackCommit.callback))
+  }
+
   // Two-stage parse: first the ecosystem-specific outer schema unwraps the
   // wrapper (`block.number` / `block.height` / `slot`) and surfaces the
   // inner chunk as raw `unknown`; then the shared `blockRangeSchema`
@@ -453,8 +460,16 @@ let getGlobalIndexer = (): 'indexer => {
             "onEvent",
             "contractRegister",
             "onBlock",
+            "~internalAndWillBeRemovedSoon_onRollbackCommit",
+          ]
+        | Svm => [
+            "name",
+            "description",
+            "chainIds",
+            "chains",
+            "onSlot",
+            "~internalAndWillBeRemovedSoon_onRollbackCommit",
           ]
-        | Svm => ["name", "description", "chainIds", "chains", "onSlot"]
         }
         keysMemo := Some(keys)
         keys
@@ -477,6 +492,7 @@ let getGlobalIndexer = (): 'indexer => {
     | "onEvent" => onEventFn->Utils.magic
     | "contractRegister" => contractRegisterFn->Utils.magic
     | "onBlock" | "onSlot" => onBlockFn->Utils.magic
+    | "~internalAndWillBeRemovedSoon_onRollbackCommit" => onRollbackCommitFn->Utils.magic
     | _ =>
       JsError.throwWithMessage(
         `Field \`${prop}\` does not exist on \`indexer\`. Available fields: ${getKeys()->Array.join(

package/src/Main.res.mjs

@@ -25,6 +25,7 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Helpers from "yargs/helpers";
+import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -255,6 +256,10 @@ function getGlobalIndexer() {
     let match = parseIdentityConfig(identityConfig);
     HandlerRegister.setContractRegister(match[0], match[1], handler, match[2], undefined);
   };
+  let onRollbackCommitFn = callback => {
+    HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
+    RollbackCommit.register(callback);
+  };
   let extractRange = (filter, name, ecosystem) => {
     try {
       let inner = S$RescriptSchema.parseOrThrow(filter, ecosystem.onBlockFilterSchema);
@@ -341,7 +346,8 @@ function getGlobalIndexer() {
           "description",
           "chainIds",
           "chains",
-          "onSlot"
+          "onSlot",
+          "~internalAndWillBeRemovedSoon_onRollbackCommit"
         ];
         break;
     }
@@ -353,7 +359,8 @@ function getGlobalIndexer() {
         "chains",
         "onEvent",
         "contractRegister",
-        "onBlock"
+        "onBlock",
+        "~internalAndWillBeRemovedSoon_onRollbackCommit"
       ];
     }
     keysMemo.contents = keys;
@@ -376,6 +383,8 @@ function getGlobalIndexer() {
       case "onBlock" :
       case "onSlot" :
         return onBlockFn;
+      case "~internalAndWillBeRemovedSoon_onRollbackCommit" :
+        return onRollbackCommitFn;
       default:
         return Stdlib_JsError.throwWithMessage(`Field \`` + prop + `\` does not exist on \`indexer\`. Available fields: ` + getKeys().join(", ") + `.`);
     }

package/src/Persistence.res

@@ -51,6 +51,9 @@ type updatedEffectCache = {
 type rollback = {
   targetCheckpointId: Internal.checkpointId,
   diffCheckpointId: Internal.checkpointId,
+  // Last valid block per chain affected by the rollback. Read by
+  // `RollbackCommit.fire` once the diff is durably written.
+  progressBlockNumberByChainId: dict<int>,
 }
 
 type updatedEntity = {

package/src/RollbackCommit.res

@@ -0,0 +1,32 @@
+// Temporary, internal-only support for the unstable
+// `indexer.~internalAndWillBeRemovedSoon_onRollbackCommit` API. The whole
+// feature lives here plus two call sites: registration in `Main.res` and the
+// fire on a successful rollback write in `InMemoryStore.res`. Delete those
+// together with this module.
+type args = {chainId: int, rollbackToBlock: int}
+type callback = args => promise<unit>
+
+let callbacks: array<callback> = []
+
+let register = (callback: callback) => {
+  callbacks->Array.push(callback)
+  () =>
+    switch callbacks->Array.indexOf(callback) {
+    | -1 => ()
+    | index => callbacks->Array.splice(~start=index, ~remove=1, ~insert=[])
+    }
+}
+
+// Fired after a rollback diff is durably written, once per affected chain.
+// `progressBlockNumberByChainId` is the last valid block per chain, taken from
+// the in-memory store's rollback object. A throwing callback bubbles to the
+// write loop's onError, crashing the indexer like a failed write.
+let fire = async (~progressBlockNumberByChainId: dict<int>) => {
+  let _ = await progressBlockNumberByChainId
+  ->Dict.toArray
+  ->Array.flatMap(((chainIdKey, rollbackToBlock)) => {
+    let args = {chainId: chainIdKey->Int.fromString->Option.getUnsafe, rollbackToBlock}
+    callbacks->Array.map(callback => callback(args))
+  })
+  ->Promise.all
+}

package/src/RollbackCommit.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+
+let callbacks = [];
+
+function register(callback) {
+  callbacks.push(callback);
+  return () => {
+    let index = callbacks.indexOf(callback);
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+      return;
+    }
+  };
+}
+
+async function fire(progressBlockNumberByChainId) {
+  await Promise.all(Object.entries(progressBlockNumberByChainId).flatMap(param => {
+    let args_chainId = Stdlib_Int.fromString(param[0], undefined);
+    let args_rollbackToBlock = param[1];
+    let args = {
+      chainId: args_chainId,
+      rollbackToBlock: args_rollbackToBlock
+    };
+    return callbacks.map(callback => callback(args));
+  }));
+}
+
+export {
+  callbacks,
+  register,
+  fire,
+}
+/* No side effect */

package/src/sources/EvmChain.res

@@ -41,25 +41,18 @@ let getSyncConfig = (
 let collectEventParams = (contracts: array<Internal.evmContractConfig>): array<
   HyperSyncClient.Decoder.eventParamsInput,
 > => {
-  let seen = Dict.make()
   let result = []
   contracts->Array.forEach(contract => {
     contract.events->Array.forEach(event => {
-      let key = event.sighash ++ "_" ++ event.topicCount->Int.toString
-      switch seen->Dict.get(key) {
-      | Some(_) => ()
-      | None => {
-          seen->Dict.set(key, true)
-          result
-          ->Array.push({
-            HyperSyncClient.Decoder.sighash: event.sighash,
-            topicCount: event.topicCount,
-            eventName: event.name,
-            params: event.paramsMetadata,
-          })
-          ->ignore
-        }
-      }
+      result
+      ->Array.push({
+        HyperSyncClient.Decoder.sighash: event.sighash,
+        topicCount: event.topicCount,
+        eventName: event.name,
+        contractName: contract.name,
+        params: event.paramsMetadata,
+      })
+      ->ignore
     })
   })
   result

package/src/sources/EvmChain.res.mjs

@@ -22,24 +22,16 @@ function getSyncConfig(param) {
 }
 
 function collectEventParams(contracts) {
-  let seen = {};
   let result = [];
   contracts.forEach(contract => {
     contract.events.forEach(event => {
-      let key = event.sighash + "_" + event.topicCount.toString();
-      let match = seen[key];
-      if (match !== undefined) {
-        return;
-      } else {
-        seen[key] = true;
-        result.push({
-          sighash: event.sighash,
-          topicCount: event.topicCount,
-          eventName: event.name,
-          params: event.paramsMetadata
-        });
-        return;
-      }
+      result.push({
+        sighash: event.sighash,
+        topicCount: event.topicCount,
+        eventName: event.name,
+        contractName: contract.name,
+        params: event.paramsMetadata
+      });
     });
   });
   return result;

package/src/sources/HyperSyncClient.res

@@ -322,11 +322,17 @@ module Decoder = {
     sighash: string,
     topicCount: int,
     eventName: string,
+    contractName: string,
     params: array<Internal.paramMeta>,
   }
 
+  // Decoded params keyed by contract name. Contracts that emit the same-signature
+  // event share one decode but get their own param names, so the caller picks the
+  // entry for the contract its router resolved the log to.
   type tWithParams = {
-    decodeLogs: array<ResponseTypes.event> => promise<array<Nullable.t<Internal.eventParams>>>,
+    decodeLogs: array<ResponseTypes.event> => promise<
+      array<Nullable.t<dict<Internal.eventParams>>>,
+    >,
   }
 
   @send
@@ -348,7 +354,7 @@ module EventItems = {
     topicCount: int,
     block: ResponseTypes.block,
     transaction: ResponseTypes.transaction,
-    params: Nullable.t<Internal.eventParams>,
+    params: Nullable.t<dict<Internal.eventParams>>,
   }
 
   type response = {

package/src/sources/HyperSyncSource.res

@@ -351,20 +351,23 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
           ~blockNumber=item.block.number->Belt.Option.getUnsafe,
         )
 
-      switch (maybeEventConfig, item.params) {
-      | (Some(eventConfig), Value(decoded)) =>
-        parsedQueueItems
-        ->Array.push(makeEventBatchQueueItem(item, ~params=decoded, ~eventConfig))
-        ->ignore
-      | (Some(eventConfig), Null | Undefined) =>
-        handleDecodeFailure(
-          ~eventConfig,
-          ~logIndex=item.logIndex,
-          ~blockNumber=item.block.number->Belt.Option.getUnsafe,
-          ~chainId,
-          ~exn=UndefinedValue,
-        )
-      | (None, _) => () //ignore events that aren't registered
+      switch maybeEventConfig {
+      | None => () //ignore events that aren't registered
+      | Some(eventConfig) =>
+        switch item.params
+        ->Nullable.toOption
+        ->Option.flatMap(Dict.get(_, eventConfig.contractName)) {
+        | Some(params) =>
+          parsedQueueItems->Array.push(makeEventBatchQueueItem(item, ~params, ~eventConfig))->ignore
+        | None =>
+          handleDecodeFailure(
+            ~eventConfig,
+            ~logIndex=item.logIndex,
+            ~blockNumber=item.block.number->Belt.Option.getUnsafe,
+            ~chainId,
+            ~exn=UndefinedValue,
+          )
+        }
       }
     })
 

package/src/sources/HyperSyncSource.res.mjs

@@ -14,6 +14,7 @@ import * as ErrorHandling from "../ErrorHandling.res.mjs";
 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 "./HyperSyncClient.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as HyperSyncHeightStream from "./HyperSyncHeightStream.res.mjs";
 
@@ -215,32 +216,31 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     let parsedQueueItems = [];
     Belt_Array.forEach(pageUnsafe.items, item => {
       let maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(item.topic0, item.topicCount), item.srcAddress, item.block.number, indexingAddresses);
-      let match = item.params;
       if (maybeEventConfig === undefined) {
         return;
       }
-      if (match == null) {
-        match === null;
-      } else {
-        parsedQueueItems.push(makeEventBatchQueueItem(item, match, maybeEventConfig));
-        return;
-      }
-      let logIndex = item.logIndex;
-      let blockNumber = item.block.number;
-      let exn = {
-        RE_EXN_ID: UndefinedValue
-      };
-      if (maybeEventConfig.isWildcard) {
+      let params = Stdlib_Option.flatMap(Primitive_option.fromNullable(item.params), __x => __x[maybeEventConfig.contractName]);
+      if (params !== undefined) {
+        parsedQueueItems.push(makeEventBatchQueueItem(item, Primitive_option.valFromOption(params), maybeEventConfig));
         return;
+      } else {
+        let logIndex = item.logIndex;
+        let blockNumber = item.block.number;
+        let exn = {
+          RE_EXN_ID: UndefinedValue
+        };
+        if (maybeEventConfig.isWildcard) {
+          return;
+        }
+        let msg = `Event ` + maybeEventConfig.name + ` was unexpectedly parsed as undefined`;
+        let logger$1 = Logging.createChildFrom(logger, {
+          chainId: chain,
+          blockNumber: blockNumber,
+          logIndex: logIndex,
+          decoder: "hypersync-client"
+        });
+        return ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
       }
-      let msg = `Event ` + maybeEventConfig.name + ` was unexpectedly parsed as undefined`;
-      let logger$1 = Logging.createChildFrom(logger, {
-        chainId: chain,
-        blockNumber: blockNumber,
-        logIndex: logIndex,
-        decoder: "hypersync-client"
-      });
-      ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
     });
     let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
     let blockHashes = [];

package/src/sources/RpcSource.res

@@ -1115,7 +1115,7 @@ let make = (
     ->Array.zip(parsedEvents)
     ->Array.filterMap(((
       log: Rpc.GetLogs.log,
-      maybeDecodedEvent: Nullable.t<Internal.eventParams>,
+      maybeDecodedEvent: Nullable.t<dict<Internal.eventParams>>,
     )) => {
       let topic0 = log.topics[0]->Option.getOr("0x0")
       let routedAddress = if lowercaseAddresses {
@@ -1132,8 +1132,10 @@ let make = (
       ) {
       | None => None
       | Some(eventConfig) =>
-        switch maybeDecodedEvent {
-        | Value(decoded) =>
+        switch maybeDecodedEvent
+        ->Nullable.toOption
+        ->Option.flatMap(Dict.get(_, eventConfig.contractName)) {
+        | Some(decoded) =>
           Some(
             (
               async () => {
@@ -1176,7 +1178,7 @@ let make = (
               }
             )(),
           )
-        | Null | Undefined => None
+        | None => None
         }
       }
     })

package/src/sources/RpcSource.res.mjs

@@ -1064,54 +1064,59 @@ function make(param) {
       };
     }
     let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(Stdlib_Array.zip(logs, parsedEvents), param => {
-      let maybeDecodedEvent = param[1];
       let log = param[0];
       let topic0 = Stdlib_Option.getOr(log.topics[0], "0x0");
       let routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : Address.Evm.fromAddressOrThrow(log.address);
       let eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, log.blockNumber, indexingAddresses);
-      if (eventConfig !== undefined && maybeDecodedEvent !== null && maybeDecodedEvent !== undefined) {
-        return (async () => {
-          let match;
-          try {
-            match = await Promise.all([
-              getEventBlockOrThrow(log, eventConfig.selectedBlockFields),
-              getEventTransactionOrThrow(log, eventConfig.selectedTransactionFields)
-            ]);
-          } catch (raw_exn) {
-            let exn = Primitive_exceptions.internalToException(raw_exn);
-            throw {
-              RE_EXN_ID: Source.GetItemsError,
-              _1: {
-                TAG: "FailedGettingFieldSelection",
-                exn: exn,
-                blockNumber: log.blockNumber,
-                logIndex: log.logIndex,
-                message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
-              },
-              Error: new Error()
-            };
-          }
-          let block = match[0];
-          return {
-            kind: 0,
-            eventConfig: eventConfig,
-            timestamp: block.timestamp,
-            chain: chain,
-            blockNumber: block.number,
-            logIndex: log.logIndex,
-            event: {
-              contractName: eventConfig.contractName,
-              eventName: eventConfig.name,
-              params: maybeDecodedEvent,
-              chainId: chain,
-              srcAddress: routedAddress,
+      if (eventConfig === undefined) {
+        return;
+      }
+      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param[1]), __x => __x[eventConfig.contractName]);
+      if (decoded === undefined) {
+        return;
+      }
+      let decoded$1 = Primitive_option.valFromOption(decoded);
+      return (async () => {
+        let match;
+        try {
+          match = await Promise.all([
+            getEventBlockOrThrow(log, eventConfig.selectedBlockFields),
+            getEventTransactionOrThrow(log, eventConfig.selectedTransactionFields)
+          ]);
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          throw {
+            RE_EXN_ID: Source.GetItemsError,
+            _1: {
+              TAG: "FailedGettingFieldSelection",
+              exn: exn,
+              blockNumber: log.blockNumber,
               logIndex: log.logIndex,
-              transaction: match[1],
-              block: block
-            }
+              message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
+            },
+            Error: new Error()
           };
-        })();
-      }
+        }
+        let block = match[0];
+        return {
+          kind: 0,
+          eventConfig: eventConfig,
+          timestamp: block.timestamp,
+          chain: chain,
+          blockNumber: block.number,
+          logIndex: log.logIndex,
+          event: {
+            contractName: eventConfig.contractName,
+            eventName: eventConfig.name,
+            params: decoded$1,
+            chainId: chain,
+            srcAddress: routedAddress,
+            logIndex: log.logIndex,
+            transaction: match[1],
+            block: block
+          }
+        };
+      })();
     }));
     let optFirstBlockParent = await firstBlockParentPromise;
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));