envio 3.3.0-alpha.10 → 3.3.0-alpha.11

package/src/FetchState.res.mjs

@@ -484,13 +484,90 @@ function bufferReadyCount(fetchState) {
   return lo;
 }
 
+function getRegistrationIndex(item) {
+  if (item.kind === 0) {
+    return item.onEventRegistration.index;
+  } else {
+    return item.onBlockRegistration.index;
+  }
+}
+
 function compareBufferItem(a, b) {
-  let blockOrdering = Primitive_int.compare(a.blockNumber, b.blockNumber);
-  if (blockOrdering === 0) {
-    return Primitive_int.compare(a.logIndex, b.logIndex);
+  let ba = a.blockNumber;
+  let bb = b.blockNumber;
+  if (ba !== bb) {
+    if (ba < bb) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  let la = a.logIndex;
+  let lb = b.logIndex;
+  if (la !== lb) {
+    if (la < lb) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  let ia = getRegistrationIndex(a);
+  let ib = getRegistrationIndex(b);
+  if (ia < ib) {
+    return -1;
+  } else if (ia > ib) {
+    return 1;
   } else {
-    return blockOrdering;
+    return 0;
+  }
+}
+
+function mergeIntoBuffer(buffer, newItems) {
+  let n = newItems.length;
+  for (let i = 1; i < n; ++i) {
+    let x = newItems[i];
+    let j = i - 1 | 0;
+    while (j >= 0 && compareBufferItem(newItems[j], x) > 0) {
+      newItems[j + 1 | 0] = newItems[j];
+      j = j - 1 | 0;
+    };
+    newItems[j + 1 | 0] = x;
   }
+  let m = buffer.length;
+  let merged = [];
+  let last = {
+    contents: undefined
+  };
+  let push = item => {
+    let l = last.contents;
+    if (l !== undefined && compareBufferItem(l, item) === 0) {
+      return;
+    }
+    merged.push(item);
+    last.contents = item;
+  };
+  let i$1 = 0;
+  let j$1 = 0;
+  while (i$1 < m && j$1 < n) {
+    let a = buffer[i$1];
+    let b = newItems[j$1];
+    if (compareBufferItem(a, b) <= 0) {
+      push(a);
+      i$1 = i$1 + 1 | 0;
+    } else {
+      push(b);
+      j$1 = j$1 + 1 | 0;
+    }
+  };
+  while (i$1 < m) {
+    push(buffer[i$1]);
+    i$1 = i$1 + 1 | 0;
+  };
+  while (j$1 < n) {
+    push(newItems[j$1]);
+    j$1 = j$1 + 1 | 0;
+  };
+  return merged;
 }
 
 function appendOnBlockItems(mutItems, onBlockRegistrations, indexerStartBlock, fromBlock, maxBlockNumber, maxOnBlockBufferSize) {
@@ -522,18 +599,19 @@ function appendOnBlockItems(mutItems, onBlockRegistrations, indexerStartBlock, f
   return latestOnBlockBlockNumber;
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOpt, knownHeightOpt) {
+function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSortedOpt, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
+  let mutItemsSorted = mutItemsSortedOpt !== undefined ? mutItemsSortedOpt : false;
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
-  let mutItemsRef = mutItems;
+  let base = mutItems !== undefined ? (
+      mutItemsSorted ? mutItems : mergeIntoBuffer([], mutItems)
+    ) : fetchState.buffer;
+  let blockItems = [];
   let onBlockRegistrations = fetchState.onBlockRegistrations;
   let latestOnBlockBlockNumber;
   if (onBlockRegistrations.length !== 0) {
-    let mutItems$1 = mutItemsRef;
-    let item = (
-        mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer
-      )[fetchState.maxOnBlockBufferSize - 1 | 0];
+    let item = base[fetchState.maxOnBlockBufferSize - 1 | 0];
     let maxBlockNumber;
     if (item !== undefined) {
       maxBlockNumber = item.blockNumber;
@@ -542,20 +620,16 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOp
       let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
       maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
     }
-    let mutItems$2 = mutItemsRef;
-    let mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice();
-    mutItemsRef = mutItems$3;
-    latestOnBlockBlockNumber = appendOnBlockItems(mutItems$3, onBlockRegistrations, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
+    latestOnBlockBlockNumber = appendOnBlockItems(blockItems, onBlockRegistrations, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.maxOnBlockBufferSize);
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
-  let mutItems$4 = mutItemsRef;
   let updatedFetchState_startBlock = fetchState.startBlock;
   let updatedFetchState_endBlock = fetchState.endBlock;
   let updatedFetchState_normalSelection = fetchState.normalSelection;
   let updatedFetchState_contractConfigs = fetchState.contractConfigs;
   let updatedFetchState_chainId = fetchState.chainId;
-  let updatedFetchState_buffer = mutItems$4 !== undefined ? (mutItems$4.sort(compareBufferItem), mutItems$4) : fetchState.buffer;
+  let updatedFetchState_buffer = blockItems.length !== 0 ? mergeIntoBuffer(base, blockItems) : base;
   let updatedFetchState_maxOnBlockBufferSize = fetchState.maxOnBlockBufferSize;
   let updatedFetchState_onBlockRegistrations = fetchState.onBlockRegistrations;
   let updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
@@ -937,11 +1011,11 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
   }
   IndexingAddresses.register(indexingAddresses, noEventsAddresses);
   let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
-  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined);
+  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined, undefined);
 }
 
-function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBlock, newItems) {
-  let newItems$1 = newItems.filter(item => {
+function filterByClientAddress(items, indexingAddresses) {
+  return items.filter(item => {
     if (item.kind !== 0) {
       return true;
     }
@@ -952,7 +1026,10 @@ function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBl
       return true;
     }
   });
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems$1.length, latestFetchedBlock), newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
+}
+
+function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems.length, latestFetchedBlock), newItems.length !== 0 ? mergeIntoBuffer(fetchState.buffer, newItems) : undefined, true, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
@@ -1051,24 +1128,6 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
   return cost.contents;
 }
 
-function waterLevel(budget, footprints) {
-  let sorted = footprints.toSorted(Primitive_float.compare);
-  let n = sorted.length;
-  let prefix = 0;
-  let level;
-  let idx = 0;
-  while (level === undefined && idx < n) {
-    let i = idx;
-    prefix = prefix + sorted[i];
-    let candidate = (budget + prefix) / (i + 1 | 0);
-    if (i === (n - 1 | 0) || candidate <= sorted[i + 1 | 0]) {
-      level = candidate;
-    }
-    idx = idx + 1 | 0;
-  };
-  return Stdlib_Option.getOr(level, 0);
-}
-
 function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star) {
   let knownHeight = param.knownHeight;
   let blockLag = param.blockLag;
@@ -1100,42 +1159,42 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       return queryEndBlock;
     }
   };
-  let existingReservedByPartition = {};
   let chainReserved = 0;
+  let reservations = [];
+  let partitionIndexById = {};
+  let candidates = [];
+  let fillStates = [];
   for (let idx$1 = 0; idx$1 < partitionsCount; ++idx$1) {
     let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
     let p$1 = optimizedPartitions.entities[partitionId$1];
-    let cost = 0;
-    for (let pqIdx = 0, pqIdx_finish = p$1.mutPendingQueries.length; pqIdx < pqIdx_finish; ++pqIdx) {
-      cost = cost + p$1.mutPendingQueries[pqIdx].itemsEst;
+    partitionIndexById[partitionId$1] = idx$1;
+    let pendingCount = p$1.mutPendingQueries.length;
+    for (let pqIdx = 0; pqIdx < pendingCount; ++pqIdx) {
+      let pq = p$1.mutPendingQueries[pqIdx];
+      if (pq.fetchedBlock === undefined) {
+        chainReserved = chainReserved + pq.itemsEst;
+        reservations.push([
+          pq.fromBlock,
+          pq.itemsEst
+        ]);
+      }
     }
-    existingReservedByPartition[partitionId$1] = cost;
-    chainReserved = chainReserved + cost;
-  }
-  let fillStates = [];
-  let gapFillCost = 0;
-  for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
-    let partitionId$2 = optimizedPartitions.idsInAscOrder[idx$2];
-    let p$2 = optimizedPartitions.entities[partitionId$2];
-    let bucket = queriesByPartitionIndex[idx$2];
-    let pendingCount = p$2.mutPendingQueries.length;
-    let queryEndBlock = computeQueryEndBlock(p$2);
-    let maybeChunkRange = getMinHistoryRange(p$2);
-    let cursor = p$2.latestFetchedBlock.blockNumber + 1 | 0;
+    let queryEndBlock = computeQueryEndBlock(p$1);
+    let maybeChunkRange = getMinHistoryRange(p$1);
+    let cursor = p$1.latestFetchedBlock.blockNumber + 1 | 0;
     let canContinue = true;
     let chunksUsedThisCall = 0;
     let pqIdx$1 = 0;
     while (pqIdx$1 < pendingCount && canContinue) {
-      let pq = p$2.mutPendingQueries[pqIdx$1];
-      if (pq.fromBlock > cursor) {
-        let beforeLen = bucket.length;
-        let cost$1 = pushGapFillQueries(bucket, partitionId$2, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$2, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$2.selection, p$2.addressesByContractName);
-        chunksUsedThisCall = chunksUsedThisCall + (bucket.length - beforeLen | 0) | 0;
-        gapFillCost = gapFillCost + cost$1;
+      let pq$1 = p$1.mutPendingQueries[pqIdx$1];
+      if (pq$1.fromBlock > cursor) {
+        let beforeLen = candidates.length;
+        pushGapFillQueries(candidates, partitionId$1, cursor, Utils.$$Math.minOptInt(pq$1.fromBlock - 1 | 0, queryEndBlock), knownHeight, chainTargetBlock, maybeChunkRange, (12 - pendingCount | 0) - chunksUsedThisCall | 0, p$1, chainTargetItems / partitionsCount, chunkItemsMultiplier, p$1.selection, p$1.addressesByContractName);
+        chunksUsedThisCall = chunksUsedThisCall + (candidates.length - beforeLen | 0) | 0;
       }
-      let toBlock = pq.toBlock;
-      if (toBlock !== undefined && pq.isChunk) {
-        let match = pq.fetchedBlock;
+      let toBlock = pq$1.toBlock;
+      if (toBlock !== undefined && pq$1.isChunk) {
+        let match = pq$1.fetchedBlock;
         if (match !== undefined) {
           let blockNumber = match.blockNumber;
           cursor = blockNumber < toBlock ? blockNumber + 1 | 0 : toBlock + 1 | 0;
@@ -1149,26 +1208,17 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     };
     if (canContinue) {
       fillStates.push({
-        partitionId: partitionId$2,
-        p: p$2,
+        partitionId: partitionId$1,
+        p: p$1,
         cursor: cursor,
         chunksUsedThisCall: chunksUsedThisCall,
         pendingCount: pendingCount,
         queryEndBlock: queryEndBlock,
-        maybeChunkRange: maybeChunkRange,
-        bucket: bucket
+        maybeChunkRange: maybeChunkRange
       });
     }
   }
-  let rangeItemsTarget = Primitive_float.max(0, chainTargetItems - chainReserved - gapFillCost);
-  let reservedByPartition = {};
-  fillStates.forEach(fs => {
-    let cost = existingReservedByPartition[fs.partitionId];
-    for (let i = 0, i_finish = fs.bucket.length; i < i_finish; ++i) {
-      cost = cost + fs.bucket[i].itemsEst;
-    }
-    reservedByPartition[fs.partitionId] = cost;
-  });
+  let freshBudget = Primitive_float.max(0, chainTargetItems - chainReserved);
   let isInRange = fs => {
     let tmp = false;
     if (fs.cursor <= chainTargetBlock) {
@@ -1182,7 +1232,18 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     }
   };
   let inRangeStates = fillStates.filter(isInRange);
-  let emitQueries = (fs, budget) => {
+  let inRangeCount = inRangeStates.length;
+  let probeShare = inRangeCount === 0 ? 0 : freshBudget / inRangeCount;
+  let frontierCursor = Stdlib_Array.reduce(inRangeStates, chainTargetBlock, (min, fs) => {
+    if (fs.cursor < min) {
+      return fs.cursor;
+    } else {
+      return min;
+    }
+  });
+  let rangeToTarget = (chainTargetBlock - frontierCursor | 0) + 1 | 0;
+  let rangeTargetDensity = inRangeCount > 0 && rangeToTarget > 0 ? freshBudget / rangeToTarget : 0;
+  inRangeStates.forEach(fs => {
     let p = fs.p;
     let eb = fs.queryEndBlock;
     let maxBlock = eb !== undefined ? eb : chainTargetBlock;
@@ -1191,39 +1252,33 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
     if (match !== undefined && match$1 !== undefined && match$1 > 0) {
       let chunkSize = Js_math.ceil_int(match * 1.8);
       let maxChunksRemaining = (12 - fs.pendingCount | 0) - fs.chunksUsedThisCall | 0;
-      let consumed = 0;
+      let chunkStartCeiling = Primitive_int.min(maxBlock, chainTargetBlock);
       let created = 0;
       let chunkFromBlock = fs.cursor;
-      let budgetLeft = true;
-      while (budgetLeft && created < maxChunksRemaining && chunkFromBlock <= Primitive_int.min(maxBlock, chainTargetBlock)) {
+      let generatedItems = 0;
+      while (created < maxChunksRemaining && chunkFromBlock <= chunkStartCeiling && generatedItems <= freshBudget) {
         let chunkToBlock = Primitive_int.min((chunkFromBlock + chunkSize | 0) - 1 | 0, maxBlock);
         let rawEst = match$1 * ((chunkToBlock - chunkFromBlock | 0) + 1 | 0);
         let itemsEst = Primitive_int.max(1, Math.ceil(rawEst) | 0);
         let itemsTarget = Primitive_int.max(1, Math.ceil(rawEst * chunkItemsMultiplier) | 0);
-        if (consumed === 0 || consumed + itemsEst <= budget) {
-          fs.bucket.push({
-            partitionId: fs.partitionId,
-            fromBlock: chunkFromBlock,
-            toBlock: chunkToBlock,
-            isChunk: true,
-            itemsTarget: itemsTarget,
-            itemsEst: itemsEst,
-            selection: p.selection,
-            addressesByContractName: p.addressesByContractName
-          });
-          consumed = consumed + itemsEst;
-          chunkFromBlock = chunkToBlock + 1 | 0;
-          created = created + 1 | 0;
-        } else {
-          budgetLeft = false;
-        }
+        candidates.push({
+          partitionId: fs.partitionId,
+          fromBlock: chunkFromBlock,
+          toBlock: chunkToBlock,
+          isChunk: true,
+          itemsTarget: itemsTarget,
+          itemsEst: itemsEst,
+          selection: p.selection,
+          addressesByContractName: p.addressesByContractName
+        });
+        generatedItems = generatedItems + itemsEst;
+        chunkFromBlock = chunkToBlock + 1 | 0;
+        created = created + 1 | 0;
       };
-      fs.cursor = chunkFromBlock;
-      fs.chunksUsedThisCall = fs.chunksUsedThisCall + created | 0;
-      return consumed;
+      return;
     }
-    let itemsTarget$1 = Primitive_int.max(1, Math.round(budget) | 0);
-    fs.bucket.push({
+    let itemsTarget$1 = rangeToTarget > 0 ? Primitive_int.max(1, Math.round(rangeTargetDensity * ((chainTargetBlock - fs.cursor | 0) + 1 | 0) / inRangeCount) | 0) : Primitive_int.max(1, Math.round(probeShare) | 0);
+    candidates.push({
       partitionId: fs.partitionId,
       fromBlock: fs.cursor,
       toBlock: fs.queryEndBlock,
@@ -1233,32 +1288,53 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star)
       selection: p.selection,
       addressesByContractName: p.addressesByContractName
     });
-    fs.cursor = maxBlock + 1 | 0;
-    fs.chunksUsedThisCall = fs.chunksUsedThisCall + 1 | 0;
-    return itemsTarget$1;
-  };
-  let notFilledPartitions = inRangeStates;
-  let remainingBudget = {
-    contents: rangeItemsTarget
-  };
-  while (notFilledPartitions.length !== 0 && remainingBudget.contents > 0) {
-    let level = waterLevel(remainingBudget.contents, notFilledPartitions.map(fs => reservedByPartition[fs.partitionId]));
-    let next = [];
-    notFilledPartitions.forEach(fs => {
-      let reserved = reservedByPartition[fs.partitionId];
-      let budget = level - reserved;
-      if (budget <= 0) {
-        return;
-      }
-      let consumed = emitQueries(fs, budget);
-      reservedByPartition[fs.partitionId] = reserved + consumed;
-      remainingBudget.contents = remainingBudget.contents - consumed;
-      if (isInRange(fs)) {
-        next.push(fs);
-        return;
+  });
+  let acceptanceStream = [];
+  candidates.forEach(query => {
+    acceptanceStream.push([
+      query.fromBlock,
+      query.itemsEst,
+      query
+    ]);
+  });
+  reservations.forEach(param => {
+    acceptanceStream.push([
+      param[0],
+      param[1],
+      undefined
+    ]);
+  });
+  acceptanceStream.sort((param, param$1) => {
+    let bFrom = param$1[0];
+    let aFrom = param[0];
+    if (aFrom !== bFrom) {
+      return Primitive_int.compare(aFrom, bFrom);
+    }
+    let bQuery = param$1[2];
+    if (param[2] !== undefined) {
+      if (bQuery !== undefined) {
+        return 0;
+      } else {
+        return 1;
       }
-    });
-    notFilledPartitions = next;
+    } else if (bQuery !== undefined) {
+      return -1;
+    } else {
+      return 0;
+    }
+  });
+  let streamCount = acceptanceStream.length;
+  let remainingBudget = chainTargetItems;
+  let acceptIdx = 0;
+  while (remainingBudget > 0 && acceptIdx < streamCount) {
+    let match$1 = acceptanceStream[acceptIdx];
+    let maybeQuery = match$1[2];
+    if (maybeQuery !== undefined) {
+      let partitionIdx = partitionIndexById[maybeQuery.partitionId];
+      queriesByPartitionIndex[partitionIdx].push(maybeQuery);
+    }
+    remainingBudget = remainingBudget - match$1[1];
+    acceptIdx = acceptIdx + 1 | 0;
   };
   let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
@@ -1525,7 +1601,7 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
     return tmp <= targetBlockNumber;
-  }), undefined, undefined);
+  }), true, undefined, undefined);
 }
 
 function resetPendingQueries(fetchState) {
@@ -1678,7 +1754,7 @@ function getProgressBlockNumberAt(fetchState, index) {
 function updateKnownHeight(fetchState, knownHeight) {
   if (knownHeight > fetchState.knownHeight) {
     Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
-    return updateInternal(fetchState, undefined, undefined, undefined, knownHeight);
+    return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
   } else {
     return fetchState;
   }
@@ -1698,7 +1774,9 @@ export {
   bufferBlockNumber,
   bufferBlock,
   bufferReadyCount,
+  getRegistrationIndex,
   compareBufferItem,
+  mergeIntoBuffer,
   blockItemLogIndex,
   appendOnBlockItems,
   updateInternal,
@@ -1707,11 +1785,11 @@ export {
   addressesByContractNameGetAll,
   createPartitionsFromIndexingAddresses,
   registerDynamicContracts,
+  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
   maxPendingChunksPerPartition,
   pushGapFillQueries,
-  waterLevel,
   getNextQuery,
   hasReadyItem,
   getReadyItemsCount,

package/src/HandlerRegister.res

@@ -679,7 +679,9 @@ let finishRegistration = (~config: Config.t): registrationsByChainId => {
                   config.ecosystem.name === Evm &&
                     (registration->getResolvedWhere).topicSelections->Utils.Array.isEmpty
                 if !isDroppedByWhere {
-                  onEventRegistrations->Array.push(registration)
+                  onEventRegistrations
+                  ->Array.push({...registration, index: onEventRegistrations->Array.length})
+                  ->ignore
                 }
               | None => ()
               }

package/src/HandlerRegister.res.mjs

@@ -388,10 +388,11 @@ function finishRegistration(config) {
           return;
         }
         let isDroppedByWhere = config.ecosystem.name === "evm" && Utils.$$Array.isEmpty(registration$1.resolvedWhere.topicSelections);
-        if (!isDroppedByWhere) {
-          onEventRegistrations.push(registration$1);
+        if (isDroppedByWhere) {
           return;
         }
+        let newrecord = {...registration$1};
+        onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
       });
     });
     registrationsByChainId[key] = {

package/src/Internal.res

@@ -330,6 +330,9 @@ type eventPayload
 @get external getPayloadBlock: eventPayload => Nullable.t<eventBlock> = "block"
 @set external setPayloadBlock: (eventPayload, eventBlock) => unit = "block"
 
+// The log's emitting address (EVM/Fuel; the program id carries it for SVM).
+@get external getPayloadSrcAddress: eventPayload => Address.t = "srcAddress"
+
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
@@ -555,6 +558,11 @@ type svmInstructionEventConfig = {
 // must stay directly constructable), and the evm→base cast in sources is sound
 // by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
 type onEventRegistration = {
+  // Chain-scoped sequential index — the registration's position in the
+  // chain's onEventRegistrations array, assigned when registration finishes
+  // (-1 until then). Native-routed items reference their registration by this
+  // index across the napi boundary; sources resolve it before creating an item.
+  index: int,
   eventConfig: eventConfig,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
@@ -601,8 +609,9 @@ type indexingAddress = {
 
 type dcs = array<indexingAddress>
 
-// Duplicate the type from item
-// to make item properly unboxed
+// Duplicate the type from item to keep item properly unboxed. Runtime event
+// items carry the registration their source already resolved from the
+// ChainState-owned registration array.
 type eventItem = private {
   kind: [#0],
   onEventRegistration: onEventRegistration,

package/src/LogSelection.res

@@ -1,65 +1,3 @@
-exception MissingRequiredTopic0
-let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]): result<
-  Internal.topicSelection,
-  exn,
-> =>
-  if topic0->Utils.Array.isEmpty {
-    Error(MissingRequiredTopic0)
-  } else {
-    {
-      Internal.topic0,
-      topic1,
-      topic2,
-      topic3,
-    }->Ok
-  }
-
-let hasFilters = ({topic1, topic2, topic3}: Internal.topicSelection) => {
-  [topic1, topic2, topic3]->Array.find(topic => !Utils.Array.isEmpty(topic))->Option.isSome
-}
-
-/**
-For a group of topic selections, if multiple only use topic0, then they can be compressed into one
-selection combining the topic0s
-*/
-let compressTopicSelections = (topicSelections: array<Internal.topicSelection>) => {
-  let topic0sOfSelectionsWithoutFilters = []
-
-  let selectionsWithFilters = []
-
-  topicSelections->Array.forEach(selection => {
-    if selection->hasFilters {
-      selectionsWithFilters->Array.push(selection)->ignore
-    } else {
-      selection.topic0->Array.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters->Array.push(topic0)->ignore
-      })
-    }
-  })
-
-  switch topic0sOfSelectionsWithoutFilters {
-  | [] => selectionsWithFilters
-  | topic0 =>
-    let selectionWithoutFilters: Internal.topicSelection = {
-      topic0,
-      topic1: [],
-      topic2: [],
-      topic3: [],
-    }
-    Array.concat([selectionWithoutFilters], selectionsWithFilters)
-  }
-}
-
-type t = {
-  addresses: array<Address.t>,
-  topicSelections: array<Internal.topicSelection>,
-}
-
-let make = (~addresses, ~topicSelections) => {
-  let topicSelections = compressTopicSelections(topicSelections)
-  {addresses, topicSelections}
-}
-
 // Expand a resolved topic selection into concrete topic values for a query:
 // `ContractAddresses` markers become the given partition addresses encoded as
 // topics; `Values` pass through.