envio 3.3.2 → 3.4.0

package/src/IndexerState.res.mjs

@@ -44,7 +44,7 @@ function get(self, entityName) {
   }
 }
 
-function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError) {
+function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let committedCheckpointId = committedCheckpointIdOpt !== undefined ? committedCheckpointIdOpt : Internal.initialCheckpointId;
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
@@ -81,6 +81,7 @@ function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime
     keepProcessAlive: isDevelopmentMode || shouldUseTui,
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
+    onExit: onExit,
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
@@ -96,7 +97,7 @@ function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime
   };
 }
 
-function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError) {
+function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError, onExit) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -118,7 +119,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
     let chainConfig = ChainMap.get(config.chainMap, chain);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
   });
-  let state = make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError);
+  let state = make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
     EffectState.setUnregisteredCacheCount(state.effectState, param.effectName, param.scope, count);
@@ -319,6 +320,10 @@ function exitAfterFirstEventBlock(state) {
   return state.exitAfterFirstEventBlock;
 }
 
+function onExit(state) {
+  return state.onExit;
+}
+
 function isStopped(state) {
   return state.isStopped;
 }
@@ -718,6 +723,7 @@ export {
   loadManager,
   keepProcessAlive,
   exitAfterFirstEventBlock,
+  onExit,
   isStopped,
   epoch,
   lastPrunedAtMillis,

package/src/IndexerState.resi

@@ -30,6 +30,7 @@ let make: (
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,
   ~onError: ErrorHandling.t => unit,
+  ~onExit: unit => unit=?,
 ) => t
 
 let makeFromDbState: (
@@ -43,6 +44,7 @@ let makeFromDbState: (
   ~reducedPollingInterval: int=?,
   ~targetBufferSize: int=?,
   ~onError: ErrorHandling.t => unit,
+  ~onExit: unit => unit=?,
 ) => t
 
 let unexpectedErrorMsg: string
@@ -96,6 +98,7 @@ let indexerStartTime: t => Date.t
 let loadManager: t => LoadManager.t
 let keepProcessAlive: t => bool
 let exitAfterFirstEventBlock: t => bool
+let onExit: t => option<unit => unit>
 let isStopped: t => bool
 let epoch: t => int
 let lastPrunedAtMillis: t => dict<float>

package/src/Internal.res

@@ -179,7 +179,7 @@ type svmBlockField =
 let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
 let svmBlockFieldSchema = S.enum(allSvmBlockFields)
 
-// Static sets of nullable field names — used by RpcSource and HyperSyncSource to wrap schemas with S.nullable
+// Static sets of field names whose source schemas must be wrapped with S.nullable.
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
     [
@@ -720,11 +720,20 @@ let fuelTransferParamsSchema = S.schema(s => {
 
 type entity = private {id: string}
 
+// Raw ClickHouse expressions/field names from the entity's
+// @storage(clickhouse: {...}) directive, applied to the history table DDL.
+type clickhouseTableOptions = {
+  partitionBy?: string,
+  orderBy?: array<string>,
+  ttl?: string,
+}
+
 // Per-entity storage resolved at parse time against the global storage
 // config. Downstream PG/CH consumers just check the matching boolean.
 type entityStorage = {
   postgres: bool,
   clickhouse: bool,
+  clickhouseOptions?: clickhouseTableOptions,
 }
 
 type genericEntityConfig<'entity> = {

package/src/Main.res.mjs

@@ -247,7 +247,7 @@ function getGlobalIndexer() {
   let onEventFn = (identityConfig, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onEvent");
     let match = parseIdentityConfig(identityConfig);
-    HandlerRegister.setHandler(match[0], match[1], handler, match[2], undefined);
+    HandlerRegister.setHandler(match[0], match[1], handler, match[2]);
   };
   let parseSvmIdentityConfig = identityConfig => {
     let match;
@@ -279,12 +279,12 @@ function getGlobalIndexer() {
     HandlerRegister.setHandler(match[0], match[1], args => handler({
       instruction: args.event,
       context: args.context
-    }), match[2], undefined);
+    }), match[2]);
   };
   let contractRegisterFn = (identityConfig, handler) => {
     HandlerRegister.throwIfFinishedRegistration("contractRegister");
     let match = parseIdentityConfig(identityConfig);
-    HandlerRegister.setContractRegister(match[0], match[1], handler, match[2], undefined);
+    HandlerRegister.setContractRegister(match[0], match[1], handler, match[2]);
   };
   let onRollbackCommitFn = callback => {
     HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
@@ -524,7 +524,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       };
     }, persistence$1, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError, undefined);
   if (shouldUseTui) {
     Tui.start(() => state);
   }

package/src/PgStorage.res

@@ -849,9 +849,24 @@ let rec writeBatch = async (
     let specificError = ref(None)
 
     let rawEvents = if config.enableRawEvents {
+      // A single on-chain log fans out to one item per matching registration;
+      // `raw_events` records the log itself, so dedupe by its coordinate
+      // (chain, block, logIndex) to keep one row per log.
+      let seenLogCoordinates = Utils.Set.make()
       let rows = batch.items->Array.filterMap(item =>
         switch item {
-        | Internal.Event(_) => Some(config.ecosystem.toRawEvent(item->Internal.castUnsafeEventItem))
+        | Internal.Event(_) =>
+          let coordinate = `${item
+            ->Internal.getItemChainId
+            ->Int.toString}-${item
+            ->Internal.getItemBlockNumber
+            ->Int.toString}-${item->Internal.getItemLogIndex->Int.toString}`
+          if seenLogCoordinates->Utils.Set.has(coordinate) {
+            None
+          } else {
+            seenLogCoordinates->Utils.Set.add(coordinate)->ignore
+            Some(config.ecosystem.toRawEvent(item->Internal.castUnsafeEventItem))
+          }
         | Internal.Block(_) => None
         }
       )

package/src/PgStorage.res.mjs

@@ -607,8 +607,16 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     };
     let rawEvents;
     if (config.enableRawEvents) {
+      let seenLogCoordinates = new Set();
       let rows = Stdlib_Array.filterMap(batch.items, item => {
-        if (item.kind === 0) {
+        if (item.kind !== 0) {
+          return;
+        }
+        let coordinate = Internal.getItemChainId(item).toString() + `-` + item.blockNumber.toString() + `-` + item.logIndex.toString();
+        if (seenLogCoordinates.has(coordinate)) {
+          return;
+        } else {
+          seenLogCoordinates.add(coordinate);
           return config.ecosystem.toRawEvent(item);
         }
       });

package/src/SimulateItems.res

@@ -339,46 +339,67 @@ let parse = (
       | None => seenCoordinates->Dict.set(coordinate, itemIndex)
       }
 
-      // Build a real registration the same way `HandlerRegister.finishRegistration`
-      // does at startup (not a stub), so the address filter and `where`
-      // behave identically to real indexing — the dead-input tracker relies
-      // on `clientAddressFilter` actually gating unrouted items.
-      let onEventRegistration = HandlerRegister.buildOnEventRegistration(
-        ~config,
-        ~chainId,
-        ~eventConfig,
-      )
-      // Append into the registration array that the chain state will own and
-      // put that same registration object directly on the simulated item.
-      let onEventRegistrationIndex = onEventRegistrations->Array.length
-      let onEventRegistration = {...onEventRegistration, index: onEventRegistrationIndex}
-      onEventRegistrations->Array.push(onEventRegistration)->ignore
-
-      items
-      ->Array.push(
-        Internal.Event({
-          onEventRegistration,
-          chain,
-          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
+      // Fan the simulated event out to every registration that would actually
+      // run here the way real routing does (one item per registration).
+      // Registrations are built the same way `HandlerRegister.finishRegistration`
+      // does at startup (not stubs), so the address filter and `where` behave
+      // identically to real indexing — the dead-input tracker relies on
+      // `clientAddressFilter` actually gating unrouted items. Drop registrations
+      // whose `where` excludes this chain (they wouldn't be fetched live), and
+      // ignore the bare handler-less fallback so a missing handler surfaces below
+      // instead of silently running nothing.
+      let liveRegistrations =
+        HandlerRegister.getSimulateOnEventRegistrations(
+          ~config,
+          ~chainId,
+          ~eventConfig,
+        )->Array.filter(reg =>
+          (reg.handler->Option.isSome || reg.contractRegister->Option.isSome) &&
+            !HandlerRegister.isDroppedByWhere(~config, reg)
+        )
+      if liveRegistrations->Utils.Array.isEmpty {
+        JsError.throwWithMessage(
+          `simulate: no handler runs for event "${eventName}" on contract "${contractName}"${switch config.chainMap
+            ->ChainMap.values
+            ->Array.length {
+            | 1 => ""
+            | _ => ` on chain ${chainId->Int.toString}`
+            }}. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`,
+        )
+      }
+      liveRegistrations->Array.forEach(reg => {
+        // Append into the registration array that the chain state will own and
+        // put that same registration object directly on the simulated item.
+        let onEventRegistrationIndex = onEventRegistrations->Array.length
+        let onEventRegistration = {...reg, index: onEventRegistrationIndex}
+        onEventRegistrations->Array.push(onEventRegistration)->ignore
+
+        items
+        ->Array.push(
+          Internal.Event({
+            onEventRegistration,
+            chain,
+            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
+      })
 
     | _ =>
       JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`)

package/src/SimulateItems.res.mjs

@@ -1,5 +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 Address from "./Address.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
@@ -232,6 +233,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         break;
     }
     let blockNumber = match$3[1];
+    let block$2 = match$3[0];
     let match$4 = config.ecosystem.name;
     let transaction;
     switch (match$4) {
@@ -253,29 +255,43 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
-    let onEventRegistration = HandlerRegister.buildOnEventRegistration(config, chainId, eventConfig, undefined);
-    let onEventRegistrationIndex = onEventRegistrations.length;
-    let newrecord = {...onEventRegistration};
-    newrecord.index = onEventRegistrationIndex;
-    onEventRegistrations.push(newrecord);
-    items.push({
-      kind: 0,
-      onEventRegistration: newrecord,
-      chain: chain,
-      blockNumber: blockNumber,
-      logIndex: logIndex,
-      transactionIndex: 0,
-      payload: {
-        contractName: eventConfig.contractName,
-        eventName: eventConfig.name,
-        params: params,
-        chainId: chainId,
-        srcAddress: srcAddress,
-        logIndex: logIndex,
-        transaction: Primitive_option.some(transaction),
-        block: Primitive_option.some(match$3[0])
+    let liveRegistrations = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+      if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
+        return !HandlerRegister.isDroppedByWhere(config, reg);
+      } else {
+        return false;
       }
     });
+    if (Utils.$$Array.isEmpty(liveRegistrations)) {
+      let match$5 = ChainMap.values(config.chainMap).length;
+      Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + match$1 + `" on contract "` + match + `"` + (
+        match$5 !== 1 ? ` on chain ` + chainId.toString() : ""
+      ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
+    }
+    liveRegistrations.forEach(reg => {
+      let onEventRegistrationIndex = onEventRegistrations.length;
+      let newrecord = {...reg};
+      newrecord.index = onEventRegistrationIndex;
+      onEventRegistrations.push(newrecord);
+      items.push({
+        kind: 0,
+        onEventRegistration: newrecord,
+        chain: chain,
+        blockNumber: blockNumber,
+        logIndex: logIndex,
+        transactionIndex: 0,
+        payload: {
+          contractName: eventConfig.contractName,
+          eventName: eventConfig.name,
+          params: params,
+          chainId: chainId,
+          srcAddress: srcAddress,
+          logIndex: logIndex,
+          transaction: Primitive_option.some(transaction),
+          block: Primitive_option.some(block$2)
+        }
+      });
+    });
   });
   return items;
 }