envio 3.15.0 → 3.16.0-subgraph

package/src/Persistence.res

@@ -117,8 +117,6 @@ type storage = {
   // carries a matching row — storage doesn't interpret it.
   initialize: (
     ~chainConfigs: array<Config.chain>=?,
-    ~entities: array<Internal.entityConfig>=?,
-    ~enums: array<Table.enumConfig<Table.enum>>=?,
     ~contractMapping: ContractMapping.t,
     ~envioInfo: JSON.t,
   ) => promise<initialState>,
@@ -129,16 +127,11 @@ type storage = {
   // Brings an initialized storage a chain it doesn't have yet: its row, its
   // partitions and its config addresses, as `initialize` would have created
   // them. The chains already there are left untouched.
-  addChain: (
-    ~chainConfig: Config.chain,
-    ~entities: array<Internal.entityConfig>,
-    ~contractMapping: ContractMapping.t,
-  ) => promise<unit>,
+  addChain: (~chainConfig: Config.chain, ~contractMapping: ContractMapping.t) => promise<unit>,
   // `chainIds` is what this run drives. An isolated run resumes a subset of
   // the stored chains, and ClickHouse's resume trims past each resumed chain's
   // checkpoint, so chains a sibling process is still writing must stay out.
   resumeInitialState: (
-    ~entities: array<Internal.entityConfig>,
     ~chainIds: array<ChainId.t>,
     ~contractMapping: ContractMapping.t,
   ) => promise<initialState>,
@@ -159,19 +152,12 @@ type storage = {
   // never runs `finalizeBackfill`: an index dropped or invalidated while it was
   // down would otherwise never be rebuilt. Best-effort, and safe to run with
   // indexing live.
-  ensureSchemaIndexes: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-  ) => promise<unit>,
+  ensureSchemaIndexes: (~chainIds: array<ChainId.t>) => promise<unit>,
   // Creates every index the schema promises for the given chains, then stamps
   // `ready_at` on them. Called once those chains finish backfill. The indexes
   // are committed one at a time so a failure part way through doesn't undo the
   // ones already built; `ready_at` is only written once they all verify.
-  finalizeBackfill: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-    ~readyAt: Date.t,
-  ) => promise<unit>,
+  finalizeBackfill: (~chainIds: array<ChainId.t>, ~readyAt: Date.t) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
   reset: unit => promise<unit>,
@@ -190,7 +176,6 @@ type storage = {
   getRollbackTargetCheckpoint: (
     ~reorgChainId: ChainId.t,
     ~lastKnownValidBlockNumber: int,
-    ~sequence: CheckpointSequence.t,
   ) => promise<option<Internal.checkpointId>>,
   // Get rollback progress diff
   getRollbackProgressDiff: (
@@ -214,7 +199,6 @@ type storage = {
     ~batch: Batch.t,
     ~rollback: option<rollback>,
     ~config: Config.t,
-    ~allEntities: array<Internal.entityConfig>,
     ~updatedEffectsCache: array<updatedEffectCache>,
     ~updatedEntities: array<updatedEntity>,
     // Addresses this batch registered, with the checkpoint that covers them.
@@ -339,8 +323,6 @@ let init = {
             throw(Refused(Config.setUpMeanwhileMessage))
           }
           let initialState = await persistence.storage.initialize(
-            ~entities=persistence.allEntities,
-            ~enums=persistence.allEnums,
             ~chainConfigs,
             ~contractMapping,
             ~envioInfo,
@@ -397,13 +379,11 @@ let init = {
               )->Array.getUnsafe(0)
             await persistence.storage.addChain(
               ~chainConfig,
-              ~entities=persistence.allEntities,
               ~contractMapping=stored.contractMapping,
             )
           }
           if resume {
             let initialState = await persistence.storage.resumeInitialState(
-              ~entities=persistence.allEntities,
               ~chainIds=chainConfigs->Array.map(chain => chain.id),
               ~contractMapping=stored.contractMapping,
             )

package/src/Persistence.res.mjs

@@ -94,7 +94,7 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
           Error: new Error()
         };
       }
-      let initialState = await persistence.storage.initialize(chainConfigs$1, persistence.allEntities, persistence.allEnums, contractMapping, envioInfo);
+      let initialState = await persistence.storage.initialize(chainConfigs$1, contractMapping, envioInfo);
       Logger.info(logger, `The indexer storage is ready. Starting indexing!`, undefined);
       persistence.storageStatus = {
         TAG: "Ready",
@@ -136,11 +136,11 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
               chainId: chainConfig.id
             });
             let chainConfig$1 = (await StartBlockResolver.resolveAllOrThrow([chainConfig], logger, lowercaseAddresses, startBlockRetry, sourceTiming))[0];
-            await persistence.storage.addChain(chainConfig$1, persistence.allEntities, stored.contractMapping);
+            await persistence.storage.addChain(chainConfig$1, stored.contractMapping);
           }
         }
         if (resume) {
-          let initialState$1 = await persistence.storage.resumeInitialState(persistence.allEntities, chainConfigs.map(chain => chain.id), stored.contractMapping);
+          let initialState$1 = await persistence.storage.resumeInitialState(chainConfigs.map(chain => chain.id), stored.contractMapping);
           persistence.storageStatus = {
             TAG: "Ready",
             _0: initialState$1

package/src/PreloadLookahead.res

@@ -0,0 +1,202 @@
+// Preload runs a batch's handlers against the store as it was before the batch,
+// so a handler reading an entity an earlier event of the batch creates (a v3
+// pool's Mint after its PoolCreated) reads it as absent and makes none of the
+// contract calls after that read. The execute pass then asks them one event
+// at a time, a round trip each.
+//
+// So preload reads that find an entity absent are remembered per item, and once
+// execute creates that entity, the items that read it are preloaded again, as
+// long as they are within `window` items of the one executing. Preload only
+// warms the store and the effect cache, and every value it fetches is keyed by
+// its full input, so what execute computes is the same with or without it.
+//
+// Preload also sees what earlier items of the batch wrote in their own preload
+// (`overlay`): agent0's URIUpdated(n), the log right after the Registered(n)
+// that creates agent n, would otherwise find no agent and return before its
+// call, and preloading it again once agent n exists is too late — it executes
+// right after. Those writes are a guess at the store execute will see; they
+// are held here, never in the store, and only an item before the reader that
+// execute hasn't run yet is taken: once it has, the store is the answer.
+//
+// Preloading again costs the handler's CPU time once more, and an item whose
+// preloads have already spent `maxPreloadMs` (a v3 Mint computing 1.0001^tick
+// a step at a time) isn't preloaded again: its calls would land later than the
+// CPU it takes away from execute.
+
+type t = {
+  items: array<Internal.item>,
+  indexOf: Utils.Map.t<Internal.item, int>,
+  absentReaders: Map.t<string, array<int>>,
+  dirty: array<bool>,
+  // Milliseconds the item's preload rounds have run for, all runs together.
+  preloadMs: array<float>,
+  // By entity key, the writes items' preloads made: (item, entity or deleted).
+  overlay: Map.t<string, array<(int, option<Internal.entity>)>>,
+  window: int,
+  // The last item execute finished; reads and writes at or before it are history.
+  mutable executed: int,
+}
+
+let active: ref<option<t>> = ref(None)
+
+// Subgraph mappings make their contract calls in the middle of a handler, after
+// the reads, so a read that misses is the difference between preloading the
+// calls and not. Native handlers are left as they are.
+let start = (~items: array<Internal.item>) => {
+  let window = Env.subgraphPreloadLookahead
+  if Env.subgraphMode.contents && window > 0 {
+    let indexOf = Utils.Map.make()
+    items->Array.forEachWithIndex((item, idx) => indexOf->Utils.Map.set(item, idx)->ignore)
+    active :=
+      Some({
+        items,
+        indexOf,
+        absentReaders: Map.make(),
+        dirty: Array.make(~length=items->Array.length, false),
+        preloadMs: Array.make(~length=items->Array.length, 0.),
+        overlay: Map.make(),
+        window,
+        executed: -1,
+      })
+  } else {
+    active := None
+  }
+}
+
+let stop = () => active := None
+
+let maxPreloadMs = 20.
+
+let roundStarted = (~isPreload) =>
+  switch active.contents {
+  | Some(_) if isPreload => Performance.now()
+  | _ => 0.
+  }
+
+let roundEnded = (~item: Internal.item, ~startedAt) =>
+  if startedAt > 0. {
+    switch active.contents {
+    | None => ()
+    | Some(t) =>
+      switch t.indexOf->Utils.Map.get(item) {
+      | Some(idx) =>
+        t.preloadMs->Array.setUnsafe(
+          idx,
+          t.preloadMs->Array.getUnsafe(idx) +. startedAt->Performance.secondsSince *. 1000.,
+        )
+      | None => ()
+      }
+    }
+  }
+
+let entityKey = (~entityName, ~scope: Internal.chainScope, ~entityId) =>
+  switch scope {
+  | CrossChain => `${entityName}..${entityId}`
+  | Chain(chainId) => `${entityName}.${chainId->ChainId.toString}.${entityId}`
+  }
+
+let recordAbsent = (~item: Internal.item, ~entityName, ~scope, ~entityId) =>
+  switch active.contents {
+  | None => ()
+  | Some(t) =>
+    switch t.indexOf->Utils.Map.get(item) {
+    | Some(idx) if idx > t.executed =>
+      let key = entityKey(~entityName, ~scope, ~entityId)
+      switch t.absentReaders->Map.get(key) {
+      | Some(readers) => readers->Array.push(idx)
+      | None => t.absentReaders->Map.set(key, [idx])
+      }
+    | _ => ()
+    }
+  }
+
+let onSet = (~entityName, ~scope, ~entityId) =>
+  switch active.contents {
+  | None => ()
+  // Every write execute makes lands here, and most batches have no absent read.
+  | Some(t) if t.absentReaders->Map.size > 0 =>
+    let key = entityKey(~entityName, ~scope, ~entityId)
+    switch t.absentReaders->Map.get(key) {
+    | None => ()
+    | Some(readers) =>
+      t.absentReaders->Map.delete(key)->ignore
+      readers->Array.forEach(idx =>
+        if idx > t.executed {
+          t.dirty->Array.setUnsafe(idx, true)
+        }
+      )
+    }
+  | Some(_) => ()
+  }
+
+let isActive = () => active.contents->Option.isSome
+
+// How many of `writes` (sorted by item) are by an item before `item`. An entity
+// every event of a batch touches (a popular holder) gathers a write per event,
+// and a scan of them per read was quadratic in the batch.
+let countWritesBeforeItem = (writes: array<(int, option<Internal.entity>)>, item) => {
+  let low = ref(0)
+  let high = ref(writes->Array.length)
+  while low.contents < high.contents {
+    let mid = (low.contents + high.contents) / 2
+    let (writer, _) = writes->Array.getUnsafe(mid)
+    if writer < item {
+      low := mid + 1
+    } else {
+      high := mid
+    }
+  }
+  low.contents
+}
+
+let overlaySet = (~item: Internal.item, ~entityName, ~scope, ~entityId, ~entity) =>
+  switch active.contents {
+  | None => ()
+  | Some(t) =>
+    switch t.indexOf->Utils.Map.get(item) {
+    | Some(writer) =>
+      let key = entityKey(~entityName, ~scope, ~entityId)
+      switch t.overlay->Map.get(key) {
+      | Some(writes) =>
+        let at = writes->countWritesBeforeItem(writer)
+        switch writes->Array.get(at) {
+        | Some((idx, _)) if idx === writer => writes->Array.setUnsafe(at, (writer, entity))
+        | _ => writes->Array.splice(~start=at, ~remove=0, ~insert=[(writer, entity)])
+        }
+      | None => t.overlay->Map.set(key, [(writer, entity)])
+      }
+    | None => ()
+    }
+  }
+
+// `Some(entity or None for deleted)` when an item before the reader that execute
+// hasn't run yet wrote the entity in its preload: the latest such write.
+let overlayGet = (~item: Internal.item, ~entityName, ~scope, ~entityId) =>
+  switch active.contents {
+  | None => None
+  | Some(t) =>
+    switch (
+      t.indexOf->Utils.Map.get(item),
+      t.overlay->Map.get(entityKey(~entityName, ~scope, ~entityId)),
+    ) {
+    | (Some(reader), Some(writes)) =>
+      switch writes->Array.get(writes->countWritesBeforeItem(reader) - 1) {
+      | Some((writer, entity)) if writer > t.executed => Some(entity)
+      | _ => None
+      }
+    | _ => None
+    }
+  }
+
+// Called once execute has finished the item at `index`: the dirty items in the
+// window ahead of it are preloaded again against the store as it is now.
+let afterItem = (t: t, ~index, ~preload: (Internal.item, int) => unit) => {
+  t.executed = index
+  let last = Math.Int.min(t.items->Array.length - 1, index + t.window)
+  for idx in index + 1 to last {
+    if t.dirty->Array.getUnsafe(idx) && t.preloadMs->Array.getUnsafe(idx) < maxPreloadMs {
+      t.dirty->Array.setUnsafe(idx, false)
+      preload(t.items->Array.getUnsafe(idx), idx)
+    }
+  }
+}

package/src/PreloadLookahead.res.mjs

@@ -0,0 +1,218 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as Performance from "./bindings/Performance.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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+let active = {
+  contents: undefined
+};
+
+function start(items) {
+  if (!(Env.subgraphMode.contents && Env.subgraphPreloadLookahead > 0)) {
+    active.contents = undefined;
+    return;
+  }
+  let indexOf = new Map();
+  items.forEach((item, idx) => {
+    indexOf.set(item, idx);
+  });
+  active.contents = {
+    items: items,
+    indexOf: indexOf,
+    absentReaders: new Map(),
+    dirty: Stdlib_Array.make(items.length, false),
+    preloadMs: Stdlib_Array.make(items.length, 0),
+    overlay: new Map(),
+    window: Env.subgraphPreloadLookahead,
+    executed: -1
+  };
+}
+
+function stop() {
+  active.contents = undefined;
+}
+
+function roundStarted(isPreload) {
+  let match = active.contents;
+  if (match !== undefined) {
+    if (isPreload) {
+      return Performance.now();
+    } else {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+}
+
+function roundEnded(item, startedAt) {
+  if (startedAt <= 0) {
+    return;
+  }
+  let t = active.contents;
+  if (t === undefined) {
+    return;
+  }
+  let idx = t.indexOf.get(item);
+  if (idx !== undefined) {
+    t.preloadMs[idx] = t.preloadMs[idx] + Performance.secondsSince(startedAt) * 1000;
+    return;
+  }
+}
+
+function entityKey(entityName, scope, entityId) {
+  if (scope === "crossChain") {
+    return entityName + `..` + entityId;
+  } else {
+    return entityName + `.` + ChainId.toString(scope) + `.` + entityId;
+  }
+}
+
+function recordAbsent(item, entityName, scope, entityId) {
+  let t = active.contents;
+  if (t === undefined) {
+    return;
+  }
+  let idx = t.indexOf.get(item);
+  if (idx === undefined) {
+    return;
+  }
+  if (idx <= t.executed) {
+    return;
+  }
+  let key = entityKey(entityName, scope, entityId);
+  let readers = t.absentReaders.get(key);
+  if (readers !== undefined) {
+    readers.push(idx);
+  } else {
+    t.absentReaders.set(key, [idx]);
+  }
+}
+
+function onSet(entityName, scope, entityId) {
+  let t = active.contents;
+  if (t === undefined) {
+    return;
+  }
+  if (t.absentReaders.size <= 0) {
+    return;
+  }
+  let key = entityKey(entityName, scope, entityId);
+  let readers = t.absentReaders.get(key);
+  if (readers !== undefined) {
+    t.absentReaders.delete(key);
+    readers.forEach(idx => {
+      if (idx > t.executed) {
+        t.dirty[idx] = true;
+        return;
+      }
+    });
+    return;
+  }
+}
+
+function isActive() {
+  return Stdlib_Option.isSome(active.contents);
+}
+
+function countWritesBeforeItem(writes, item) {
+  let low = 0;
+  let high = writes.length;
+  while (low < high) {
+    let mid = (low + high | 0) / 2 | 0;
+    let match = writes[mid];
+    if (match[0] < item) {
+      low = mid + 1 | 0;
+    } else {
+      high = mid;
+    }
+  };
+  return low;
+}
+
+function overlaySet(item, entityName, scope, entityId, entity) {
+  let t = active.contents;
+  if (t === undefined) {
+    return;
+  }
+  let writer = t.indexOf.get(item);
+  if (writer === undefined) {
+    return;
+  }
+  let key = entityKey(entityName, scope, entityId);
+  let writes = t.overlay.get(key);
+  if (writes !== undefined) {
+    let at = countWritesBeforeItem(writes, writer);
+    let match = writes[at];
+    if (match !== undefined && match[0] === writer) {
+      writes[at] = [
+        writer,
+        entity
+      ];
+      return;
+    }
+    writes.splice(at, 0, [
+      writer,
+      entity
+    ]);
+    return;
+  }
+  t.overlay.set(key, [[
+      writer,
+      entity
+    ]]);
+}
+
+function overlayGet(item, entityName, scope, entityId) {
+  let t = active.contents;
+  if (t === undefined) {
+    return;
+  }
+  let match = t.indexOf.get(item);
+  let match$1 = t.overlay.get(entityKey(entityName, scope, entityId));
+  if (match === undefined) {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  let match$2 = match$1[countWritesBeforeItem(match$1, match) - 1 | 0];
+  if (match$2 !== undefined && match$2[0] > t.executed) {
+    return Primitive_option.some(match$2[1]);
+  }
+}
+
+function afterItem(t, index, preload) {
+  t.executed = index;
+  let last = Math.min(t.items.length - 1 | 0, index + t.window | 0);
+  for (let idx = index + 1 | 0; idx <= last; ++idx) {
+    if (t.dirty[idx] && t.preloadMs[idx] < 20) {
+      t.dirty[idx] = false;
+      preload(t.items[idx], idx);
+    }
+  }
+}
+
+let maxPreloadMs = 20;
+
+export {
+  active,
+  start,
+  stop,
+  maxPreloadMs,
+  roundStarted,
+  roundEnded,
+  entityKey,
+  recordAbsent,
+  onSet,
+  isActive,
+  countWritesBeforeItem,
+  overlaySet,
+  overlayGet,
+  afterItem,
+}
+/* Env Not a pure module */

package/src/Rollback.res

@@ -130,7 +130,6 @@ and executeRollback = async (
     switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
       ~reorgChainId=reorgChain,
       ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
-      ~sequence=(state->IndexerState.config).checkpointSequence,
     ) {
     | Some(checkpointId) => checkpointId
     | None => 0n

package/src/Rollback.res.mjs

@@ -42,7 +42,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   Logger.info(logger, "Started rollback on reorg", undefined);
   ChainState.setRollbackTargetBlock(IndexerState.getChainState(state, reorgChain), rollbackTargetBlockNumber);
   await Writing.flush(state);
-  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber, IndexerState.config(state).checkpointSequence);
+  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
   let config = IndexerState.config(state);
   let next = RollbackFloors.make(config.checkpointSequence, ChainMap.keys(config.chainMap), reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber);

package/src/RunScope.res

@@ -22,6 +22,9 @@ type contractRegisterRun = {
   chainLogger: Logger.t,
   ecosystem: Ecosystem.t,
   registrations: array<AddressStore.registration>,
+  // Subgraph mode: the creation round the addresses it adds belong to (see
+  // `AddressStore.registration.creationRound`).
+  creationRound?: int,
 }
 
 // An effect call is shared by the runs that asked for it, so it is told by the

package/src/SafeCheckpointTracking.res

@@ -16,9 +16,7 @@ let make = (
 ) => {
   if maxReorgDepth > 0 && shouldRollbackOnReorg {
     let checkpointIds = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
-    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(
-      chainReorgCheckpoints->Array.length,
-    )
+    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
     chainReorgCheckpoints->Array.forEachWithIndex((checkpoint, idx) => {
       checkpointIds->Array.setUnsafe(idx, checkpoint.checkpointId)
       checkpointBlockNumbers->Array.setUnsafe(idx, checkpoint.blockNumber)
@@ -36,7 +34,9 @@ let make = (
 let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int): option<
   Internal.checkpointId,
 > => {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
+  // The first block reorg detection compares is itself reorgable, so the safe
+  // block is the one below it.
+  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth - 1
 
   switch safeCheckpointTracking.checkpointIds {
   | [] => None

package/src/SafeCheckpointTracking.res.mjs

@@ -20,7 +20,7 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
 }
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  let safeBlockNumber = (sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0) - 1 | 0;
   let match = safeCheckpointTracking.checkpointIds;
   if (match.length === 0) {
     return;

package/src/SimulateItems.res

@@ -638,7 +638,16 @@ let parse = (
       // A simulate item must land on a distinct (block, logIndex): event ordering
       // and the dead-input tracker both key on it. Catch explicit duplicates and
       // explicit-vs-auto-increment collisions here, naming both offending indices.
-      let coordinate = `${blockNumber->Int.toString}:${logIndex->Int.toString}`
+      // A call is ordered by its position in its transaction's trace, so two
+      // transactions' calls share an index.
+      let coordinate = switch Internal.callRankOfEventName(eventConfig.name) {
+      | Some(_) =>
+        let transactionIndex = (
+          transaction->(Utils.magic: Internal.eventTransaction => {"transactionIndex": int})
+        )["transactionIndex"]
+        `${blockNumber->Int.toString}:tx${transactionIndex->Int.toString}:${logIndex->Int.toString}`
+      | None => `${blockNumber->Int.toString}:${logIndex->Int.toString}`
+      }
       switch seenCoordinates->Dict.get(coordinate) {
       | Some(firstIndex) =>
         JsError.throwWithMessage(
@@ -673,31 +682,38 @@ let parse = (
         let onEventRegistration = {...reg, index: onEventRegistrationIndex}
         onEventRegistrations->Array.push(onEventRegistration)->ignore
 
-        items
-        ->Array.push(
-          Internal.Event({
-            onEventRegistration,
-            chainId,
-            blockNumber,
-            logIndex,
-            // Simulate keeps the transaction inline on the payload, so the store
-            // key is unused.
-            transactionIndex: 0,
-            payload: (
-              {
-                contractName: eventConfig.contractName,
-                eventName: eventConfig.name,
-                params,
-                chainId,
-                srcAddress,
-                logIndex,
-                transaction,
-                block,
-              }: Evm.payload
-            )->Evm.fromPayload,
-          }),
-        )
-        ->ignore
+        let item = Internal.Event({
+          onEventRegistration,
+          chainId,
+          blockNumber,
+          logIndex,
+          // Simulate keeps the transaction inline on the payload, so the store
+          // key is unused; a subgraph's call triggers order by it among logs.
+          transactionIndex: switch config.ecosystem.name {
+          | Evm =>
+            (
+              transaction->(Utils.magic: Internal.eventTransaction => {"transactionIndex": int})
+            )["transactionIndex"]
+          | _ => 0
+          },
+          payload: (
+            {
+              contractName: eventConfig.contractName,
+              eventName: eventConfig.name,
+              params,
+              chainId,
+              srcAddress,
+              logIndex,
+              transaction,
+              block,
+            }: Evm.payload
+          )->Evm.fromPayload,
+        })
+        switch Internal.callRankOfEventName(eventConfig.name) {
+        | Some(rank) => item->Internal.markItemCall(~rank)
+        | None => ()
+        }
+        items->Array.push(item)->ignore
       })
     }
   })