envio 3.3.0-alpha.0 → 3.3.0-alpha.10

package/src/IndexerState.res.mjs

@@ -18,6 +18,7 @@ import * as CrossChainState from "./CrossChainState.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 function make() {
   let intervalMillis = Env.ThrottleWrites.pruneStaleDataIntervalMillis;
@@ -53,9 +54,7 @@ function get(self, entityName) {
   }
 }
 
-function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime, maxBackfillConcurrencyOpt, maxRealtimeConcurrencyOpt, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError) {
-  let maxBackfillConcurrency = maxBackfillConcurrencyOpt !== undefined ? maxBackfillConcurrencyOpt : Env.maxBackfillConcurrency;
-  let maxRealtimeConcurrency = maxRealtimeConcurrencyOpt !== undefined ? maxRealtimeConcurrencyOpt : Env.maxRealtimeConcurrency;
+function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let committedCheckpointId = committedCheckpointIdOpt !== undefined ? committedCheckpointIdOpt : Internal.initialCheckpointId;
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
@@ -84,7 +83,7 @@ function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime
     chainMetaDirty: false,
     chainMetaThrottler: chainMetaThrottler,
     isProcessing: false,
-    crossChainState: CrossChainState.make(chainStates, isInReorgThreshold, isRealtime, maxBackfillConcurrency, maxRealtimeConcurrency, targetBufferSize),
+    crossChainState: CrossChainState.make(chainStates, isInReorgThreshold, isRealtime, targetBufferSize),
     rollbackState: "NoRollback",
     indexerStartTime: new Date(),
     writeThrottlers: make(),
@@ -93,16 +92,15 @@ function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
     isStopped: false,
-    epoch: 0
+    epoch: 0,
+    simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config)
   };
 }
 
-function makeFromDbState(config, persistence, initialState, registrations, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, maxBackfillConcurrencyOpt, maxRealtimeConcurrencyOpt, targetBufferSizeOpt, onError) {
+function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
-  let maxBackfillConcurrency = maxBackfillConcurrencyOpt !== undefined ? maxBackfillConcurrencyOpt : Env.maxBackfillConcurrency;
-  let maxRealtimeConcurrency = maxRealtimeConcurrencyOpt !== undefined ? maxRealtimeConcurrencyOpt : Env.maxRealtimeConcurrency;
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let isInReorgThreshold = initialState.cleanRun ? false : initialState.chains.some(chain => {
       let progressBlockNumber = chain.progressBlockNumber;
@@ -125,7 +123,7 @@ function makeFromDbState(config, persistence, initialState, registrations, isDev
   initialState.chains.forEach(resumedChainState => {
     let chain = Config.getChain(config, resumedChainState.id);
     let chainConfig = ChainMap.get(config.chainMap, chain);
-    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, reducedPollingInterval);
+    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
   });
   let allChainsReady = {
     contents: initialState.chains.length !== 0
@@ -144,7 +142,7 @@ function makeFromDbState(config, persistence, initialState, registrations, isDev
   if (allChainsReady.contents) {
     Prometheus.ProgressReady.setAllReady();
   }
-  return make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime, maxBackfillConcurrency, maxRealtimeConcurrency, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError);
+  return make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError);
 }
 
 function isStale(state, stateId) {
@@ -233,7 +231,7 @@ function invalidateInflight(state) {
 }
 
 function applyBatchProgress(state, batch) {
-  CrossChainState.applyBatchProgress(state.crossChainState, batch);
+  CrossChainState.applyBatchProgress(state.crossChainState, batch, state.config.ecosystem.blockTimestampName);
 }
 
 function isProcessing(state) {
@@ -352,6 +350,10 @@ function pruneStaleEntityHistoryThrottler(state) {
   return state.writeThrottlers.pruneStaleEntityHistory;
 }
 
+function simulateDeadInputTracker(state) {
+  return state.simulateDeadInputTracker;
+}
+
 function queueProcessedBatch(state, batch) {
   state.processedBatches.push(batch);
   let checkpointId = Utils.$$Array.last(batch.checkpointIds);
@@ -531,6 +533,7 @@ export {
   isStopped,
   epoch,
   pruneStaleEntityHistoryThrottler,
+  simulateDeadInputTracker,
   queueProcessedBatch,
   drainBatchRun,
   takeRollback,

package/src/IndexerState.resi

@@ -32,8 +32,6 @@ let make: (
   ~chainStates: dict<ChainState.t>,
   ~isInReorgThreshold: bool,
   ~isRealtime: bool,
-  ~maxBackfillConcurrency: int=?,
-  ~maxRealtimeConcurrency: int=?,
   ~targetBufferSize: int=?,
   ~committedCheckpointId: Internal.checkpointId=?,
   ~isDevelopmentMode: bool=?,
@@ -46,13 +44,11 @@ let makeFromDbState: (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~initialState: Persistence.initialState,
-  ~registrations: HandlerRegister.registrations,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
   ~isDevelopmentMode: bool=?,
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,
   ~reducedPollingInterval: int=?,
-  ~maxBackfillConcurrency: int=?,
-  ~maxRealtimeConcurrency: int=?,
   ~targetBufferSize: int=?,
   ~onError: ErrorHandling.t => unit,
 ) => t
@@ -111,6 +107,7 @@ let exitAfterFirstEventBlock: t => bool
 let isStopped: t => bool
 let epoch: t => int
 let pruneStaleEntityHistoryThrottler: t => Throttler.t
+let simulateDeadInputTracker: t => option<SimulateDeadInputTracker.t>
 
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit

package/src/IndexingAddresses.res

@@ -0,0 +1,108 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t = dict<indexingAddress>
+
+let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: option<int>) => {
+  Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
+}
+
+let makeContractConfigs = (~onEventRegistrations: array<Internal.onEventRegistration>): dict<
+  contractConfig,
+> => {
+  let contractConfigs: dict<contractConfig> = Dict.make()
+  onEventRegistrations->Array.forEach(reg => {
+    let contractName = reg.eventConfig.contractName
+    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(contractName) {
+    | Some({startBlock}) =>
+      contractConfigs->Dict.set(
+        contractName,
+        {
+          startBlock: switch (startBlock, reg.startBlock) {
+          | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
+          | (Some(_) as s, None) | (None, Some(_) as s) => s
+          | (None, None) => None
+          },
+        },
+      )
+    | None =>
+      contractConfigs->Dict.set(
+        contractName,
+        {
+          startBlock: reg.startBlock,
+        },
+      )
+    }
+  })
+  contractConfigs
+}
+
+let makeIndexingAddress = (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+): indexingAddress => {
+  let contractStartBlock = switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(
+    contract.contractName,
+  ) {
+  | Some({startBlock}) => startBlock
+  | None => None
+  }
+  {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(
+      ~registrationBlock=contract.registrationBlock,
+      ~contractStartBlock,
+    ),
+  }
+}
+
+let make = (
+  ~contractConfigs: dict<contractConfig>,
+  ~addresses: array<Internal.indexingAddress>,
+): t => {
+  let indexingAddresses = Dict.make()
+  addresses->Array.forEach(contract => {
+    indexingAddresses->Dict.set(
+      contract.address->Address.toString,
+      makeIndexingAddress(~contract, ~contractConfigs),
+    )
+  })
+  indexingAddresses
+}
+
+let get = (indexingAddresses: t, address) =>
+  indexingAddresses->Utils.Dict.dangerouslyGetNonOption(address)
+
+let size = (indexingAddresses: t) => indexingAddresses->Utils.Dict.size
+
+let getContractAddresses = (indexingAddresses: t, ~contractName): array<Address.t> => {
+  let addresses = []
+  indexingAddresses->Utils.Dict.forEach(ia => {
+    if ia.contractName === contractName {
+      addresses->Array.push(ia.address)
+    }
+  })
+  addresses
+}
+
+// Underlying dict for the precompiled `clientAddressFilter` only — it does raw
+// `indexingAddresses[srcAddress]` access in generated JS and can't take the opaque
+// type. Don't reach for this elsewhere; use the domain accessors above.
+let rawForFilter = (indexingAddresses: t): dict<indexingAddress> => indexingAddresses
+
+let register = (indexingAddresses: t, additions: dict<indexingAddress>) => {
+  let _ = Utils.Dict.mergeInPlace(indexingAddresses, additions)
+}
+
+let rollbackInPlace = (indexingAddresses: t, ~targetBlockNumber: int): unit => {
+  // forEachWithKey is a `for..in`, so deleting the key currently being visited is
+  // safe — it doesn't affect enumeration of the remaining keys.
+  indexingAddresses->Utils.Dict.forEachWithKey((indexingContract, address) => {
+    if indexingContract.registrationBlock > targetBlockNumber {
+      indexingAddresses->Utils.Dict.deleteInPlace(address)
+    }
+  })
+}

package/src/IndexingAddresses.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
+  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
+}
+
+function makeContractConfigs(onEventRegistrations) {
+  let contractConfigs = {};
+  onEventRegistrations.forEach(reg => {
+    let contractName = reg.eventConfig.contractName;
+    let match = contractConfigs[contractName];
+    if (match !== undefined) {
+      let startBlock = match.startBlock;
+      let match$1 = reg.startBlock;
+      contractConfigs[contractName] = {
+        startBlock: startBlock !== undefined ? (
+            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
+          ) : (
+            match$1 !== undefined ? match$1 : undefined
+          )
+      };
+      return;
+    }
+    contractConfigs[contractName] = {
+      startBlock: reg.startBlock
+    };
+  });
+  return contractConfigs;
+}
+
+function makeIndexingAddress(contract, contractConfigs) {
+  let match = contractConfigs[contract.contractName];
+  let contractStartBlock = match !== undefined ? match.startBlock : undefined;
+  return {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock)
+  };
+}
+
+function make(contractConfigs, addresses) {
+  let indexingAddresses = {};
+  addresses.forEach(contract => {
+    indexingAddresses[contract.address] = makeIndexingAddress(contract, contractConfigs);
+  });
+  return indexingAddresses;
+}
+
+function get(indexingAddresses, address) {
+  return indexingAddresses[address];
+}
+
+function size(indexingAddresses) {
+  return Utils.Dict.size(indexingAddresses);
+}
+
+function getContractAddresses(indexingAddresses, contractName) {
+  let addresses = [];
+  Utils.Dict.forEach(indexingAddresses, ia => {
+    if (ia.contractName === contractName) {
+      addresses.push(ia.address);
+      return;
+    }
+  });
+  return addresses;
+}
+
+function rawForFilter(indexingAddresses) {
+  return indexingAddresses;
+}
+
+function register(indexingAddresses, additions) {
+  Object.assign(indexingAddresses, additions);
+}
+
+function rollbackInPlace(indexingAddresses, targetBlockNumber) {
+  Utils.Dict.forEachWithKey(indexingAddresses, (indexingContract, address) => {
+    if (indexingContract.registrationBlock > targetBlockNumber) {
+      return Utils.Dict.deleteInPlace(indexingAddresses, address);
+    }
+  });
+}
+
+export {
+  deriveEffectiveStartBlock,
+  makeContractConfigs,
+  makeIndexingAddress,
+  make,
+  get,
+  size,
+  getContractAddresses,
+  rawForFilter,
+  register,
+  rollbackInPlace,
+}
+/* Utils Not a pure module */

package/src/IndexingAddresses.resi

@@ -0,0 +1,34 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t
+
+let deriveEffectiveStartBlock: (~registrationBlock: int, ~contractStartBlock: option<int>) => int
+
+let makeContractConfigs: (
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+) => dict<contractConfig>
+
+let makeIndexingAddress: (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+) => indexingAddress
+
+let make: (~contractConfigs: dict<contractConfig>, ~addresses: array<Internal.indexingAddress>) => t
+
+let get: (t, string) => option<indexingAddress>
+
+let size: t => int
+
+let getContractAddresses: (t, ~contractName: string) => array<Address.t>
+
+// Underlying dict for the precompiled `clientAddressFilter` only, which does raw
+// `indexingAddresses[srcAddress]` access in generated JS. Don't use elsewhere —
+// prefer the domain accessors so the opaque type stays enforced.
+let rawForFilter: t => dict<indexingAddress>
+
+let register: (t, dict<indexingAddress>) => unit
+
+// Deletes addresses registered after `targetBlockNumber` from the index in place.
+let rollbackInPlace: (t, ~targetBlockNumber: int) => unit