envio 3.2.1 → 3.3.0-alpha.1

package/src/Rollback.res

@@ -0,0 +1,204 @@
+// The reorg rollback state machine. Re-enters fetch/process/rollback through
+// the injected schedule* effects.
+
+/**
+Finds the last known valid block number below the reorg block
+If not found, returns the highest block below threshold
+*/
+let getLastKnownValidBlock = async (
+  chainState: ChainState.t,
+  ~reorgBlockNumber: int,
+  ~isRealtime: bool,
+) => {
+  // Don't include the reorg block itself — different source instances
+  // may have mismatching hashes at the head, so we always rollback
+  // the block where we detected the reorg.
+  let scannedBlockNumbers =
+    chainState
+    ->ChainState.reorgDetection
+    ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
+      ~blockNumber=reorgBlockNumber,
+      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+    )
+
+  switch scannedBlockNumbers {
+  | [] => chainState->ChainState.getHighestBlockBelowThreshold
+  | _ => {
+      let blockNumbersAndHashes = await chainState
+      ->ChainState.sourceManager
+      ->SourceManager.getBlockHashes(~blockNumbers=scannedBlockNumbers, ~isRealtime)
+
+      switch chainState
+      ->ChainState.reorgDetection
+      ->ReorgDetection.getLatestValidScannedBlock(~blockNumbersAndHashes) {
+      | Some(blockNumber) => blockNumber
+      | None => chainState->ChainState.getHighestBlockBelowThreshold
+      }
+    }
+  }
+}
+
+let rec rollback = async (
+  state: IndexerState.t,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+  ~scheduleRollback,
+) =>
+  // Owns its error boundary: launch doesn't catch, so a failure mid-rollback
+  // must stop the indexer.
+  try {
+    switch state->IndexerState.rollbackState {
+    | NoRollback | RollbackReady(_) =>
+      JsError.throwWithMessage("Internal error: Rollback initiated with invalid state")
+    | ReorgDetected({chain, blockNumber: reorgBlockNumber}) =>
+      let chainState = state->IndexerState.getChainState(~chain)
+
+      state->IndexerState.enterFindingReorgDepth
+      let rollbackTargetBlockNumber = await chainState->getLastKnownValidBlock(
+        ~reorgBlockNumber,
+        ~isRealtime=state->IndexerState.isRealtime,
+      )
+
+      chainState
+      ->ChainState.sourceManager
+      ->SourceManager.onReorg(~rollbackTargetBlock=rollbackTargetBlockNumber)
+
+      state->IndexerState.foundReorgDepth(~chain, ~rollbackTargetBlockNumber)
+      // Rendezvous with the processing loop: whichever of {depth found, loop
+      // idle} happens last triggers the rollback; the earlier one finds the
+      // other condition unmet and bails here.
+      scheduleRollback()
+    // Reached when a batch finished (loop idle) while the reorg depth wasn't
+    // found yet. Wait for the ReorgDetected branch above to find it and re-kick.
+    | FindingReorgDepth => ()
+    | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
+      Logging.info("Waiting for batch to finish processing before executing rollback")
+    | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
+      await executeRollback(
+        state,
+        ~reorgChain,
+        ~rollbackTargetBlockNumber,
+        ~scheduleFetch,
+        ~scheduleProcessing,
+      )
+    }
+  } catch {
+  | exn =>
+    IndexerState.errorExit(state, exn->ErrorHandling.make(~msg=IndexerState.unexpectedErrorMsg))
+  }
+
+and executeRollback = async (
+  state: IndexerState.t,
+  ~reorgChain,
+  ~rollbackTargetBlockNumber,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+) => {
+  let startTime = Hrtime.makeTimer()
+
+  let chainState = state->IndexerState.getChainState(~chain=reorgChain)
+
+  let logger = Logging.createChildFrom(
+    ~logger=chainState->ChainState.logger,
+    ~params={
+      "action": "Rollback",
+      "reorgChain": reorgChain,
+      "targetBlockNumber": rollbackTargetBlockNumber,
+    },
+  )
+  logger->Logging.childInfo("Started rollback on reorg")
+  Prometheus.RollbackTargetBlockNumber.set(
+    ~blockNumber=rollbackTargetBlockNumber,
+    ~chain=reorgChain,
+  )
+
+  let reorgChainId = reorgChain->ChainMap.Chain.toChainId
+
+  // Finish pending batch writes first: the target checkpoint, the progress
+  // diff and the rollback diff below must all be computed from the same db
+  // state. Otherwise an in-flight batch lands after the progress reads and
+  // its entity changes get reverted without the chain progress being
+  // rolled back, so the events are never reprocessed.
+  await state->Writing.flush
+
+  let rollbackTargetCheckpointId = {
+    switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
+      ~reorgChainId,
+      ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
+    ) {
+    | Some(checkpointId) => checkpointId
+    | None => 0n
+    }
+  }
+
+  let eventsProcessedDiffByChain = Dict.make()
+  let newProgressBlockNumberPerChain = Dict.make()
+  let rollbackedProcessedEvents = ref(0.)
+
+  {
+    let rollbackProgressDiff = await (
+      state->IndexerState.persistence
+    ).storage.getRollbackProgressDiff(~rollbackTargetCheckpointId)
+    for idx in 0 to rollbackProgressDiff->Array.length - 1 {
+      let diff = rollbackProgressDiff->Array.getUnsafe(idx)
+      eventsProcessedDiffByChain->Utils.Dict.setByInt(
+        diff["chain_id"],
+        {
+          let eventsProcessedDiff =
+            Float.fromString(diff["events_processed_diff"])->Option.getOrThrow
+          rollbackedProcessedEvents := rollbackedProcessedEvents.contents +. eventsProcessedDiff
+          eventsProcessedDiff
+        },
+      )
+      newProgressBlockNumberPerChain->Utils.Dict.setByInt(
+        diff["chain_id"],
+        if rollbackTargetCheckpointId === 0n && diff["chain_id"] === reorgChainId {
+          Pervasives.min(diff["new_progress_block_number"], rollbackTargetBlockNumber)
+        } else {
+          diff["new_progress_block_number"]
+        },
+      )
+    }
+  }
+
+  state
+  ->IndexerState.chainStates
+  ->Utils.Dict.forEach(cs => {
+    let chainId = (cs->ChainState.chainConfig).id
+    cs->ChainState.rollback(
+      ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
+        chainId,
+      ),
+      ~eventsProcessedDiff=eventsProcessedDiffByChain->Utils.Dict.dangerouslyGetByIntNonOption(
+        chainId,
+      ),
+      ~rollbackTargetBlockNumber,
+      ~isReorgChain=chainId === reorgChainId,
+    )
+  })
+
+  let diff = await state->InMemoryStore.prepareRollbackDiff(
+    ~rollbackTargetCheckpointId,
+    ~rollbackDiffCheckpointId=state->IndexerState.committedCheckpointId->BigInt.add(1n),
+    ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
+  )
+
+  logger->Logging.childTrace({
+    "msg": "Finished rollback on reorg",
+    "entityChanges": {
+      "deleted": diff["deletedEntities"],
+      "upserted": diff["setEntities"],
+    },
+    "rollbackedEvents": rollbackedProcessedEvents.contents,
+    "beforeCheckpointId": state->IndexerState.committedCheckpointId,
+    "targetCheckpointId": rollbackTargetCheckpointId,
+  })
+  Prometheus.RollbackSuccess.increment(
+    ~timeSeconds=Hrtime.timeSince(startTime)->Hrtime.toSecondsFloat,
+    ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
+  )
+
+  state->IndexerState.completeRollback(~eventsProcessedDiffByChain)
+  scheduleFetch()
+  scheduleProcessing()
+}

package/src/Rollback.res.mjs

@@ -0,0 +1,118 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Hrtime from "./bindings/Hrtime.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Writing from "./Writing.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+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 ReorgDetection from "./ReorgDetection.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime) {
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.fetchState(chainState).knownHeight);
+  if (scannedBlockNumbers.length === 0) {
+    return ChainState.getHighestBlockBelowThreshold(chainState);
+  }
+  let blockNumbersAndHashes = await SourceManager.getBlockHashes(ChainState.sourceManager(chainState), scannedBlockNumbers, isRealtime);
+  let blockNumber = ReorgDetection.getLatestValidScannedBlock(ChainState.reorgDetection(chainState), blockNumbersAndHashes);
+  if (blockNumber !== undefined) {
+    return blockNumber;
+  } else {
+    return ChainState.getHighestBlockBelowThreshold(chainState);
+  }
+}
+
+async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
+  let startTime = Hrtime.makeTimer();
+  let chainState = IndexerState.getChainState(state, reorgChain);
+  let logger = Logging.createChildFrom(ChainState.logger(chainState), {
+    action: "Rollback",
+    reorgChain: reorgChain,
+    targetBlockNumber: rollbackTargetBlockNumber
+  });
+  Logging.childInfo(logger, "Started rollback on reorg");
+  Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber, reorgChain);
+  await Writing.flush(state);
+  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
+  let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
+  let eventsProcessedDiffByChain = {};
+  let newProgressBlockNumberPerChain = {};
+  let rollbackedProcessedEvents = 0;
+  let rollbackProgressDiff = await IndexerState.persistence(state).storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+  for (let idx = 0, idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx) {
+    let diff = rollbackProgressDiff[idx];
+    let eventsProcessedDiff = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
+    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
+    eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
+    newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
+  }
+  Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
+    let chainId = ChainState.chainConfig(cs).id;
+    ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+  });
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  Logging.childTrace(logger, {
+    msg: "Finished rollback on reorg",
+    entityChanges: {
+      deleted: diff$1.deletedEntities,
+      upserted: diff$1.setEntities
+    },
+    rollbackedEvents: rollbackedProcessedEvents,
+    beforeCheckpointId: IndexerState.committedCheckpointId(state),
+    targetCheckpointId: rollbackTargetCheckpointId
+  });
+  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+  IndexerState.completeRollback(state, eventsProcessedDiffByChain);
+  scheduleFetch();
+  return scheduleProcessing();
+}
+
+async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollback) {
+  try {
+    let match = IndexerState.rollbackState(state);
+    if (typeof match !== "object") {
+      if (match === "NoRollback") {
+        return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+      } else {
+        return;
+      }
+    }
+    switch (match.TAG) {
+      case "ReorgDetected" :
+        let chain = match.chain;
+        let chainState = IndexerState.getChainState(state, chain);
+        IndexerState.enterFindingReorgDepth(state);
+        let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainState, match.blockNumber, IndexerState.isRealtime(state));
+        SourceManager.onReorg(ChainState.sourceManager(chainState), rollbackTargetBlockNumber);
+        IndexerState.foundReorgDepth(state, chain, rollbackTargetBlockNumber);
+        return scheduleRollback();
+      case "FoundReorgDepth" :
+        if (IndexerState.isProcessing(state)) {
+          return Logging.info("Waiting for batch to finish processing before executing rollback");
+        } else {
+          return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
+        }
+      case "RollbackReady" :
+        return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+    }
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, IndexerState.unexpectedErrorMsg));
+  }
+}
+
+export {
+  getLastKnownValidBlock,
+  rollback,
+  executeRollback,
+}
+/* Utils Not a pure module */

package/src/SimulateItems.res

@@ -288,16 +288,18 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
           blockNumber,
           blockHash,
           logIndex,
-          event: {
-            contractName: eventConfig.contractName,
-            eventName: eventConfig.name,
-            params,
-            chainId,
-            srcAddress,
-            logIndex,
-            transaction,
-            block,
-          }->Internal.fromGenericEvent,
+          payload: (
+            {
+              contractName: eventConfig.contractName,
+              eventName: eventConfig.name,
+              params,
+              chainId,
+              srcAddress,
+              logIndex,
+              transaction,
+              block,
+            }: Evm.payload
+          )->Evm.fromPayload,
         }),
       )
       ->ignore

package/src/SimulateItems.res.mjs

@@ -241,7 +241,7 @@ function parse(simulateItems, config, chainConfig) {
       blockNumber: blockNumber,
       blockHash: match$3[3],
       logIndex: logIndex,
-      event: {
+      payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
         params: params,

package/src/UserContext.res

@@ -1,7 +1,7 @@
 type contextParams = {
   item: Internal.item,
   checkpointId: Internal.checkpointId,
-  inMemoryStore: InMemoryStore.t,
+  indexerState: IndexerState.t,
   loadManager: LoadManager.t,
   persistence: Persistence.t,
   isPreload: bool,
@@ -22,7 +22,8 @@ Utils.Object.defineProperty(
   {
     // Wrap with toMethod so `this` binds to the EffectContext instance.
     get: Utils.toMethod(() => {
-      (paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))).item->Logging.getUserLogger
+      let params = paramsByThis->Utils.WeakMap.unsafeGet(%raw(`this`))
+      Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
     }),
   },
 )
@@ -60,9 +61,10 @@ let initEffect = (params: contextParams) => {
       ~persistence=params.persistence,
       ~effect,
       ~effectArgs,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
     )
   }
   callEffect
@@ -82,9 +84,10 @@ let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>)
       ~loadManager=params.loadManager,
       ~persistence=params.persistence,
       ~entityConfig,
-      ~inMemoryStore=params.inMemoryStore,
+      ~indexerState=params.indexerState,
       ~shouldGroup=params.isPreload,
       ~item=params.item,
+      ~ecosystem=params.config.ecosystem,
       ~filter,
     )
 
@@ -121,10 +124,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
     let set = params.isPreload
       ? noopSet
       : (entity: Internal.entity) => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Set({
               entityId: entity.id,
               checkpointId: params.checkpointId,
@@ -146,9 +149,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )
         )->(Utils.magic: (string => promise<option<Internal.entity>>) => unknown)
@@ -177,9 +181,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId,
             )->Promise.thenResolve(entity => {
               switch entity {
@@ -206,9 +211,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
               ~loadManager=params.loadManager,
               ~persistence=params.persistence,
               ~entityConfig=params.entityConfig,
-              ~inMemoryStore=params.inMemoryStore,
+              ~indexerState=params.indexerState,
               ~shouldGroup=params.isPreload,
               ~item=params.item,
+              ~ecosystem=params.config.ecosystem,
               ~entityId=entity.id,
             )->Promise.thenResolve(storageEntity => {
               switch storageEntity {
@@ -227,10 +233,10 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
         noopDeleteUnsafe
       } else {
         entityId => {
-          params.inMemoryStore
+          params.indexerState
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
+            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,
@@ -250,13 +256,17 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
     if params.isResolved {
       Utils.Error.make(
         `Impossible to access context.${prop} after the handler is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
+      )->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
+      )
     }
     switch prop {
     | "log" =>
-      (params.isPreload ? Logging.noopLogger : params.item->Logging.getUserLogger)->(
-        Utils.magic: Envio.logger => unknown
-      )
+      (
+        params.isPreload
+          ? Logging.noopLogger
+          : Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)
+      )->(Utils.magic: Envio.logger => unknown)
 
     | "effect" =>
       initEffect((params :> contextParams))->(
@@ -277,7 +287,7 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
         {
           item: params.item,
           isPreload: params.isPreload,
-          inMemoryStore: params.inMemoryStore,
+          indexerState: params.indexerState,
           loadManager: params.loadManager,
           persistence: params.persistence,
           checkpointId: params.checkpointId,
@@ -300,101 +310,3 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
 let getHandlerContext = (params: contextParams): Internal.handlerContext => {
   params->Utils.Proxy.make(handlerTraps)->(Utils.magic: contextParams => Internal.handlerContext)
 }
-
-// Contract register context creation
-type contractRegisterParams = {
-  item: Internal.item,
-  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
-  config: Config.t,
-  mutable isResolved: bool,
-}
-
-// Helper to create a validated add function for contract registration.
-// The isResolved check has to live inside the returned closure (not just in the
-// outer proxy trap) because users can capture `const add = context.chain.X.add`
-// before awaiting — a later call would otherwise bypass the resolved guard.
-let makeAddFunction = (~params: contractRegisterParams, ~contractName: string): (
-  Address.t => unit
-) => {
-  (contractAddress: Address.t) => {
-    if params.isResolved {
-      Utils.Error.make(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`)->ErrorHandling.mkLogAndRaise(
-        ~logger=params.item->Logging.getItemLogger,
-      )
-    }
-    let validatedAddress = if params.config.ecosystem.name === Evm {
-      // The value is passed from the user-land,
-      // so we need to validate and checksum/lowercase the address.
-      if params.config.lowercaseAddresses {
-        contractAddress->Address.Evm.fromAddressLowercaseOrThrow
-      } else {
-        contractAddress->Address.Evm.fromAddressOrThrow
-      }
-    } else {
-      // TODO: Ideally we should do the same for other ecosystems
-      contractAddress
-    }
-
-    params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
-  }
-}
-
-// Chain proxy for contractRegister context: context.chain.ContractName.add(address)
-let contractRegisterChainTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    switch prop {
-    | "id" =>
-      let eventItem = params.item->Internal.castUnsafeEventItem
-      eventItem.chain->ChainMap.Chain.toChainId->(Utils.magic: int => unknown)
-    | _ =>
-      // Look up the contract name directly in config contracts across all chains.
-      let contractName = prop
-      let isValidContract =
-        params.config.chainMap
-        ->ChainMap.values
-        ->Array.some(chain => chain.contracts->Array.some(c => c.name === contractName))
-      if isValidContract {
-        let addFn = makeAddFunction(~params, ~contractName)
-        {"add": addFn}->(Utils.magic: {"add": Address.t => unit} => unknown)
-      } else {
-        JsError.throwWithMessage(
-          `Invalid contract name '${prop}' on context.chain. ${EntityFilter.codegenHelpMessage}`,
-        )
-      }
-    }
-  },
-}
-
-let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
-  get: (~target as params, ~prop: unknown) => {
-    let prop = prop->(Utils.magic: unknown => string)
-    if params.isResolved {
-      Utils.Error.make(
-        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
-      )->ErrorHandling.mkLogAndRaise(~logger=params.item->Logging.getItemLogger)
-    }
-    switch prop {
-    | "log" => params.item->Logging.getUserLogger->(Utils.magic: Envio.logger => unknown)
-    | "chain" =>
-      params
-      ->Utils.Proxy.make(contractRegisterChainTraps)
-      ->(Utils.magic: contractRegisterParams => unknown)
-    | _ =>
-      JsError.throwWithMessage(
-        `Invalid context access by '${prop}' property. Use context.chain.ContractName.add(address) to register contracts. ${EntityFilter.codegenHelpMessage}`,
-      )
-    }
-  },
-}
-
-let getContractRegisterContext = (params: contractRegisterParams) => {
-  params
-  ->Utils.Proxy.make(contractRegisterTraps)
-  ->(Utils.magic: contractRegisterParams => Internal.contractRegisterContext)
-}
-
-let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
-  event: (params.item->Internal.castUnsafeEventItem).event,
-  context: getContractRegisterContext(params),
-}