envio 3.1.2 → 3.2.1

package/src/EventConfigBuilder.res

@@ -309,6 +309,39 @@ let resolveFieldSelection = (
   (selectedBlockFields, selectedTransactionFields)
 }
 
+// ============== Client-side address filter ==============
+
+let compileAddressFilter: string => (
+  Internal.event,
+  int,
+  dict<Internal.indexingContract>,
+) => bool = %raw(`function (body) {
+  return new Function("event", "blockNumber", "indexingAddresses", body);
+}`)
+
+// Body of the client-side address filter for a DNF of address-filtered param
+// names (OR of AND-groups): keep the event only if some group's params are all
+// registered at or before the log's block. The DNF is fixed here, so it's
+// unrolled into one boolean expression — no per-event closure, loop, or array.
+// `None` when there's no address-param filter. Exposed for snapshotting.
+let buildAddressFilterBody = (groups: array<array<string>>): option<string> => {
+  switch groups {
+  | [] => None
+  | _ =>
+    let leaf = name =>
+      `(ic = indexingAddresses[p[${JSON.stringify(
+          JSON.String(name),
+        )}]]) !== undefined && ic.effectiveStartBlock <= blockNumber`
+    let groupExprs =
+      groups->Array.map(group => "(" ++ group->Array.map(leaf)->Array.join(" && ") ++ ")")
+    Some("var p = event.params, ic; return " ++ groupExprs->Array.join(" || ") ++ ";")
+  }
+}
+
+let buildAddressFilter = (groups: array<array<string>>): option<
+  (Internal.event, int, dict<Internal.indexingContract>) => bool,
+> => buildAddressFilterBody(groups)->Option.map(compileAddressFilter)
+
 // ============== Build complete EVM event config ==============
 
 let buildEvmEventConfig = (
@@ -334,6 +367,7 @@ let buildEvmEventConfig = (
   let {
     getEventFiltersOrThrow,
     filterByAddresses,
+    addressFilterParamGroups,
     startBlock: whereStartBlock,
   } = LogSelection.parseEventFiltersOrThrow(
     ~eventFilters,
@@ -374,6 +408,7 @@ let buildEvmEventConfig = (
     simulateParamsSchema: buildSimulateParamsSchema(params),
     getEventFiltersOrThrow,
     filterByAddresses,
+    clientAddressFilter: ?buildAddressFilter(addressFilterParamGroups),
     dependsOnAddresses: !isWildcard || filterByAddresses,
     startBlock: resolvedStartBlock,
     selectedBlockFields,
@@ -386,6 +421,58 @@ let buildEvmEventConfig = (
 
 // ============== Build Fuel event config ==============
 
+let buildSvmInstructionEventConfig = (
+  ~contractName: string,
+  ~instructionName: string,
+  ~programId: SvmTypes.Pubkey.t,
+  ~discriminator: option<string>,
+  ~discriminatorByteLen: int,
+  ~includeTransaction: bool,
+  ~includeLogs: bool,
+  ~includeTokenBalances: bool,
+  ~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)
+    ->Utils.Schema.coerceToJsonPgType
+    ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
+  {
+    id: switch discriminator {
+    | Some(d) => d
+    | None => "none"
+    },
+    name: instructionName,
+    contractName,
+    isWildcard,
+    handler,
+    contractRegister,
+    paramsRawEventSchema: paramsSchema,
+    simulateParamsSchema: paramsSchema,
+    filterByAddresses: false,
+    dependsOnAddresses: !isWildcard,
+    startBlock,
+    programId,
+    discriminator,
+    discriminatorByteLen,
+    includeTransaction,
+    includeLogs,
+    includeTokenBalances,
+    accountFilters,
+    isInner,
+    accounts,
+    args,
+    definedTypes,
+  }
+}
+
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,

package/src/EventConfigBuilder.res.mjs

@@ -251,6 +251,23 @@ function resolveFieldSelection(blockFields, transactionFields, globalBlockFields
   ];
 }
 
+let compileAddressFilter = (function (body) {
+  return new Function("event", "blockNumber", "indexingAddresses", body);
+});
+
+function buildAddressFilterBody(groups) {
+  if (groups.length === 0) {
+    return;
+  }
+  let leaf = name => `(ic = indexingAddresses[p[` + JSON.stringify(name) + `]]) !== undefined && ic.effectiveStartBlock <= blockNumber`;
+  let groupExprs = groups.map(group => "(" + group.map(leaf).join(" && ") + ")");
+  return "var p = event.params, ic; return " + groupExprs.join(" || ") + ";";
+}
+
+function buildAddressFilter(groups) {
+  return Stdlib_Option.map(buildAddressFilterBody(groups), compileAddressFilter);
+}
+
 function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcard, handler, contractRegister, eventFilters, probeChainId, onEventBlockFilterSchema, blockFields, transactionFields, startBlock, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
   let globalBlockFieldsSet = globalBlockFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalBlockFieldsSetOpt) : new Set();
   let globalTransactionFieldsSet = globalTransactionFieldsSetOpt !== undefined ? Primitive_option.valFromOption(globalTransactionFieldsSetOpt) : new Set();
@@ -274,6 +291,7 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
     isWildcard: isWildcard,
     filterByAddresses: filterByAddresses,
     dependsOnAddresses: !isWildcard || filterByAddresses,
+    clientAddressFilter: Stdlib_Option.map(buildAddressFilterBody(match.addressFilterParamGroups), compileAddressFilter),
     handler: handler,
     contractRegister: contractRegister,
     paramsRawEventSchema: buildParamsSchema(params),
@@ -288,6 +306,37 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   };
 }
 
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, includeTokenBalances, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+  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));
+  return {
+    id: discriminator !== undefined ? discriminator : "none",
+    name: instructionName,
+    contractName: contractName,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: !isWildcard,
+    handler: handler,
+    contractRegister: contractRegister,
+    paramsRawEventSchema: paramsSchema,
+    simulateParamsSchema: paramsSchema,
+    startBlock: startBlock,
+    programId: programId,
+    discriminator: discriminator,
+    discriminatorByteLen: discriminatorByteLen,
+    includeTransaction: includeTransaction,
+    includeLogs: includeLogs,
+    includeTokenBalances: includeTokenBalances,
+    accountFilters: accountFilters,
+    isInner: isInner,
+    accounts: accounts,
+    args: args,
+    definedTypes: definedTypes
+  };
+}
+
 function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
   let fuelKind;
   switch (kind) {
@@ -362,7 +411,11 @@ export {
   buildTopicGetter,
   alwaysIncludedBlockFields,
   resolveFieldSelection,
+  compileAddressFilter,
+  buildAddressFilterBody,
+  buildAddressFilter,
   buildEvmEventConfig,
+  buildSvmInstructionEventConfig,
   buildFuelEventConfig,
 }
 /* paramMetaSchema Not a pure module */

package/src/EventUtils.res

@@ -45,8 +45,8 @@ let packEventIndex = (~blockNumber, ~logIndex) => {
 //   let logIndexMask = 65535->BigInt.fromInt
 //   let logIndex = packedEventIndex->BigInt.bitwiseAnd(logIndexMask)
 //   {
-//     blockNumber: blockNumber->BigInt.toString->Belt.Int.fromString->Belt.Option.getUnsafe,
-//     logIndex: logIndex->BigInt.toString->Belt.Int.fromString->Belt.Option.getUnsafe,
+//     blockNumber: blockNumber->BigInt.toString->Int.fromString->Option.getUnsafe,
+//     logIndex: logIndex->BigInt.toString->Int.fromString->Option.getUnsafe,
 //   }
 // }
 

package/src/FetchState.res

@@ -1,9 +1,6 @@
-type contractConfig = {filterByAddresses: bool, startBlock: option<int>}
+type contractConfig = {startBlock: option<int>}
 
-type indexingAddress = {
-  ...Internal.indexingAddress,
-  effectiveStartBlock: int,
-}
+type indexingAddress = Internal.indexingContract
 
 let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: option<int>) => {
   Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
@@ -336,7 +333,7 @@ module OptimizedPartitions = {
     let _ = newPartitions->Array.sort(ascSortFn)
 
     let partitionsCount = newPartitions->Array.length
-    let idsInAscOrder = Belt.Array.makeUninitializedUnsafe(partitionsCount)
+    let idsInAscOrder = Utils.Array.jsArrayCreate(partitionsCount)
     let entities = Dict.make()
     for idx in 0 to partitionsCount - 1 {
       let p = newPartitions->Array.getUnsafe(idx)
@@ -639,7 +636,7 @@ let updateInternal = (
       let maxBlockNumber = switch switch mutItemsRef.contents {
       | Some(mutItems) => mutItems
       | None => fetchState.buffer
-      }->Belt.Array.get(fetchState.targetBufferSize - 1) {
+      }->Array.get(fetchState.targetBufferSize - 1) {
       | Some(item) => item->Internal.getItemBlockNumber
       | None =>
         switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
@@ -756,7 +753,6 @@ Returns OptimizedPartitions.t directly.
 */
 let createPartitionsFromIndexingAddresses = (
   ~registeringContractsByContract: dict<dict<indexingAddress>>,
-  ~contractConfigs: dict<contractConfig>,
   ~dynamicContracts: Utils.Set.t<string>,
   ~normalSelection: selection,
   ~maxAddrInPartition: int,
@@ -778,9 +774,6 @@ OptimizedPartitions.t => {
     let addresses =
       registeringContracts->Dict.keysToArray->(Utils.magic: array<string> => array<Address.t>)
 
-    // Can unsafely get it, because we already filtered out the contracts
-    // that don't have any events to fetch
-    let contractConfig = contractConfigs->Dict.getUnsafe(contractName)
     let isDynamic = dynamicContracts->Utils.Set.has(contractName)
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions
 
@@ -802,30 +795,23 @@ OptimizedPartitions.t => {
       let maybeNextStartBlockKey =
         ascKeys->Array.getUnsafe(idx + 1)->(Utils.magic: string => option<string>)
 
-      // For this case we can't filter out events earlier than contract registration
-      // on the client side, so we need to keep the old logic of creating
-      // a partition for every block range, so there are no irrelevant events
-      let shouldAllocateNewPartition = if contractConfig.filterByAddresses {
-        true
-      } else {
-        switch maybeNextStartBlockKey {
-        | None => true
-        | Some(nextStartBlockKey) => {
-            let nextStartBlock = nextStartBlockKey->Int.fromString->Option.getUnsafe
-            let shouldJoinCurrentStartBlock =
-              nextStartBlock - startBlockRef.contents < OptimizedPartitions.tooFarBlockRange
-
-            // If dynamic contract registration are close to eachother
-            // and it's possible to use dc.effectiveStartBlock to filter out events on client side
-            // then we can optimize the number of partitions,
-            // by putting dcs with different startBlocks in the same partition
-            if shouldJoinCurrentStartBlock {
-              addressesRef :=
-                addressesRef.contents->Array.concat(byStartBlock->Dict.getUnsafe(nextStartBlockKey))
-              false
-            } else {
-              true
-            }
+      let shouldAllocateNewPartition = switch maybeNextStartBlockKey {
+      | None => true
+      | Some(nextStartBlockKey) => {
+          let nextStartBlock = nextStartBlockKey->Int.fromString->Option.getUnsafe
+          let shouldJoinCurrentStartBlock =
+            nextStartBlock - startBlockRef.contents < OptimizedPartitions.tooFarBlockRange
+
+          // Addresses with different start blocks within range share a partition;
+          // events before each address's effectiveStartBlock are dropped on the
+          // client side (EventRouter for the srcAddress, the event's
+          // clientAddressFilter for address-valued params).
+          if shouldJoinCurrentStartBlock {
+            addressesRef :=
+              addressesRef.contents->Array.concat(byStartBlock->Dict.getUnsafe(nextStartBlockKey))
+            false
+          } else {
+            true
           }
         }
       }
@@ -907,15 +893,10 @@ OptimizedPartitions.t => {
           }
         }
 
-        let nextContractName =
-          nextP.addressesByContractName->Dict.keysToArray->Utils.Array.firstUnsafe
-        let hasFilterByAddresses = (
-          contractConfigs->Dict.getUnsafe(nextContractName)
-        ).filterByAddresses
         let isTooFar = currentPBlock + OptimizedPartitions.tooFarBlockRange < nextPBlock
 
-        if isTooFar || hasFilterByAddresses {
-          // Too far or address-filtered: mergeBlock on current, merge addresses into next
+        if isTooFar {
+          // Too far: mergeBlock on current, merge addresses into next
           mergedNonDynamic
           ->Array.push({
             ...currentP,
@@ -927,7 +908,7 @@ OptimizedPartitions.t => {
               addressesByContractName: mergedAddresses,
             }
         } else {
-          // Close and not address-filtered: push next's addresses into current
+          // Close: push next's addresses into current
           currentPRef := {
               ...currentP,
               addressesByContractName: mergedAddresses,
@@ -968,12 +949,15 @@ let registerDynamicContracts = (
   let indexingAddresses = fetchState.indexingAddresses
   let registeringContractsByContract: dict<dict<indexingAddress>> = Dict.make()
   let earliestRegisteringEventBlockNumber = ref(%raw(`Infinity`))
-  let hasDCWithFilterByAddresses = ref(false)
   // Addresses registered for contracts without matching events. These are not
   // added to partitions, but they are tracked on fetchState.indexingAddresses
   // so that later conflicting registrations are detected, and are persisted
   // to envio_addresses so they can be picked up on restart with updated config.
   let noEventsAddresses: dict<indexingAddress> = Dict.make()
+  // Batch-level view of all addresses registered so far (across contracts,
+  // including no-events ones), so two contracts registering the same address
+  // within one batch conflict the same way as against indexingAddresses.
+  let registeringAddresses: dict<indexingAddress> = Dict.make()
 
   for itemIdx in 0 to items->Array.length - 1 {
     let item = items->Array.getUnsafe(itemIdx)
@@ -987,7 +971,7 @@ let registerDynamicContracts = (
         let shouldRemove = ref(false)
 
         switch fetchState.contractConfigs->Utils.Dict.dangerouslyGetNonOption(dc.contractName) {
-        | Some({filterByAddresses, startBlock: contractStartBlock}) =>
+        | Some({startBlock: contractStartBlock}) =>
           let dcWithStartBlock: indexingAddress = {
             address: dc.address,
             contractName: dc.contractName,
@@ -1021,9 +1005,7 @@ let registerDynamicContracts = (
             }
             shouldRemove := true
           | None =>
-            let registeringContracts =
-              registeringContractsByContract->Utils.Dict.getOrInsertEmptyDict(dc.contractName)
-            let shouldUpdate = switch registeringContracts->Utils.Dict.dangerouslyGetNonOption(
+            let shouldUpdate = switch registeringAddresses->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
             ) {
             | Some(registeringContract) if registeringContract.contractName != dc.contractName =>
@@ -1036,9 +1018,7 @@ let registerDynamicContracts = (
               // FIXME: This unsafely relies on the asc order of the items
               // which is 99% true, but there were cases when the source ordering was wrong
               false
-            | None =>
-              hasDCWithFilterByAddresses := hasDCWithFilterByAddresses.contents || filterByAddresses
-              true
+            | None => true
             }
             if shouldUpdate {
               earliestRegisteringEventBlockNumber :=
@@ -1046,7 +1026,10 @@ let registerDynamicContracts = (
                   earliestRegisteringEventBlockNumber.contents,
                   dcWithStartBlock.effectiveStartBlock,
                 )
-              registeringContracts->Dict.set(dc.address->Address.toString, dcWithStartBlock)
+              registeringContractsByContract
+              ->Utils.Dict.getOrInsertEmptyDict(dc.contractName)
+              ->Dict.set(dc.address->Address.toString, dcWithStartBlock)
+              registeringAddresses->Dict.set(dc.address->Address.toString, dcWithStartBlock)
             } else {
               shouldRemove := true
             }
@@ -1073,11 +1056,14 @@ let registerDynamicContracts = (
             }
             shouldRemove := true
           | None =>
-            switch noEventsAddresses->Utils.Dict.dangerouslyGetNonOption(
+            switch registeringAddresses->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
             ) {
-            | Some(_) =>
-              // Already queued for persistence by an earlier item in this batch.
+            | Some(existingContract) =>
+              if existingContract.contractName != dc.contractName {
+                fetchState->warnDifferentContractType(~existingContract, ~dc=dcAsIndexingAddress)
+              }
+              // Otherwise already queued for persistence by an earlier item in this batch.
               shouldRemove := true
             | None =>
               let logger = Logging.createChild(
@@ -1092,6 +1078,7 @@ let registerDynamicContracts = (
               // skip partition registration since there's nothing to fetch.
               logger->Logging.childWarn(`Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`)
               noEventsAddresses->Dict.set(dc.address->Address.toString, dcAsIndexingAddress)
+              registeringAddresses->Dict.set(dc.address->Address.toString, dcAsIndexingAddress)
             }
           }
         }
@@ -1209,7 +1196,6 @@ let registerDynamicContracts = (
 
       let optimizedPartitions = createPartitionsFromIndexingAddresses(
         ~registeringContractsByContract,
-        ~contractConfigs=fetchState.contractConfigs,
         ~dynamicContracts=dynamicContractsRef.contents,
         ~normalSelection=fetchState.normalSelection,
         ~maxAddrInPartition=fetchState.optimizedPartitions.maxAddrInPartition,
@@ -1236,6 +1222,20 @@ let handleQueryResult = (
   ~latestFetchedBlock: blockNumberAndTimestamp,
   ~newItems,
 ): t => {
+  // Drop events an address-param filter rejects. A merged partition may
+  // over-fetch a wildcard event whose indexed address param references an
+  // address registered after the log's block; `clientAddressFilter` is the
+  // param-level analogue of EventRouter's srcAddress effectiveStartBlock check.
+  let newItems = newItems->Array.filter(item =>
+    switch item {
+    | Internal.Event({eventConfig, event, blockNumber}) =>
+      switch eventConfig.clientAddressFilter {
+      | Some(filter) => filter(event, blockNumber, fetchState.indexingAddresses)
+      | None => true
+      }
+    | _ => true
+    }
+  )
   fetchState->updateInternal(
     ~optimizedPartitions=fetchState.optimizedPartitions->OptimizedPartitions.handleQueryResponse(
       ~query,
@@ -1508,7 +1508,7 @@ let getNextQuery = (
 }
 
 let hasReadyItem = ({buffer} as fetchState: t) => {
-  switch buffer->Belt.Array.get(0) {
+  switch buffer->Array.get(0) {
   | Some(item) => item->Internal.getItemBlockNumber <= fetchState->bufferBlockNumber
   | None => false
   }
@@ -1519,7 +1519,7 @@ let getReadyItemsCount = (fetchState: t, ~targetSize: int, ~fromItem) => {
   let acc = ref(0)
   let isFinished = ref(false)
   while !isFinished.contents {
-    switch fetchState.buffer->Belt.Array.get(fromItem + acc.contents) {
+    switch fetchState.buffer->Array.get(fromItem + acc.contents) {
     | Some(item) =>
       let itemBlockNumber = item->Internal.getItemBlockNumber
       if itemBlockNumber <= readyBlockNumber.contents {
@@ -1563,15 +1563,14 @@ let make = (
   let normalEventConfigs = []
   let contractNamesWithNormalEvents = Utils.Set.make()
   let indexingAddresses = Dict.make()
-  let contractConfigs = Dict.make()
+  let contractConfigs: dict<contractConfig> = Dict.make()
 
   eventConfigs->Array.forEach(ec => {
     switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(ec.contractName) {
-    | Some({filterByAddresses, startBlock}) =>
+    | Some({startBlock}) =>
       contractConfigs->Dict.set(
         ec.contractName,
         {
-          filterByAddresses: filterByAddresses || ec.filterByAddresses,
           startBlock: switch (startBlock, ec.startBlock) {
           | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
           | (Some(_) as s, None) | (None, Some(_) as s) => s
@@ -1583,7 +1582,6 @@ let make = (
       contractConfigs->Dict.set(
         ec.contractName,
         {
-          filterByAddresses: ec.filterByAddresses,
           startBlock: ec.startBlock,
         },
       )
@@ -1663,7 +1661,6 @@ let make = (
 
   let optimizedPartitions = createPartitionsFromIndexingAddresses(
     ~registeringContractsByContract,
-    ~contractConfigs,
     ~dynamicContracts,
     ~normalSelection,
     ~maxAddrInPartition,
@@ -1866,7 +1863,6 @@ let rollback = (fetchState: t, ~targetBlockNumber) => {
   // Step 3: Recreate partitions from deleted partition addresses
   let optimizedPartitions = createPartitionsFromIndexingAddresses(
     ~registeringContractsByContract,
-    ~contractConfigs=fetchState.contractConfigs,
     ~dynamicContracts=fetchState.optimizedPartitions.dynamicContracts,
     ~normalSelection=fetchState.normalSelection,
     ~maxAddrInPartition=fetchState.optimizedPartitions.maxAddrInPartition,
@@ -1951,7 +1947,7 @@ let isReadyToEnterReorgThreshold = ({endBlock, blockLag, buffer, knownHeight} as
 
 let sortForUnorderedBatch = {
   let hasFullBatch = ({buffer} as fetchState: t, ~batchSizeTarget) => {
-    switch buffer->Belt.Array.get(batchSizeTarget - 1) {
+    switch buffer->Array.get(batchSizeTarget - 1) {
     | Some(item) => item->Internal.getItemBlockNumber <= fetchState->bufferBlockNumber
     | None => false
     }
@@ -1966,7 +1962,7 @@ let sortForUnorderedBatch = {
       if totalRange <= 0 {
         0.
       } else {
-        let progress = switch fetchState.buffer->Belt.Array.get(0) {
+        let progress = switch fetchState.buffer->Array.get(0) {
         | Some(item) => item->Internal.getItemBlockNumber - firstEventBlock
         | None => fetchState->bufferBlockNumber - firstEventBlock
         }
@@ -2001,7 +1997,7 @@ let sortForUnorderedBatch = {
 
 let getProgressBlockNumberAt = ({buffer} as fetchState: t, ~index) => {
   let bufferBlockNumber = fetchState->bufferBlockNumber
-  switch buffer->Belt.Array.get(index) {
+  switch buffer->Array.get(index) {
   | Some(item) if bufferBlockNumber >= item->Internal.getItemBlockNumber =>
     item->Internal.getItemBlockNumber - 1
   | _ => bufferBlockNumber