envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/RawEvent.res.mjs

@@ -18,10 +18,10 @@ function convertFieldsToJson(fields) {
   }
 }
 
-function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEventFieldsInPlace) {
+function make(eventItem, block, transaction, params, srcAddress, blockHash, blockTimestamp, cleanUpRawEventFieldsInPlace) {
   let logIndex = eventItem.logIndex;
   let blockNumber = eventItem.blockNumber;
-  let eventConfig = eventItem.eventConfig;
+  let eventConfig = eventItem.onEventRegistration.eventConfig;
   let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
   let blockFields = convertFieldsToJson(block);
   let transactionFields = convertFieldsToJson(transaction);
@@ -36,8 +36,8 @@ function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEvent
     block_number: blockNumber,
     log_index: logIndex,
     src_address: srcAddress,
-    block_hash: eventItem.blockHash,
-    block_timestamp: eventItem.timestamp,
+    block_hash: blockHash,
+    block_timestamp: blockTimestamp,
     block_fields: blockFields,
     transaction_fields: transactionFields,
     params: params$2

package/src/Rollback.res

@@ -18,7 +18,7 @@ let getLastKnownValidBlock = async (
     ->ChainState.reorgDetection
     ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
       ~blockNumber=reorgBlockNumber,
-      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+      ~knownHeight=chainState->ChainState.knownHeight,
     )
 
   switch scannedBlockNumbers {
@@ -94,7 +94,7 @@ and executeRollback = async (
   ~scheduleFetch,
   ~scheduleProcessing,
 ) => {
-  let startTime = Hrtime.makeTimer()
+  let startTime = Performance.now()
 
   let chainState = state->IndexerState.getChainState(~chain=reorgChain)
 
@@ -194,7 +194,7 @@ and executeRollback = async (
     "targetCheckpointId": rollbackTargetCheckpointId,
   })
   Prometheus.RollbackSuccess.increment(
-    ~timeSeconds=Hrtime.timeSince(startTime)->Hrtime.toSecondsFloat,
+    ~timeSeconds=Performance.secondsSince(startTime),
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )
 

package/src/Rollback.res.mjs

@@ -1,11 +1,11 @@
 // 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 Performance from "./bindings/Performance.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";
@@ -18,7 +18,7 @@ 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);
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.knownHeight(chainState));
   if (scannedBlockNumbers.length === 0) {
     return ChainState.getHighestBlockBelowThreshold(chainState);
   }
@@ -32,7 +32,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 }
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
-  let startTime = Hrtime.makeTimer();
+  let startTime = Performance.now();
   let chainState = IndexerState.getChainState(state, reorgChain);
   let logger = Logging.createChildFrom(ChainState.logger(chainState), {
     action: "Rollback",
@@ -70,7 +70,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     beforeCheckpointId: IndexerState.committedCheckpointId(state),
     targetCheckpointId: rollbackTargetCheckpointId
   });
-  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+  Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
   scheduleFetch();
   return scheduleProcessing();

package/src/RollbackCommit.res

@@ -6,7 +6,10 @@
 type args = {chainId: int, rollbackToBlock: int}
 type callback = args => promise<unit>
 
-let callbacks: array<callback> = []
+// Lives in the process-wide `EnvioGlobal` record so callbacks registered
+// through a duplicate envio module instance still fire.
+let callbacks =
+  EnvioGlobal.value.rollbackCommitCallbacks->(Utils.magic: array<unknown> => array<callback>)
 
 let register = (callback: callback) => {
   callbacks->Array.push(callback)

package/src/RollbackCommit.res.mjs

@@ -1,8 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
-let callbacks = [];
+let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
 
 function register(callback) {
   callbacks.push(callback);
@@ -32,4 +33,4 @@ export {
   register,
   fire,
 }
-/* No side effect */
+/* EnvioGlobal Not a pure module */

package/src/SimulateDeadInputTracker.res

@@ -0,0 +1,85 @@
+// Lives on IndexerState and is fed each processed batch, so ChainState and the
+// fetch loop carry no simulate-specific state.
+
+// Match a provided item to a processed one by its (chain, block, logIndex)
+// coordinate rather than object identity, so matching survives any copy or
+// transform of the item between the source and the batch.
+let itemKey = (item: Internal.item): string =>
+  switch item {
+  | Internal.Event({chain, blockNumber, logIndex}) =>
+    `${chain
+      ->ChainMap.Chain.toChainId
+      ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
+  | Internal.Block(_) => ""
+  }
+
+// `index` is the item's position in its chain's `simulate` array, reported back
+// so a user finds it without echoing its fields.
+type entry = {chainId: int, index: int, key: string}
+
+type t = {mutable unprocessed: array<entry>}
+
+let makeFromConfig = (config: Config.t): option<t> => {
+  let entries =
+    config.chainMap
+    ->ChainMap.values
+    ->Array.flatMap(chainConfig =>
+      switch chainConfig.sourceConfig {
+      | Config.CustomSources(sources) =>
+        sources->Array.flatMap(source =>
+          source.simulateItems
+          ->Option.getOr([])
+          ->Array.mapWithIndex(
+            (item, index) => {
+              chainId: chainConfig.id,
+              index,
+              key: itemKey(item),
+            },
+          )
+        )
+      | _ => []
+      }
+    )
+  switch entries {
+  | [] => None
+  | _ => Some({unprocessed: entries})
+  }
+}
+
+let recordProcessed = (t: t, ~batch: Batch.t) => {
+  let processedKeys = batch.items->Array.map(itemKey)->Utils.Set.fromArray
+  t.unprocessed = t.unprocessed->Array.filter(entry => !(processedKeys->Utils.Set.has(entry.key)))
+}
+
+// Unrouted item indices grouped by chain, in the order chains were first seen.
+let unroutedByChain = (t: t): array<(int, array<int>)> => {
+  let indicesByChain = Dict.make()
+  let chainOrder = []
+  t.unprocessed->Array.forEach(entry => {
+    let key = entry.chainId->Int.toString
+    if indicesByChain->Dict.get(key)->Option.isNone {
+      chainOrder->Array.push(entry.chainId)->ignore
+    }
+    indicesByChain->Utils.Dict.push(key, entry.index)
+  })
+  chainOrder->Array.map(chainId => (chainId, indicesByChain->Dict.getUnsafe(chainId->Int.toString)))
+}
+
+let failureMessage = (t: t): option<string> =>
+  switch t->unroutedByChain {
+  | [] => None
+  | byChain =>
+    let count = byChain->Array.reduce(0, (acc, (_chainId, indices)) => acc + indices->Array.length)
+    let itemWord = count === 1 ? "item" : "items"
+    let lines =
+      byChain
+      ->Array.map(((chainId, indices)) =>
+        `  - chain ${chainId->Int.toString}: ${indices
+          ->Array.map(index => index->Int.toString)
+          ->Array.join(", ")}`
+      )
+      ->Array.join("\n")
+    Some(
+      `simulate: ${count->Int.toString} ${itemWord} you passed to simulate never reached a handler, so nothing ran for them. Each was filtered out before the handler — usually a non-wildcard srcAddress that isn't indexed for the contract, or a where/block filter that excluded the event. Unrouted items, by index in each chain's simulate array:\n${lines}`,
+    )
+  }

package/src/SimulateDeadInputTracker.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as ChainMap from "./ChainMap.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";
+
+function itemKey(item) {
+  if (item.kind === 0) {
+    return item.chain.toString() + `:` + item.blockNumber.toString() + `:` + item.logIndex.toString();
+  } else {
+    return "";
+  }
+}
+
+function makeFromConfig(config) {
+  let entries = ChainMap.values(config.chainMap).flatMap(chainConfig => {
+    let sources = chainConfig.sourceConfig;
+    if (sources.TAG === "CustomSources") {
+      return sources._0.flatMap(source => Stdlib_Option.getOr(source.simulateItems, []).map((item, index) => ({
+        chainId: chainConfig.id,
+        index: index,
+        key: itemKey(item)
+      })));
+    } else {
+      return [];
+    }
+  });
+  if (entries.length !== 0) {
+    return {
+      unprocessed: entries
+    };
+  }
+}
+
+function recordProcessed(t, batch) {
+  let processedKeys = new Set(batch.items.map(itemKey));
+  t.unprocessed = t.unprocessed.filter(entry => !processedKeys.has(entry.key));
+}
+
+function unroutedByChain(t) {
+  let indicesByChain = {};
+  let chainOrder = [];
+  t.unprocessed.forEach(entry => {
+    let key = entry.chainId.toString();
+    if (Stdlib_Option.isNone(indicesByChain[key])) {
+      chainOrder.push(entry.chainId);
+    }
+    Utils.Dict.push(indicesByChain, key, entry.index);
+  });
+  return chainOrder.map(chainId => [
+    chainId,
+    indicesByChain[chainId.toString()]
+  ]);
+}
+
+function failureMessage(t) {
+  let byChain = unroutedByChain(t);
+  if (byChain.length === 0) {
+    return;
+  }
+  let count = Stdlib_Array.reduce(byChain, 0, (acc, param) => acc + param[1].length | 0);
+  let itemWord = count === 1 ? "item" : "items";
+  let lines = byChain.map(param => `  - chain ` + param[0].toString() + `: ` + param[1].map(index => index.toString()).join(", ")).join("\n");
+  return `simulate: ` + count.toString() + ` ` + itemWord + ` you passed to simulate never reached a handler, so nothing ran for them. Each was filtered out before the handler — usually a non-wildcard srcAddress that isn't indexed for the contract, or a where/block filter that excluded the event. Unrouted items, by index in each chain's simulate array:\n` + lines;
+}
+
+export {
+  makeFromConfig,
+  recordProcessed,
+  failureMessage,
+}
+/* Utils Not a pure module */

package/src/SimulateDeadInputTracker.resi

@@ -0,0 +1,12 @@
+type t
+
+// Builds a tracker from the run's config, seeded with every item each simulate
+// source provided. None when no chain has a simulate source.
+let makeFromConfig: Config.t => option<t>
+
+// Drop the batch's items from the not-yet-routed set, matched by event coordinate.
+let recordProcessed: (t, ~batch: Batch.t) => unit
+
+// The error to fail the run with when items never reached a handler, listing them
+// by chain and index within that chain's `simulate` array. None when all routed.
+let failureMessage: t => option<string>

package/src/SimulateItems.res

@@ -195,9 +195,57 @@ let findEventConfig = (~config: Config.t, ~contractName: string, ~eventName: str
   found.contents
 }
 
-let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
-  Internal.item,
+let dummySrcAddress = Address.unsafeFromString("0x0000000000000000000000000000000000000000")
+
+// First address configured for `contractName` on the simulated chain. Only the
+// simulated chain is consulted — a contract's address on another chain has no
+// meaning here.
+let firstContractAddress = (~chainConfig: Config.chain, ~contractName: string): option<
+  Address.t,
 > => {
+  let found = ref(None)
+  chainConfig.contracts->Array.forEach(contract => {
+    if found.contents->Option.isNone && contract.name === contractName {
+      found := contract.addresses->Array.get(0)
+    }
+  })
+  found.contents
+}
+
+let deriveSrcAddress = (
+  ~providedSrcAddress: option<Address.t>,
+  ~eventConfig: Internal.eventConfig,
+  ~chainConfig: Config.chain,
+  ~config: Config.t,
+): Address.t => {
+  switch providedSrcAddress {
+  // Canonicalize to the configured casing; the fallback addresses below already
+  // come from the parsed config and need no normalization. Relaxed (not
+  // Config.normalizeUserAddress) so test placeholders like "0xfoo" are allowed.
+  | Some(addr) => config->Config.normalizeSimulateAddress(addr)
+  | None =>
+    if (
+      HandlerRegister.isWildcard(
+        ~contractName=eventConfig.contractName,
+        ~eventName=eventConfig.name,
+      )
+    ) {
+      dummySrcAddress
+    } else {
+      switch firstContractAddress(~chainConfig, ~contractName=eventConfig.contractName) {
+      | Some(addr) => addr
+      | None => dummySrcAddress
+      }
+    }
+  }
+}
+
+let parse = (
+  ~simulateItems: array<JSON.t>,
+  ~config: Config.t,
+  ~chainConfig: Config.chain,
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+): array<Internal.item> => {
   let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
   let chainId = chainConfig.id
   let startBlock = chainConfig.startBlock
@@ -205,8 +253,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
   let currentLogIndex = ref(0)
 
   let items = []
+  // Coordinate "block:logIndex" -> the index of the first item that claimed it,
+  // used to reject two items resolving to the same (block, logIndex).
+  let seenCoordinates = Dict.make()
 
-  simulateItems->Array.forEach(rawJson => {
+  simulateItems->Array.forEachWithIndex((rawJson, itemIndex) => {
     let raw = rawJson->(Utils.magic: JSON.t => rawSimulateItem)
 
     switch (raw->getContract, raw->getEvent) {
@@ -230,44 +281,41 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       }
       let params = paramsJson->S.convertOrThrow(eventConfig.simulateParamsSchema)
 
+      // An explicit logIndex advances the auto-increment counter past itself, so a
+      // later item that omits logIndex picks up after it instead of colliding.
       let logIndex = switch item.logIndex {
-      | Some(li) => li
+      | Some(li) =>
+        if li >= currentLogIndex.contents {
+          currentLogIndex := li + 1
+        }
+        li
       | None =>
         let li = currentLogIndex.contents
         currentLogIndex := li + 1
         li
       }
 
-      let srcAddress = switch item.srcAddress {
-      | Some(addr) => addr
-      | None =>
-        // Use first address from contract config
-        let addr = ref(Address.unsafeFromString("0x0000000000000000000000000000000000000000"))
-        chainConfig.contracts->Array.forEach(contract => {
-          if contract.name === contractName {
-            switch contract.addresses->Array.get(0) {
-            | Some(a) => addr := a
-            | None => ()
-            }
-          }
-        })
-        addr.contents
-      }
+      let srcAddress = deriveSrcAddress(
+        ~providedSrcAddress=item.srcAddress,
+        ~eventConfig,
+        ~chainConfig,
+        ~config,
+      )
 
       let rawItem = rawJson->(Utils.magic: JSON.t => {..})
       let blockJson: option<JSON.t> =
         rawItem["block"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
       let transactionJson: option<JSON.t> =
         rawItem["transaction"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
-      let (block, blockNumber, timestamp, blockHash) = switch config.ecosystem.name {
+      let (block, blockNumber) = switch config.ecosystem.name {
       | Fuel =>
         let block = parseFuelSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => fuelSimulateBlock)
-        (block, blockFields.height, blockFields.time, blockFields.id)
+        (block, blockFields.height)
       | Evm =>
         let block = parseEvmSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => evmSimulateBlock)
-        (block, blockFields.number, blockFields.timestamp, blockFields.hash)
+        (block, blockFields.number)
       | Svm => JsError.throwWithMessage("simulate is not supported for SVM ecosystem")
       }
       let transaction = switch config.ecosystem.name {
@@ -279,15 +327,43 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       // Update currentBlock for subsequent items
       currentBlock := blockNumber
 
+      // 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}`
+      switch seenCoordinates->Dict.get(coordinate) {
+      | Some(firstIndex) =>
+        JsError.throwWithMessage(
+          `simulate: items at index ${firstIndex->Int.toString} and ${itemIndex->Int.toString} on chain ${chainId->Int.toString} both resolve to block ${blockNumber->Int.toString}, logIndex ${logIndex->Int.toString}. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`,
+        )
+      | 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({
-          eventConfig,
-          timestamp,
+          onEventRegistration,
           chain,
           blockNumber,
-          blockHash,
           logIndex,
+          // Simulate keeps the transaction inline on the payload, so the store
+          // key is unused.
+          transactionIndex: 0,
           payload: (
             {
               contractName: eventConfig.contractName,
@@ -314,7 +390,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
 
 // Apply simulate source config from processConfig JSON to a Config.t
 // This patches chainMap entries that have simulate items with CustomSources
-let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
+let patchConfig = (
+  ~config: Config.t,
+  ~processConfig: JSON.t,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
+): Config.t => {
   let processChains: option<dict<JSON.t>> =
     (processConfig->(Utils.magic: JSON.t => {..}))["chains"]->Nullable.toOption
   switch processChains {
@@ -327,11 +407,31 @@ let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
         let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
-          let items = parse(~simulateItems, ~config, ~chainConfig)
+          let chainRegistrations = switch registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(
+            chainIdStr,
+          ) {
+          | Some(registrations) => registrations
+          | None =>
+            let registrations: HandlerRegister.chainRegistrations = {
+              onEventRegistrations: [],
+              onBlockRegistrations: [],
+            }
+            registrationsByChainId->Dict.set(chainIdStr, registrations)
+            registrations
+          }
           let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
           let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
+          // Parse with the process's startBlock so items default into the range
+          // the source will be queried over; the source now filters by range.
+          let chainConfig = {...chainConfig, startBlock, endBlock}
+          let items = parse(
+            ~simulateItems,
+            ~config,
+            ~chainConfig,
+            ~onEventRegistrations=chainRegistrations.onEventRegistrations,
+          )
           let source = SimulateSource.make(~items, ~endBlock, ~chain)
-          {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
+          {...chainConfig, sourceConfig: Config.CustomSources([source])}
         | None => chainConfig
         }
       | None => chainConfig