envio 3.4.0 → 3.5.0-alpha.1

package/src/IndexingAddresses.res

@@ -2,7 +2,12 @@ type indexingAddress = Internal.indexingContract
 
 type contractConfig = {startBlock: option<int>}
 
-type t = dict<indexingAddress>
+// Grouped by contract name, then by address string. Contracts are few, so
+// per-contract operations (address count, the client-side filter's lookup
+// dict) are direct, and whole-index scans (get by address, rollback) walk the
+// small contract set. Address strings are globally unique across contracts
+// (conflicting registrations are rejected before they reach here).
+type t = dict<dict<indexingAddress>>
 
 let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: option<int>) => {
   Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
@@ -59,50 +64,88 @@ let makeIndexingAddress = (
   }
 }
 
+let insert = (indexingAddresses: t, indexingAddress: indexingAddress) => {
+  indexingAddresses
+  ->Utils.Dict.getOrInsertEmptyDict(indexingAddress.contractName)
+  ->Dict.set(indexingAddress.address->Address.toString, indexingAddress)
+}
+
 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->insert(makeIndexingAddress(~contract, ~contractConfigs))
   })
   indexingAddresses
 }
 
-let get = (indexingAddresses: t, address) =>
-  indexingAddresses->Utils.Dict.dangerouslyGetNonOption(address)
+// Address strings are globally unique, so the first inner dict holding the
+// address owns it. for..in returns on the first hit without allocating a values
+// array per lookup (get runs once per registration).
+let get: (t, string) => option<indexingAddress> = %raw(`(index, address) => {
+  for (var contractName in index) {
+    var entry = index[contractName][address];
+    if (entry !== undefined) {
+      return entry;
+    }
+  }
+  return undefined;
+}`)
+
+let size = (indexingAddresses: t) => {
+  let total = ref(0)
+  indexingAddresses->Utils.Dict.forEach(inner => {
+    total := total.contents + inner->Utils.Dict.size
+  })
+  total.contents
+}
 
-let size = (indexingAddresses: t) => indexingAddresses->Utils.Dict.size
+// Number of registered addresses for a single contract — a for..in over that
+// one contract's addresses. The trigger deciding when to switch a contract to
+// client-side filtering reads this.
+let contractCount = (indexingAddresses: t, ~contractName) =>
+  switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(contractName) {
+  | Some(inner) => inner->Utils.Dict.size
+  | None => 0
+  }
 
 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
+  switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(contractName) {
+  | Some(inner) => inner->Dict.valuesToArray->Array.map(ia => ia.address)
+  | None => []
+  }
 }
 
-// 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 emptyContractDict: dict<indexingAddress> = Dict.make()
+
+// The address→entry dict for a single contract, passed to that contract's
+// precompiled `clientAddressFilter` (which does raw `byAddr[srcAddress]` access
+// in generated JS). Every leaf of a filter references the event's own contract
+// — `chain.<Contract>.addresses` only exposes the event's contract — so one
+// inner dict covers the srcAddress and param-address checks alike. Returns a
+// shared empty dict when the contract has no registered addresses.
+let forContract = (indexingAddresses: t, ~contractName): dict<indexingAddress> =>
+  switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(contractName) {
+  | Some(inner) => inner
+  | None => emptyContractDict
+  }
 
 let register = (indexingAddresses: t, additions: dict<indexingAddress>) => {
-  let _ = Utils.Dict.mergeInPlace(indexingAddresses, additions)
+  additions->Utils.Dict.forEach(indexingAddress => {
+    indexingAddresses->insert(indexingAddress)
+  })
 }
 
 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)
-    }
+  indexingAddresses->Utils.Dict.forEach(inner => {
+    inner->Utils.Dict.forEachWithKey((indexingContract, address) => {
+      if indexingContract.registrationBlock > targetBlockNumber {
+        inner->Utils.Dict.deleteInPlace(address)
+      }
+    })
   })
 }

package/src/IndexingAddresses.res.mjs

@@ -43,47 +43,75 @@ function makeIndexingAddress(contract, contractConfigs) {
   };
 }
 
+function insert(indexingAddresses, indexingAddress) {
+  Utils.Dict.getOrInsertEmptyDict(indexingAddresses, indexingAddress.contractName)[indexingAddress.address] = indexingAddress;
+}
+
 function make(contractConfigs, addresses) {
   let indexingAddresses = {};
-  addresses.forEach(contract => {
-    indexingAddresses[contract.address] = makeIndexingAddress(contract, contractConfigs);
-  });
+  addresses.forEach(contract => insert(indexingAddresses, makeIndexingAddress(contract, contractConfigs)));
   return indexingAddresses;
 }
 
-function get(indexingAddresses, address) {
-  return indexingAddresses[address];
-}
+let get = ((index, address) => {
+  for (var contractName in index) {
+    var entry = index[contractName][address];
+    if (entry !== undefined) {
+      return entry;
+    }
+  }
+  return undefined;
+});
 
 function size(indexingAddresses) {
-  return Utils.Dict.size(indexingAddresses);
+  let total = {
+    contents: 0
+  };
+  Utils.Dict.forEach(indexingAddresses, inner => {
+    total.contents = total.contents + Utils.Dict.size(inner) | 0;
+  });
+  return total.contents;
+}
+
+function contractCount(indexingAddresses, contractName) {
+  let inner = indexingAddresses[contractName];
+  if (inner !== undefined) {
+    return Utils.Dict.size(inner);
+  } else {
+    return 0;
+  }
 }
 
 function getContractAddresses(indexingAddresses, contractName) {
-  let addresses = [];
-  Utils.Dict.forEach(indexingAddresses, ia => {
-    if (ia.contractName === contractName) {
-      addresses.push(ia.address);
-      return;
-    }
-  });
-  return addresses;
+  let inner = indexingAddresses[contractName];
+  if (inner !== undefined) {
+    return Object.values(inner).map(ia => ia.address);
+  } else {
+    return [];
+  }
 }
 
-function rawForFilter(indexingAddresses) {
-  return indexingAddresses;
+let emptyContractDict = {};
+
+function forContract(indexingAddresses, contractName) {
+  let inner = indexingAddresses[contractName];
+  if (inner !== undefined) {
+    return inner;
+  } else {
+    return emptyContractDict;
+  }
 }
 
 function register(indexingAddresses, additions) {
-  Object.assign(indexingAddresses, additions);
+  Utils.Dict.forEach(additions, indexingAddress => insert(indexingAddresses, indexingAddress));
 }
 
 function rollbackInPlace(indexingAddresses, targetBlockNumber) {
-  Utils.Dict.forEachWithKey(indexingAddresses, (indexingContract, address) => {
+  Utils.Dict.forEach(indexingAddresses, inner => Utils.Dict.forEachWithKey(inner, (indexingContract, address) => {
     if (indexingContract.registrationBlock > targetBlockNumber) {
-      return Utils.Dict.deleteInPlace(indexingAddresses, address);
+      return Utils.Dict.deleteInPlace(inner, address);
     }
-  });
+  }));
 }
 
 export {
@@ -93,8 +121,9 @@ export {
   make,
   get,
   size,
+  contractCount,
   getContractAddresses,
-  rawForFilter,
+  forContract,
   register,
   rollbackInPlace,
 }

package/src/IndexingAddresses.resi

@@ -21,12 +21,17 @@ let get: (t, string) => option<indexingAddress>
 
 let size: t => int
 
+// Number of registered addresses for a single contract (scans just that
+// contract's addresses).
+let contractCount: (t, ~contractName: string) => 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>
+// The address→entry dict for a single contract, passed to that contract's
+// precompiled `clientAddressFilter` (raw `byAddr[srcAddress]` access in
+// generated JS). Don't use elsewhere — prefer the domain accessors so the
+// opaque type stays enforced.
+let forContract: (t, ~contractName: string) => dict<indexingAddress>
 
 let register: (t, dict<indexingAddress>) => unit
 

package/src/TestIndexer.res

@@ -199,7 +199,11 @@ let handleWriteBatch = (
           if deleted->Array.length > 0 {
             entityObj->Dict.set("deleted", deleted->(Utils.magic: array<string> => unknown))
           }
-          change->Dict.set(entityName, entityObj->(Utils.magic: dict<unknown> => unknown))
+          // Match the capitalized entity accessor the generated change types expose.
+          change->Dict.set(
+            entityName->Utils.String.capitalize,
+            entityObj->(Utils.magic: dict<unknown> => unknown),
+          )
         }
       })
     | None => ()
@@ -699,7 +703,9 @@ let createTestIndexer = (): t<'processConfig> => {
   entityOpsDict
   ->Dict.toArray
   ->Array.forEach(((name, ops)) => {
-    result->Dict.set(name, ops->(Utils.magic: entityOperations => unknown))
+    // Expose the capitalized accessor (indexer.Pool_snapshots) the generated
+    // types declare, matching the handler-context keys.
+    result->Dict.set(name->Utils.String.capitalize, ops->(Utils.magic: entityOperations => unknown))
   })
 
   result->Dict.set(

package/src/TestIndexer.res.mjs

@@ -146,7 +146,7 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
         if (deleted.length !== 0) {
           entityObj$1["deleted"] = deleted;
         }
-        change[entityName] = entityObj$1;
+        change[Utils.$$String.capitalize(entityName)] = entityObj$1;
       });
     }
     state.processChanges.push(change);
@@ -470,7 +470,7 @@ function createTestIndexer() {
   result["chainIds"] = chainIds;
   result["chains"] = chains;
   Object.entries(entityOpsDict).forEach(param => {
-    result[param[0]] = param[1];
+    result[Utils.$$String.capitalize(param[0])] = param[1];
   });
   result["process"] = processConfig => {
     if (state.processInProgress) {

package/src/sources/EvmHyperSyncSource.res

@@ -1,6 +1,5 @@
 open Source
 
-
 // Surfaced by HyperSyncClient.getHeight (Rust) when HyperSync rejects the API
 // token. The corrupted-token test feeds the real server error through this
 // check so it can't silently drift away from what getHeightOrThrow guards on.
@@ -46,9 +45,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     ~url=endpointUrl,
     ~apiToken,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
-    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(
-      onEventRegistrations,
-    ),
+    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~enableChecksumAddresses=!lowercaseAddresses,
     ~serializationFormat,
     ~enableQueryCaching,
@@ -110,6 +107,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       ~maxNumLogs=itemsTarget,
       ~registrationIndexes=selection.onEventRegistrations->Array.map(reg => reg.index),
       ~addressesByContractName,
+      ~clientFilteredContracts=selection.clientFilteredContracts,
     ) catch {
     | HyperSync.GetLogs.Error(error) =>
       throw(
@@ -180,8 +178,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     let getBlock = blockNumber => blocksByNumber->Utils.Map.unsafeGet(blockNumber)
 
     pageUnsafe.items->Array.forEach(item => {
-      let onEventRegistration =
-        onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex)
+      let onEventRegistration = onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex)
       parsedQueueItems
       ->Array.push(makeEventBatchQueueItem(item, ~onEventRegistration))
       ->ignore

package/src/sources/EvmHyperSyncSource.res.mjs

@@ -57,7 +57,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
     let startFetchingBatchTimeRef = Performance.now();
     let pageUnsafe;
     try {
-      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, itemsTarget, selection.onEventRegistrations.map(reg => reg.index), addressesByContractName);
+      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, itemsTarget, selection.onEventRegistrations.map(reg => reg.index), addressesByContractName, selection.clientFilteredContracts);
     } catch (raw_error) {
       let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {

package/src/sources/EvmRpcClient.res

@@ -27,6 +27,10 @@ type nextPageParams = {
   // registrations passed at construction.
   registrationIndexes: array<int>,
   addressesByContractName: dict<array<Address.t>>,
+  // Contract names to fetch address-free even though their registrations
+  // depend on addresses (client-side filtering). None/empty means
+  // every address-dependent contract is filtered server-side.
+  clientFilteredContracts: option<array<string>>,
 }
 
 type nextPageResponse = {

package/src/sources/HyperSync.res

@@ -93,13 +93,15 @@ module GetLogs = {
     ~maxNumLogs,
     ~registrationIndexes,
     ~addressesByContractName,
+    ~clientFilteredContracts,
   ): logsQueryPage => {
     let query: HyperSyncClient.EventItems.query = {
       fromBlock,
       toBlock,
-      maxNumLogs,
+      ?maxNumLogs,
       registrationIndexes,
       addressesByContractName,
+      clientFilteredContracts,
     }
 
     let (res, transactionStore, blockStore) = switch await client.getEventItems(~query) {

package/src/sources/HyperSync.res.mjs

@@ -82,13 +82,14 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName) {
+async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName, clientFilteredContracts) {
   let query$1 = {
     fromBlock: fromBlock,
     toBlock: toBlock,
     maxNumLogs: maxNumLogs,
     registrationIndexes: registrationIndexes,
-    addressesByContractName: addressesByContractName
+    addressesByContractName: addressesByContractName,
+    clientFilteredContracts: clientFilteredContracts
   };
   let match;
   try {

package/src/sources/HyperSync.resi

@@ -32,9 +32,10 @@ module GetLogs: {
     ~client: HyperSyncClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
-    ~maxNumLogs: int,
+    ~maxNumLogs: option<int>,
     ~registrationIndexes: array<int>,
     ~addressesByContractName: dict<array<Address.t>>,
+    ~clientFilteredContracts: option<array<string>>,
   ) => promise<logsQueryPage>
 }
 

package/src/sources/HyperSyncClient.res

@@ -309,9 +309,14 @@ module EventItems = {
     fromBlock: int,
     // Inclusive; None queries to the end of available data.
     toBlock: option<int>,
-    maxNumLogs: int,
+    // Absent means no server-side cap on the number of logs returned.
+    maxNumLogs?: int,
     registrationIndexes: array<int>,
     addressesByContractName: dict<array<Address.t>>,
+    // Contract names to fetch address-free even though their registrations
+    // depend on addresses (client-side filtering). None/empty means
+    // every address-dependent contract is filtered server-side.
+    clientFilteredContracts: option<array<string>>,
   }
 
   type item = {

package/src/sources/RpcSource.res

@@ -97,7 +97,6 @@ let getErrorMessage = (exn: exn): option<string> =>
   | _ => None
   }
 
-
 // `EvmRpcClient.getNextPage` throws a napi error whose message is a JSON
 // payload describing the retry decision:
 // `{"kind":"Retry","attemptedToBlock":int,"errorMessage":string|null,
@@ -647,9 +646,7 @@ let make = (
   let client = Rpc.makeClient(url, ~headers?)
   let rpcClient = EvmRpcClient.make(
     ~url,
-    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(
-      onEventRegistrations,
-    ),
+    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~checksumAddresses=!lowercaseAddresses,
     ~syncConfig,
     ~headers?,
@@ -839,6 +836,7 @@ let make = (
       partitionId,
       registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
       addressesByContractName,
+      clientFilteredContracts: selection.clientFilteredContracts,
     }) catch {
     | exn =>
       switch exn->parseGetNextPageRetryError {
@@ -879,63 +877,64 @@ let make = (
         onEventRegistration.eventConfig->(
           Utils.magic: Internal.eventConfig => Internal.evmEventConfig
         )
+
       (
         async () => {
-                let (block, transaction) = try await Promise.all2((
-                  log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
-                  log->getEventTransactionOrThrow(
-                    ~selectedTransactionFields=eventConfig.selectedTransactionFields->(
-                      Utils.magic: Utils.Set.t<string> => Utils.Set.t<Internal.evmTransactionField>
-                    ),
-                  ),
-                )) catch {
-                | TransactionDataNotFound({message}) =>
-                  let backoffMillis = switch retry {
-                  | 0 => 100
-                  | _ => 500 * retry
-                  }
-                  throw(
-                    Source.GetItemsError(
-                      FailedGettingItems({
-                        exn: %raw(`null`),
-                        attemptedToBlock: toBlock,
-                        retry: WithBackoff({
-                          message: `${message}. The RPC provider might be load-balanced between nodes that drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${backoffMillis->Int.toString}ms.`,
-                          backoffMillis,
-                        }),
-                      }),
-                    ),
-                  )
-                | exn =>
-                  throw(
-                    Source.GetItemsError(
-                      FailedGettingFieldSelection({
-                        message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
-                        exn,
-                        blockNumber: log.blockNumber,
-                        logIndex: log.logIndex,
-                      }),
-                    ),
-                  )
-                }
-
-                Internal.Event({
-                  onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
-                  blockNumber: block->getBlockNumber,
-                  chain,
+          let (block, transaction) = try await Promise.all2((
+            log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
+            log->getEventTransactionOrThrow(
+              ~selectedTransactionFields=eventConfig.selectedTransactionFields->(
+                Utils.magic: Utils.Set.t<string> => Utils.Set.t<Internal.evmTransactionField>
+              ),
+            ),
+          )) catch {
+          | TransactionDataNotFound({message}) =>
+            let backoffMillis = switch retry {
+            | 0 => 100
+            | _ => 500 * retry
+            }
+            throw(
+              Source.GetItemsError(
+                FailedGettingItems({
+                  exn: %raw(`null`),
+                  attemptedToBlock: toBlock,
+                  retry: WithBackoff({
+                    message: `${message}. The RPC provider might be load-balanced between nodes that drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${backoffMillis->Int.toString}ms.`,
+                    backoffMillis,
+                  }),
+                }),
+              ),
+            )
+          | exn =>
+            throw(
+              Source.GetItemsError(
+                FailedGettingFieldSelection({
+                  message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
+                  exn,
+                  blockNumber: log.blockNumber,
                   logIndex: log.logIndex,
-                  transactionIndex: log.transactionIndex,
-                  payload: {
-                    contractName: eventConfig.contractName,
-                    eventName: eventConfig.name,
-                    chainId: chain->ChainMap.Chain.toChainId,
-                    params: decoded,
-                    block,
-                    transaction,
-                    srcAddress: log.address,
-                    logIndex: log.logIndex,
-                  }->Evm.fromPayload,
-                })
+                }),
+              ),
+            )
+          }
+
+          Internal.Event({
+            onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
+            blockNumber: block->getBlockNumber,
+            chain,
+            logIndex: log.logIndex,
+            transactionIndex: log.transactionIndex,
+            payload: {
+              contractName: eventConfig.contractName,
+              eventName: eventConfig.name,
+              chainId: chain->ChainMap.Chain.toChainId,
+              params: decoded,
+              block,
+              transaction,
+              srcAddress: log.address,
+              logIndex: log.logIndex,
+            }->Evm.fromPayload,
+          })
         }
       )()
     })

package/src/sources/RpcSource.res.mjs

@@ -841,7 +841,8 @@ function make(param) {
         toBlockCeiling: toBlock$1,
         partitionId: partitionId,
         registrationIndexes: selection.onEventRegistrations.map(reg => reg.index),
-        addressesByContractName: addressesByContractName
+        addressesByContractName: addressesByContractName,
+        clientFilteredContracts: selection.clientFilteredContracts
       });
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);

package/src/sources/Source.res

@@ -82,8 +82,10 @@ type t = {
     // source should ask its backend for, from the query's own estResponseSize.
     // A HyperSync-backed source enforces it server-side, so a wrong estimate
     // truncates the response instead of overshooting the shared buffer. Sources
-    // without an equivalent lever (RPC, Fuel, Simulate) ignore it.
-    ~itemsTarget: int,
+    // without an equivalent lever (RPC, Fuel, Simulate) ignore it. None means no
+    // cap: bounded chunk queries fetch their whole range even if denser than
+    // expected, so client-side-filtered items can't truncate the range short.
+    ~itemsTarget: option<int>,
     ~retry: int,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,

package/src/sources/SvmHyperSyncClient.res

@@ -188,7 +188,8 @@ module EventItems = {
     fromSlot: int,
     // Inclusive; None queries to the end of available data.
     toSlot: option<int>,
-    maxNumInstructions: int,
+    // Absent means no server-side cap on the number of instructions returned.
+    maxNumInstructions?: int,
     registrationIndexes: array<int>,
     addressesByContractName: dict<array<Address.t>>,
   }

package/src/sources/SvmHyperSyncSource.res

@@ -100,7 +100,7 @@ let make = (
     let query: SvmHyperSyncClient.EventItems.query = {
       fromSlot: fromBlock,
       toSlot: toBlock,
-      maxNumInstructions: itemsTarget,
+      maxNumInstructions: ?itemsTarget,
       registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
       addressesByContractName,
     }