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

package/src/CrossChainState.res.mjs

@@ -7,9 +7,7 @@ import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
-import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
@@ -17,13 +15,13 @@ function calculateTargetBufferSize() {
   if (Env.targetBufferSize !== undefined) {
     return Env.targetBufferSize;
   } else {
-    return 100000;
+    return 50000;
   }
 }
 
 function make(chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
-      Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
+      Env.targetBufferSize !== undefined ? Env.targetBufferSize : 50000
     );
   let crossChainState = {
     chainStates: chainStates,
@@ -95,12 +93,12 @@ function enterReorgThreshold(crossChainState) {
   crossChainState.isInReorgThreshold = true;
 }
 
-function applyBatchProgress(crossChainState, batch) {
+function applyBatchProgress(crossChainState, batch, blockTimestampName) {
   let chainIds = crossChainState.chainIds;
   let everyChainCaughtUp = true;
   for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[chainIds[i]];
-    ChainState.applyBatchProgress(cs, batch);
+    ChainState.applyBatchProgress(cs, batch, blockTimestampName);
     if (!(ChainState.hasProcessedToEndblock(cs) || ChainState.isProgressAtHead(cs))) {
       everyChainCaughtUp = false;
     }
@@ -135,72 +133,59 @@ function totalReservedSize(crossChainState) {
   return total;
 }
 
-function compareByProgress(a, b) {
-  return Primitive_float.compare(a.progress, b.progress);
-}
-
 async function checkAndFetch(crossChainState, dispatchChain) {
-  let remaining = Primitive_int.max(0, (crossChainState.targetBufferSize - totalReadyCount(crossChainState) | 0) - (totalReservedSize(crossChainState) | 0) | 0);
-  let chainIds = crossChainState.chainIds;
+  let remaining = {
+    contents: Primitive_float.max(0, crossChainState.targetBufferSize - totalReadyCount(crossChainState) - totalReservedSize(crossChainState))
+  };
   let actionByChain = {};
-  let candidates = [];
-  for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
-    let chainId = chainIds[i];
-    let cs = crossChainState.chainStates[chainId];
-    let action = ChainState.getNextQuery(cs, remaining);
+  priorityOrder(crossChainState).forEach(cs => {
+    let chainId = ChainState.chainConfig(cs).id;
+    let chainTargetItems = remaining.contents + ChainState.pendingBudget(cs);
+    let action = ChainState.getNextQuery(cs, chainTargetItems);
     if (typeof action !== "object") {
+      if (action === "WaitingForNewBlock") {
+        actionByChain[chainId] = action;
+        return;
+      }
       actionByChain[chainId] = action;
+      return;
     } else {
-      actionByChain[chainId] = "NothingToQuery";
-      action._0.forEach(query => {
-        query.chainId = chainId;
-        query.progress = ChainState.getProgressPercentageAt(cs, query.fromBlock);
-        candidates.push(query);
+      let queries = action._0;
+      let consumed = Stdlib_Array.reduce(queries, 0, (acc, query) => acc + query.itemsTarget);
+      let partitions = {};
+      queries.forEach(query => {
+        partitions[query.partitionId] = {
+          fromBlock: query.fromBlock,
+          targetBlock: query.toBlock,
+          targetEvents: Math.round(query.itemsTarget) | 0
+        };
       });
-    }
-  }
-  candidates.sort(compareByProgress);
-  let admittedByChain = {};
-  let running = 0;
-  let idx = 0;
-  while (running < remaining && idx < candidates.length) {
-    let query = candidates[idx];
-    Utils.Dict.push(admittedByChain, query.chainId.toString(), query);
-    running = running + query.estResponseSize;
-    idx = idx + 1 | 0;
-  };
-  Stdlib_Dict.forEachWithKey(admittedByChain, (queries, chainId) => {
-    let partitions = {};
-    queries.forEach(query => {
-      partitions[query.partitionId] = {
-        fromBlock: query.fromBlock,
-        targetBlock: query.toBlock
+      Logging.trace({
+        msg: "Started querying",
+        chainId: chainId,
+        partitions: partitions
+      });
+      actionByChain[chainId] = {
+        TAG: "Ready",
+        _0: queries
       };
-    });
-    Logging.trace({
-      msg: "Started querying",
-      chainId: Stdlib_Int.fromString(chainId, undefined),
-      partitions: partitions
-    });
-    actionByChain[chainId] = {
-      TAG: "Ready",
-      _0: queries
-    };
-    let chainId$1 = Stdlib_Int.fromString(chainId, undefined);
-    ChainState.startFetchingQueries(crossChainState.chainStates[chainId$1], queries);
+      ChainState.startFetchingQueries(cs, queries);
+      remaining.contents = Primitive_float.max(0, remaining.contents - consumed);
+      return;
+    }
   });
   let promises = [];
-  for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
-    let chainId$1 = chainIds[i$1];
-    let action$1 = actionByChain[chainId$1];
-    if (action$1 !== undefined) {
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let chainId = crossChainState.chainIds[i];
+    let action = actionByChain[chainId];
+    if (action !== undefined) {
       let exit = 0;
-      if (typeof action$1 === "object" || action$1 === "WaitingForNewBlock") {
+      if (typeof action === "object" || action === "WaitingForNewBlock") {
         exit = 1;
       }
       if (exit === 1) {
-        let chain = ChainMap.Chain.makeUnsafe(chainId$1);
-        promises.push(dispatchChain(chain, action$1));
+        let chain = ChainMap.Chain.makeUnsafe(chainId);
+        promises.push(dispatchChain(chain, action));
       }
     }
   }

package/src/CrossChainState.resi

@@ -29,7 +29,7 @@ let createBatch: (
   ~isRollback: bool,
 ) => Batch.t
 let enterReorgThreshold: t => unit
-let applyBatchProgress: (t, ~batch: Batch.t) => unit
+let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
 
 // Fetch control.
 let priorityOrder: t => array<ChainState.t>

package/src/Ecosystem.res

@@ -69,12 +69,12 @@ let getItemLogger = {
     | None =>
       let logger = switch item {
       | Internal.Event(_) => ecosystem.toEventLogger(item->Internal.castUnsafeEventItem)
-      | Block({blockNumber, onBlockConfig}) =>
+      | Block({blockNumber, onBlockRegistration}) =>
         Logging.createChildFrom(
           ~logger=ecosystem.logger,
           ~params={
-            "onBlock": onBlockConfig.name,
-            "chainId": onBlockConfig.chainId,
+            "onBlock": onBlockRegistration.name,
+            "chainId": onBlockRegistration.chainId,
             "block": blockNumber,
           },
         )

package/src/Ecosystem.res.mjs

@@ -26,10 +26,10 @@ function getItemLogger(item, ecosystem) {
   if (item.kind === 0) {
     logger$1 = ecosystem.toEventLogger(item);
   } else {
-    let onBlockConfig = item.onBlockConfig;
+    let onBlockRegistration = item.onBlockRegistration;
     logger$1 = Logging.createChildFrom(ecosystem.logger, {
-      onBlock: onBlockConfig.name,
-      chainId: onBlockConfig.chainId,
+      onBlock: onBlockRegistration.name,
+      chainId: onBlockRegistration.chainId,
       block: item.blockNumber
     });
   }

package/src/Envio.res

@@ -66,18 +66,21 @@ type svmLog = {
   message: string,
 }
 
-/** Block context for a matched instruction. `time`/`hash` follow the
- EVM/Fuel field names so the shared `Ecosystem.t` getters in `Svm.res` read
- them uniformly. */
+/** Block context for a matched instruction. `slot`/`hash` are always present;
+ `time` can still be absent — HyperSync/Solana may not report a block time for
+ every slot. Every other field is opt-in via `field_selection.block_fields`,
+ materialised from the per-chain block store at batch prep. */
 type svmInstructionBlock = {
   /** Slot this instruction's block was matched in. */
   slot: int,
-  /** Unix block time (seconds). `0` when HyperSync didn't return a block
-   for this instruction's slot. */
-  time: int,
-  /** Block hash. Currently always empty — populated by the future
-   reorg-guard `queryBlockHash(slot)` route. */
+  /** Unix block time (seconds). */
+  time?: int,
   hash: string,
+  /** Block height (distinct from slot). Absent when not selected via
+   `field_selection.block_fields`. */
+  height?: int,
+  parentSlot?: int,
+  parentHash?: string,
 }
 
 /** The per-instruction payload handlers receive as their `instruction`
@@ -111,7 +114,9 @@ type svmInstruction = {
   /** Program log entries scoped to this instruction. Absent when the
    per-instruction `include_logs` flag is `false`. */
   logs?: array<svmLog>,
-  block: svmInstructionBlock,
+  // Omitted on construction; materialised onto the payload at batch prep,
+  // before a handler ever reads it.
+  block?: svmInstructionBlock,
 }
 
 /** Arguments passed to handlers registered via `indexer.onInstruction`. */

package/src/EventConfigBuilder.res

@@ -378,20 +378,54 @@ let buildEvmEventConfig = (
   ~eventName: string,
   ~sighash: string,
   ~params: array<paramMeta>,
+  ~blockFields: option<array<Internal.evmBlockField>>=?,
+  ~transactionFields: option<array<Internal.evmTransactionField>>=?,
+  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>=Utils.Set.make(),
+  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>=Utils.Set.make(),
+): Internal.evmEventConfig => {
+  let topicCount = params->Array.reduce(1, (acc, p) => p.indexed ? acc + 1 : acc)
+
+  let (selectedBlockFields, selectedTransactionFields) = resolveFieldSelection(
+    ~blockFields,
+    ~transactionFields,
+    ~globalBlockFieldsSet,
+    ~globalTransactionFieldsSet,
+  )
+
+  {
+    id: sighash ++ "_" ++ topicCount->Int.toString,
+    name: eventName,
+    contractName,
+    paramsRawEventSchema: buildParamsSchema(params),
+    simulateParamsSchema: buildSimulateParamsSchema(params),
+    selectedBlockFields,
+    selectedTransactionFields,
+    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
+    blockFieldMask: Evm.eventBlockFieldMask(
+      selectedBlockFields->(
+        Utils.magic: Utils.Set.t<Internal.evmBlockField> => Utils.Set.t<string>
+      ),
+    ),
+    sighash,
+    topicCount,
+    paramsMetadata: params,
+  }
+}
+
+// Enrich an EVM definition into a per-(event,chain) registration: resolve the
+// registered `where` (with `probeChainId`) into the lazy `getEventFiltersOrThrow`
+// closure + address filters, and override `startBlock` with `where.block._gte`.
+let buildEvmOnEventRegistration = (
+  ~eventConfig: Internal.evmEventConfig,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
   ~eventFilters: option<JSON.t>,
   ~probeChainId: int,
   ~onEventBlockFilterSchema: S.t<option<unknown>>,
-  ~blockFields: option<array<Internal.evmBlockField>>=?,
-  ~transactionFields: option<array<Internal.evmTransactionField>>=?,
   ~startBlock: option<int>=?,
-  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>=Utils.Set.make(),
-  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>=Utils.Set.make(),
-): Internal.evmEventConfig => {
-  let topicCount = params->Array.reduce(1, (acc, p) => p.indexed ? acc + 1 : acc)
-  let indexedParams = params->Array.filter(p => p.indexed)
+): Internal.evmOnEventRegistration => {
+  let indexedParams = eventConfig.paramsMetadata->Array.filter(p => p.indexed)
 
   let {
     getEventFiltersOrThrow,
@@ -400,9 +434,9 @@ let buildEvmEventConfig = (
     startBlock: whereStartBlock,
   } = LogSelection.parseEventFiltersOrThrow(
     ~eventFilters,
-    ~sighash,
+    ~sighash=eventConfig.sighash,
     ~params=indexedParams->Array.map(p => p.name),
-    ~contractName,
+    ~contractName=eventConfig.contractName,
     ~probeChainId,
     ~onEventBlockFilterSchema,
     ~topic1=?indexedParams->Array.get(0)->Option.map(buildTopicGetter),
@@ -410,46 +444,32 @@ let buildEvmEventConfig = (
     ~topic3=?indexedParams->Array.get(2)->Option.map(buildTopicGetter),
   )
 
-  // `where.block.number._gte` overrides the contract-level startBlock
-  // when present. The user opts into this explicitly in handler code so
-  // it should win over the `config.yaml` contract `start_block`; absent
-  // `where.block`, the caller's contract-level value passes through.
+  // `where.block.number._gte` overrides the contract-level startBlock when
+  // present (an explicit per-event opt-in that wins over `config.yaml`);
+  // otherwise the contract/chain value passes through.
   let resolvedStartBlock = switch whereStartBlock {
   | Some(_) as sb => sb
   | None => startBlock
   }
 
-  let (selectedBlockFields, selectedTransactionFields) = resolveFieldSelection(
-    ~blockFields,
-    ~transactionFields,
-    ~globalBlockFieldsSet,
-    ~globalTransactionFieldsSet,
-  )
-
   {
-    id: sighash ++ "_" ++ topicCount->Int.toString,
-    name: eventName,
-    contractName,
+    eventConfig: (eventConfig :> Internal.eventConfig),
     isWildcard,
     handler,
     contractRegister,
-    paramsRawEventSchema: buildParamsSchema(params),
-    simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
     clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups, ~isWildcard),
-    dependsOnAddresses: !isWildcard || filterByAddresses,
+    dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
     startBlock: resolvedStartBlock,
-    selectedBlockFields,
-    selectedTransactionFields,
-    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
-    sighash,
-    topicCount,
-    paramsMetadata: params,
   }
 }
 
-// ============== Build Fuel event config ==============
+// ============== Build SVM instruction event config ==============
+
+// Always-included block fields (slot, time, hash) are prepended at runtime so
+// they're always present regardless of config.
+let alwaysIncludedSvmBlockFields: array<Internal.svmBlockField> = [Slot, Time, Hash]
 
 let buildSvmInstructionEventConfig = (
   ~contractName: string,
@@ -459,15 +479,12 @@ let buildSvmInstructionEventConfig = (
   ~discriminatorByteLen: int,
   ~includeLogs: bool,
   ~transactionFields: array<Internal.svmTransactionField>=[],
+  ~blockFields: array<Internal.svmBlockField>=[],
   ~accountFilters: array<Internal.svmAccountFilterGroup>,
   ~isInner: option<bool>,
-  ~isWildcard: bool,
-  ~handler: option<Internal.handler>,
-  ~contractRegister: option<Internal.contractRegister>,
   ~accounts: array<string>=[],
   ~args: JSON.t=JSON.Null,
   ~definedTypes: JSON.t=JSON.Null,
-  ~startBlock: option<int>=?,
 ): Internal.svmInstructionEventConfig => {
   let paramsSchema =
     S.json(~validate=false)
@@ -480,6 +497,12 @@ let buildSvmInstructionEventConfig = (
     Utils.Set.fromArray(transactionFields)->(
       Utils.magic: Utils.Set.t<Internal.svmTransactionField> => Utils.Set.t<string>
     )
+  let selectedBlockFields = Utils.Set.fromArray(
+    Array.concat(alwaysIncludedSvmBlockFields, blockFields),
+  )
+  let blockFieldMask = Svm.eventBlockFieldMask(
+    selectedBlockFields->(Utils.magic: Utils.Set.t<Internal.svmBlockField> => Utils.Set.t<string>),
+  )
   {
     id: switch discriminator {
     | Some(d) => d
@@ -487,21 +510,16 @@ let buildSvmInstructionEventConfig = (
     },
     name: instructionName,
     contractName,
-    isWildcard,
-    handler,
-    contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
-    startBlock,
     programId,
     discriminator,
     discriminatorByteLen,
     includeLogs,
     selectedTransactionFields,
     transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
+    selectedBlockFields,
+    blockFieldMask,
     accountFilters,
     isInner,
     accounts,
@@ -510,16 +528,33 @@ let buildSvmInstructionEventConfig = (
   }
 }
 
+// Enrich an SVM definition into a registration. SVM has no `where`; only the
+// handler binding + wildcard-derived address gate are registration state.
+let buildSvmOnEventRegistration = (
+  ~eventConfig: Internal.svmInstructionEventConfig,
+  ~isWildcard: bool,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~startBlock: option<int>=?,
+): Internal.svmOnEventRegistration => {
+  eventConfig: (eventConfig :> Internal.eventConfig),
+  handler,
+  contractRegister,
+  isWildcard,
+  filterByAddresses: false,
+  dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
+  clientAddressFilter: ?buildAddressFilter([], ~isWildcard, ~srcAddressExpr="event.programId"),
+  startBlock,
+}
+
+// ============== Build Fuel event config ==============
+
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,
   ~kind: string,
   ~sighash: string,
   ~rawAbi: JSON.t,
-  ~isWildcard: bool,
-  ~handler: option<Internal.handler>,
-  ~contractRegister: option<Internal.contractRegister>,
-  ~startBlock: option<int>=?,
 ): Internal.fuelEventConfig => {
   let fuelKind = switch kind {
   | "logData" =>
@@ -559,18 +594,32 @@ let buildFuelEventConfig = (
     },
     name: eventName,
     contractName,
-    isWildcard,
-    handler,
-    contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
-    startBlock,
-    // Fuel keeps the transaction inline on the payload; nothing to materialise.
+    // Fuel keeps the transaction and block inline on the payload; nothing to
+    // materialise.
     selectedTransactionFields: Utils.Set.make(),
     transactionFieldMask: 0.,
+    blockFieldMask: 0.,
     kind: fuelKind,
   }
 }
+
+// Enrich a Fuel definition into a registration (handler binding +
+// wildcard-derived address gate; Fuel never filters by addresses).
+let buildFuelOnEventRegistration = (
+  ~eventConfig: Internal.fuelEventConfig,
+  ~isWildcard: bool,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~startBlock: option<int>=?,
+): Internal.fuelOnEventRegistration => {
+  eventConfig: (eventConfig :> Internal.eventConfig),
+  handler,
+  contractRegister,
+  isWildcard,
+  filterByAddresses: false,
+  dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses=false),
+  clientAddressFilter: ?buildAddressFilter([], ~isWildcard),
+  startBlock,
+}

package/src/EventConfigBuilder.res.mjs

@@ -280,7 +280,7 @@ function buildAddressFilter(groups, isWildcard, srcAddressExprOpt) {
   return Stdlib_Option.map(buildAddressFilterBody(groups, isWildcard, srcAddressExpr), compileAddressFilter);
 }
 
-function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, blockFields, transactionFields, startBlock, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
+function buildEvmEventConfig(contractName, eventName, sighash, params, blockFields, transactionFields, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
   let globalBlockFieldsSet = globalBlockFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalBlockFieldsSetOpt) : new Set();
   let globalTransactionFieldsSet = globalTransactionFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalTransactionFieldsSetOpt) : new Set();
   let topicCount = Stdlib_Array.reduce(params, 1, (acc, p) => {
@@ -290,58 +290,70 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
       return acc;
     }
   });
-  let indexedParams = params.filter(p => p.indexed);
-  let match = LogSelection.parseEventFiltersOrThrow(eventFilters, sighash, indexedParams.map(p => p.name), contractName, probeChainId, onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], buildTopicGetter), Stdlib_Option.map(indexedParams[1], buildTopicGetter), Stdlib_Option.map(indexedParams[2], buildTopicGetter));
-  let whereStartBlock = match.startBlock;
-  let filterByAddresses = match.filterByAddresses;
-  let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
-  let match$1 = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
-  let selectedTransactionFields = match$1[1];
+  let match = resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet);
+  let selectedTransactionFields = match[1];
+  let selectedBlockFields = match[0];
   return {
     id: sighash + "_" + topicCount.toString(),
     name: eventName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: filterByAddresses,
-    dependsOnAddresses: !isWildcard || filterByAddresses,
-    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
-    startBlock: resolvedStartBlock,
     selectedTransactionFields: selectedTransactionFields,
     transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
-    getEventFiltersOrThrow: match.getEventFiltersOrThrow,
-    selectedBlockFields: match$1[0],
+    blockFieldMask: Evm.eventBlockFieldMask(selectedBlockFields),
+    selectedBlockFields: selectedBlockFields,
     sighash: sighash,
     topicCount: topicCount,
     paramsMetadata: params
   };
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, startBlock) {
+  let indexedParams = eventConfig.paramsMetadata.filter(p => p.indexed);
+  let match = LogSelection.parseEventFiltersOrThrow(eventFilters, eventConfig.sighash, indexedParams.map(p => p.name), eventConfig.contractName, probeChainId, onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], buildTopicGetter), Stdlib_Option.map(indexedParams[1], buildTopicGetter), Stdlib_Option.map(indexedParams[2], buildTopicGetter));
+  let whereStartBlock = match.startBlock;
+  let filterByAddresses = match.filterByAddresses;
+  let resolvedStartBlock = whereStartBlock !== undefined ? whereStartBlock : startBlock;
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: filterByAddresses,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, filterByAddresses),
+    clientAddressFilter: buildAddressFilter(match.addressFilterParamGroups, isWildcard, undefined),
+    startBlock: resolvedStartBlock,
+    getEventFiltersOrThrow: match.getEventFiltersOrThrow
+  };
+}
+
+let alwaysIncludedSvmBlockFields = [
+  "slot",
+  "time",
+  "hash"
+];
+
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, blockFieldsOpt, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
   let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
+  let blockFields = blockFieldsOpt !== undefined ? blockFieldsOpt : [];
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
   let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
   let selectedTransactionFields = new Set(transactionFields);
+  let selectedBlockFields = new Set(alwaysIncludedSvmBlockFields.concat(blockFields));
+  let blockFieldMask = Svm.eventBlockFieldMask(selectedBlockFields);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    startBlock: startBlock,
     selectedTransactionFields: selectedTransactionFields,
     transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
+    blockFieldMask: blockFieldMask,
+    selectedBlockFields: selectedBlockFields,
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
@@ -354,7 +366,20 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
   };
 }
 
-function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
+function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
+    clientAddressFilter: buildAddressFilter([], isWildcard, "event.programId"),
+    startBlock: startBlock
+  };
+}
+
+function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
   let fuelKind;
   switch (kind) {
     case "burn" :
@@ -401,21 +426,28 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     id: tmp,
     name: eventName,
     contractName: contractName,
-    isWildcard: isWildcard,
-    filterByAddresses: false,
-    dependsOnAddresses: !isWildcard,
-    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
-    handler: handler,
-    contractRegister: contractRegister,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    startBlock: startBlock,
     selectedTransactionFields: new Set(),
     transactionFieldMask: 0,
+    blockFieldMask: 0,
     kind: fuelKind
   };
 }
 
+function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
+  return {
+    eventConfig: eventConfig,
+    handler: handler,
+    contractRegister: contractRegister,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
+    clientAddressFilter: buildAddressFilter([], isWildcard, undefined),
+    startBlock: startBlock
+  };
+}
+
 export {
   paramMetaSchema,
   normalizeOrThrow,
@@ -435,7 +467,11 @@ export {
   buildAddressFilterBody,
   buildAddressFilter,
   buildEvmEventConfig,
+  buildEvmOnEventRegistration,
+  alwaysIncludedSvmBlockFields,
   buildSvmInstructionEventConfig,
+  buildSvmOnEventRegistration,
   buildFuelEventConfig,
+  buildFuelOnEventRegistration,
 }
 /* paramMetaSchema Not a pure module */