envio 3.3.0-alpha.6 → 3.3.0-alpha.8

package/src/EventProcessing.res

@@ -74,8 +74,8 @@ let runEventHandlerOrThrow = async (
   }
   let handlerDuration = timeBeforeHandler->Performance.secondsSince
   Prometheus.ProcessingHandler.increment(
-    ~contract=eventItem.eventConfig.contractName,
-    ~event=eventItem.eventConfig.name,
+    ~contract=eventItem.onEventRegistration.eventConfig.contractName,
+    ~event=eventItem.onEventRegistration.eventConfig.name,
     ~duration=handlerDuration,
   )
 }
@@ -90,7 +90,7 @@ let runHandlerOrThrow = async (
   ~chains: Internal.chains,
 ) => {
   switch item {
-  | Block({onBlockConfig: {handler}, blockNumber}) =>
+  | Block({onBlockRegistration: {handler}, blockNumber}) =>
     try {
       let contextParams: UserContext.contextParams = {
         item,
@@ -121,8 +121,8 @@ let runHandlerOrThrow = async (
         }),
       )
     }
-  | Event({eventConfig}) =>
-    switch eventConfig.handler {
+  | Event({onEventRegistration}) =>
+    switch onEventRegistration.handler {
     | Some(handler) =>
       await item->runEventHandlerOrThrow(
         ~handler,
@@ -161,7 +161,7 @@ let preloadBatchOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
-      | Event({eventConfig: {handler, contractName, name: eventName}}) =>
+      | Event({onEventRegistration: {handler, eventConfig: {contractName, name: eventName}}}) =>
         switch handler {
         | None => ()
         | Some(handler) =>
@@ -200,7 +200,7 @@ let preloadBatchOrThrow = async (
           | _ => ()
           }
         }
-      | Block({onBlockConfig: {handler}, blockNumber}) =>
+      | Block({onBlockRegistration: {handler}, blockNumber}) =>
         try {
           promises->Array.push(
             handler({
@@ -289,15 +289,19 @@ type logPartitionInfo = {
   lastItemBlockNumber?: int,
 }
 
-// Off the hot path: bulk-materialise the selected transaction fields for the
-// batch's store-backed (HyperSync) items and write them onto the payloads, so
-// handlers read plain objects. A batch can span chains, each with its own store
-// and field mask, so group items by chain before materialising.
-let materializeBatchTransactions = async (batch: Batch.t, ~chainStates: dict<ChainState.t>) => {
+// Off the hot path: bulk-materialise the selected transaction and block fields
+// for the batch's store-backed (HyperSync) items and write them onto the
+// payloads, so handlers read plain objects. A batch can span chains, each with
+// its own stores and field masks, so group items by chain before materialising.
+let materializeBatchEvents = async (
+  batch: Batch.t,
+  ~chainStates: dict<ChainState.t>,
+  ~ecosystem,
+) => {
   switch chainStates->Dict.valuesToArray {
   // Single-chain indexers (the common case): every item belongs to the one
   // chain, so skip the per-chain grouping and its allocations.
-  | [cs] => await cs->ChainState.materializeBatchItems(~items=batch.items)
+  | [cs] => await cs->ChainState.materializeBatchItems(~items=batch.items, ~ecosystem)
   | _ =>
     let itemsByChain: dict<array<Internal.item>> = Dict.make()
     batch.items->Array.forEach(item => {
@@ -312,7 +316,7 @@ let materializeBatchTransactions = async (batch: Batch.t, ~chainStates: dict<Cha
     ->Dict.toArray
     ->Array.map(async ((chainId, items)) => {
       let cs = chainStates->Dict.getUnsafe(chainId)
-      await cs->ChainState.materializeBatchItems(~items)
+      await cs->ChainState.materializeBatchItems(~items, ~ecosystem)
     })
     ->Promise.all
   }
@@ -348,7 +352,7 @@ let processEventBatch = async (
     if batch.items->Utils.Array.notEmpty {
       // Materialise store-backed transactions onto payloads before any handler
       // (preload or execute) reads them.
-      await materializeBatchTransactions(batch, ~chainStates)
+      await materializeBatchEvents(batch, ~chainStates, ~ecosystem=config.ecosystem.name)
       await batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 

package/src/EventProcessing.res.mjs

@@ -65,12 +65,12 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
     };
   }
   let handlerDuration = Performance.secondsSince(timeBeforeHandler);
-  return Prometheus.ProcessingHandler.increment(item.eventConfig.contractName, item.eventConfig.name, handlerDuration);
+  return Prometheus.ProcessingHandler.increment(item.onEventRegistration.eventConfig.contractName, item.onEventRegistration.eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {
   if (item.kind === 0) {
-    let handler = item.eventConfig.handler;
+    let handler = item.onEventRegistration.handler;
     if (handler !== undefined) {
       return await runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config);
     } else {
@@ -89,7 +89,7 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
       config: config,
       isResolved: false
     };
-    await item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
+    await item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
     contextParams.isResolved = true;
     return;
   } catch (raw_exn) {
@@ -113,11 +113,12 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
     for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
       let item = batch.items[itemIdx + idx | 0];
       if (item.kind === 0) {
-        let match = item.eventConfig;
+        let match = item.onEventRegistration;
         let handler = match.handler;
         if (handler !== undefined) {
-          let contractName = match.contractName;
-          let eventName = match.name;
+          let match$1 = match.eventConfig;
+          let contractName = match$1.contractName;
+          let eventName = match$1.name;
           try {
             let timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
             promises.push(Utils.$$Promise.silentCatch(handler({
@@ -140,7 +141,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
         }
       } else {
         try {
-          promises.push(Utils.$$Promise.silentCatch(item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
+          promises.push(Utils.$$Promise.silentCatch(item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
             item: item,
             checkpointId: checkpointId,
             indexerState: indexerState,
@@ -184,7 +185,7 @@ function registerProcessEventBatchMetrics(logger, batch, loadDuration, handlerDu
   Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
 }
 
-async function materializeBatchTransactions(batch, chainStates) {
+async function materializeBatchEvents(batch, chainStates, ecosystem) {
   let match = Object.values(chainStates);
   if (match.length !== 1) {
     let itemsByChain = {};
@@ -199,12 +200,12 @@ async function materializeBatchTransactions(batch, chainStates) {
     });
     await Promise.all(Object.entries(itemsByChain).map(async param => {
       let cs = chainStates[param[0]];
-      return await ChainState.materializeBatchItems(cs, param[1]);
+      return await ChainState.materializeBatchItems(cs, param[1], ecosystem);
     }));
     return;
   }
   let cs = match[0];
-  return await ChainState.materializeBatchItems(cs, batch.items);
+  return await ChainState.materializeBatchItems(cs, batch.items, ecosystem);
 }
 
 async function processEventBatch(batch, indexerState, loadManager, persistence, config, chainStates) {
@@ -219,7 +220,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
     await Writing.awaitCapacity(indexerState);
     let timeRef = Performance.now();
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await materializeBatchTransactions(batch, chainStates);
+      await materializeBatchEvents(batch, chainStates, config.ecosystem.name);
       await preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains);
     }
     let elapsedTimeAfterLoaders = Performance.secondsSince(timeRef);
@@ -264,7 +265,7 @@ export {
   preloadBatchOrThrow,
   runBatchHandlersOrThrow,
   registerProcessEventBatchMetrics,
-  materializeBatchTransactions,
+  materializeBatchEvents,
   processEventBatch,
 }
 /* Utils Not a pure module */