envio 3.5.0-alpha.1 → 3.5.0-alpha.2

package/src/sources/SimulateSource.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function make(items, endBlock, chain) {
   let reportedHeight = Primitive_int.max(endBlock, 1);
@@ -22,7 +21,7 @@ function make(items, endBlock, chain) {
       height: reportedHeight,
       requestStats: []
     }),
-    getItemsOrThrow: (fromBlock, toBlock, param, contractNameByAddress, param$1, param$2, selection, param$3, param$4, param$5) => {
+    getItemsOrThrow: (fromBlock, toBlock, addressSet, param, param$1, selection, param$2, param$3, param$4) => {
       let toBlockQueried = toBlock !== undefined ? toBlock : reportedHeight;
       let selectionEventIds = new Set();
       selection.onEventRegistrations.forEach(reg => {
@@ -37,11 +36,20 @@ function make(items, endBlock, chain) {
         if (!selectionEventIds.has(onEventRegistration.eventConfig.id)) {
           return false;
         }
-        if (onEventRegistration.isWildcard) {
+        let contractName = onEventRegistration.eventConfig.contractName;
+        let emitterAllowed = onEventRegistration.isWildcard || addressSet.has(item.payload.srcAddress, contractName, blockNumber);
+        if (!emitterAllowed) {
+          return false;
+        }
+        let groups = onEventRegistration.addressFilterParamGroups;
+        if (groups === undefined) {
+          return true;
+        }
+        if (groups.length === 0) {
           return true;
         }
-        let sa = item.payload.srcAddress;
-        return Stdlib_Option.isSome(contractNameByAddress[sa]);
+        let params = item.payload.params;
+        return groups.some(group => group.every(name => addressSet.has(params[name], contractName, blockNumber)));
       });
       return Promise.resolve({
         knownHeight: reportedHeight,

package/src/sources/Source.res

@@ -73,8 +73,10 @@ type t = {
   getItemsOrThrow: (
     ~fromBlock: int,
     ~toBlock: option<int>,
-    ~addressesByContractName: dict<array<Address.t>>,
-    ~contractNameByAddress: dict<string>,
+    // The partition's slice of the chain's address index. The source hands it
+    // straight to its Rust client, which builds the query's address filter from
+    // it and gates every returned item against the chain-wide store.
+    ~addressSet: AddressSet.t,
     ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,

package/src/sources/SourceManager.res

@@ -754,7 +754,7 @@ let executeQuery = async (
         "source": source.name,
         "fromBlock": query.fromBlock,
         "toBlock": toBlock,
-        "addresses": query.addressesByContractName->FetchState.addressesByContractNameCount,
+        "addresses": query.addresses->AddressSet.size,
         "retry": retry,
       },
     )
@@ -763,8 +763,7 @@ let executeQuery = async (
       let response = await source.getItemsOrThrow(
         ~fromBlock=query.fromBlock,
         ~toBlock,
-        ~addressesByContractName=query.addressesByContractName,
-        ~contractNameByAddress=query.addressesByContractName->FetchState.deriveContractNameByAddress,
+        ~addressSet=query.addresses,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,

package/src/sources/SourceManager.res.mjs

@@ -3,7 +3,6 @@
 import * as Utils from "../Utils.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as FetchState from "../FetchState.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -597,11 +596,11 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
       source: source.name,
       fromBlock: query.fromBlock,
       toBlock: toBlock,
-      addresses: FetchState.addressesByContractNameCount(query.addressesByContractName),
+      addresses: query.addresses.size(),
       retry: retry
     });
     try {
-      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, FetchState.deriveContractNameByAddress(query.addressesByContractName), knownHeight, query.partitionId, query.selection, query.itemsTarget, retry, logger$2);
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addresses, knownHeight, query.partitionId, query.selection, query.itemsTarget, retry, logger$2);
       recordRequestStats(sourceState, response.requestStats);
       sourceState.lastFailedAt = undefined;
       if (response.knownHeight > sourceState.knownHeight) {

package/src/sources/Svm.res

@@ -100,8 +100,7 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
     getItemsOrThrow: (
       ~fromBlock as _,
       ~toBlock as _,
-      ~addressesByContractName as _,
-      ~contractNameByAddress as _,
+      ~addressSet as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,

package/src/sources/Svm.res.mjs

@@ -91,7 +91,7 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
           }]
       };
     },
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => Stdlib_JsError.throwWithMessage("Svm does not support getting items")
+    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => Stdlib_JsError.throwWithMessage("Svm does not support getting items")
   };
 }
 

package/src/sources/SvmHyperSyncClient.res

@@ -191,7 +191,10 @@ module EventItems = {
     // Absent means no server-side cap on the number of instructions returned.
     maxNumInstructions?: int,
     registrationIndexes: array<int>,
-    addressesByContractName: dict<array<Address.t>>,
+    // Program names to fetch address-free even though their registrations
+    // depend on addresses (client-side filtering). None/empty means every
+    // address-dependent program is filtered server-side.
+    clientFilteredContracts: option<array<string>>,
   }
 
   type log = {
@@ -221,8 +224,10 @@ module EventItems = {
 
   type response = {
     nextSlot: int,
-    // One lean header per slot referenced by `items`; the full blocks live in
-    // the block store returned alongside.
+    // One lean header per returned slot, including slots no item references —
+    // reorg detection and the batch's latest timestamp read them all. The full
+    // blocks live in the block store returned alongside, which keeps only the
+    // slots items reference.
     blocks: array<ResponseTypes.block>,
     items: array<item>,
   }
@@ -240,6 +245,7 @@ type t = {
   // prep.
   getEventItems: (
     ~query: EventItems.query,
+    ~addressSet: AddressSet.t,
   ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
 }
 
@@ -249,6 +255,7 @@ external classFromConfig: (
   cfg,
   string,
   array<Registration.input>,
+  AddressStore.t,
 ) => t = "fromConfig"
 
 let make = (
@@ -259,6 +266,7 @@ let make = (
   ~retryBaseMs=?,
   ~retryCeilingMs=?,
   ~eventRegistrations=[],
+  ~addressStore,
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
   Core.getAddon().svmHyperSyncClient->classFromConfig(
@@ -272,5 +280,6 @@ let make = (
     },
     `hyperindex/${envioVersion}`,
     eventRegistrations,
+    addressStore,
   )
 }

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -45,7 +45,7 @@ let ResponseTypes = {};
 
 let EventItems = {};
 
-function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, eventRegistrationsOpt) {
+function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, eventRegistrationsOpt, addressStore) {
   let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let envioVersion = Utils.EnvioPackage.value.version;
   return Core.getAddon().SvmHyperSyncClient.fromConfig({
@@ -55,7 +55,7 @@ function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, r
     maxNumRetries: maxNumRetries,
     retryBaseMs: retryBaseMs,
     retryCeilingMs: retryCeilingMs
-  }, `hyperindex/` + envioVersion, eventRegistrations);
+  }, `hyperindex/` + envioVersion, eventRegistrations, addressStore);
 }
 
 export {

package/src/sources/SvmHyperSyncSource.res

@@ -6,6 +6,8 @@ type options = {
   apiToken: option<string>,
   onEventRegistrations: array<Internal.svmOnEventRegistration>,
   clientTimeoutMillis: int,
+  // The chain's address index; the client reads it while routing.
+  addressStore: AddressStore.t,
 }
 
 // Synthesize a stable logIndex for an SVM instruction so the FetchState
@@ -66,7 +68,7 @@ let toSvmInstruction = (
 }
 
 let make = (
-  {chain, endpointUrl, apiToken, onEventRegistrations, clientTimeoutMillis}: options,
+  {chain, endpointUrl, apiToken, onEventRegistrations, clientTimeoutMillis, addressStore}: options,
 ): t => {
   let name = "SvmHyperSync"
 
@@ -80,13 +82,13 @@ let make = (
     ~eventRegistrations=SvmHyperSyncClient.Registration.fromOnEventRegistrations(
       onEventRegistrations,
     ),
+    ~addressStore,
   )
 
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress as _,
+    ~addressSet,
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
@@ -102,10 +104,13 @@ let make = (
       toSlot: toBlock,
       maxNumInstructions: ?itemsTarget,
       registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
-      addressesByContractName,
+      clientFilteredContracts: selection.clientFilteredContracts,
     }
 
-    let (resp, transactionStore, blockStore) = try await client.getEventItems(~query) catch {
+    let (resp, transactionStore, blockStore) = try await client.getEventItems(
+      ~query,
+      ~addressSet,
+    ) catch {
     | exn =>
       throw(
         Source.GetItemsError(

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -58,21 +58,22 @@ function toSvmInstruction(item, programName, instructionName) {
 function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
-  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, param$1, selection, itemsTarget, retry, param$2) => {
+  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
+  let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let pageFetchRef = Performance.now();
     let query_registrationIndexes = selection.onEventRegistrations.map(reg => reg.index);
+    let query_clientFilteredContracts = selection.clientFilteredContracts;
     let query = {
       fromSlot: fromBlock,
       toSlot: toBlock,
       maxNumInstructions: itemsTarget,
       registrationIndexes: query_registrationIndexes,
-      addressesByContractName: addressesByContractName
+      clientFilteredContracts: query_clientFilteredContracts
     };
     let match;
     try {
-      match = await client.getEventItems(query);
+      match = await client.getEventItems(query, addressSet);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {

package/src/IndexingAddresses.res

@@ -1,151 +0,0 @@
-type indexingAddress = Internal.indexingContract
-
-type contractConfig = {startBlock: option<int>}
-
-// 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))
-}
-
-let makeContractConfigs = (~onEventRegistrations: array<Internal.onEventRegistration>): dict<
-  contractConfig,
-> => {
-  let contractConfigs: dict<contractConfig> = Dict.make()
-  onEventRegistrations->Array.forEach(reg => {
-    let contractName = reg.eventConfig.contractName
-    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(contractName) {
-    | Some({startBlock}) =>
-      contractConfigs->Dict.set(
-        contractName,
-        {
-          startBlock: switch (startBlock, reg.startBlock) {
-          | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
-          | (Some(_) as s, None) | (None, Some(_) as s) => s
-          | (None, None) => None
-          },
-        },
-      )
-    | None =>
-      contractConfigs->Dict.set(
-        contractName,
-        {
-          startBlock: reg.startBlock,
-        },
-      )
-    }
-  })
-  contractConfigs
-}
-
-let makeIndexingAddress = (
-  ~contract: Internal.indexingAddress,
-  ~contractConfigs: dict<contractConfig>,
-): indexingAddress => {
-  let contractStartBlock = switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(
-    contract.contractName,
-  ) {
-  | Some({startBlock}) => startBlock
-  | None => None
-  }
-  {
-    address: contract.address,
-    contractName: contract.contractName,
-    registrationBlock: contract.registrationBlock,
-    effectiveStartBlock: deriveEffectiveStartBlock(
-      ~registrationBlock=contract.registrationBlock,
-      ~contractStartBlock,
-    ),
-  }
-}
-
-let 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->insert(makeIndexingAddress(~contract, ~contractConfigs))
-  })
-  indexingAddresses
-}
-
-// 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
-}
-
-// 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> => {
-  switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(contractName) {
-  | Some(inner) => inner->Dict.valuesToArray->Array.map(ia => ia.address)
-  | None => []
-  }
-}
-
-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>) => {
-  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.forEach(inner => {
-    inner->Utils.Dict.forEachWithKey((indexingContract, address) => {
-      if indexingContract.registrationBlock > targetBlockNumber {
-        inner->Utils.Dict.deleteInPlace(address)
-      }
-    })
-  })
-}

package/src/IndexingAddresses.res.mjs

@@ -1,130 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Utils from "./Utils.res.mjs";
-import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-
-function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
-  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
-}
-
-function makeContractConfigs(onEventRegistrations) {
-  let contractConfigs = {};
-  onEventRegistrations.forEach(reg => {
-    let contractName = reg.eventConfig.contractName;
-    let match = contractConfigs[contractName];
-    if (match !== undefined) {
-      let startBlock = match.startBlock;
-      let match$1 = reg.startBlock;
-      contractConfigs[contractName] = {
-        startBlock: startBlock !== undefined ? (
-            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
-          ) : (
-            match$1 !== undefined ? match$1 : undefined
-          )
-      };
-      return;
-    }
-    contractConfigs[contractName] = {
-      startBlock: reg.startBlock
-    };
-  });
-  return contractConfigs;
-}
-
-function makeIndexingAddress(contract, contractConfigs) {
-  let match = contractConfigs[contract.contractName];
-  let contractStartBlock = match !== undefined ? match.startBlock : undefined;
-  return {
-    address: contract.address,
-    contractName: contract.contractName,
-    registrationBlock: contract.registrationBlock,
-    effectiveStartBlock: deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock)
-  };
-}
-
-function insert(indexingAddresses, indexingAddress) {
-  Utils.Dict.getOrInsertEmptyDict(indexingAddresses, indexingAddress.contractName)[indexingAddress.address] = indexingAddress;
-}
-
-function make(contractConfigs, addresses) {
-  let indexingAddresses = {};
-  addresses.forEach(contract => insert(indexingAddresses, makeIndexingAddress(contract, contractConfigs)));
-  return indexingAddresses;
-}
-
-let get = ((index, address) => {
-  for (var contractName in index) {
-    var entry = index[contractName][address];
-    if (entry !== undefined) {
-      return entry;
-    }
-  }
-  return undefined;
-});
-
-function 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 inner = indexingAddresses[contractName];
-  if (inner !== undefined) {
-    return Object.values(inner).map(ia => ia.address);
-  } else {
-    return [];
-  }
-}
-
-let emptyContractDict = {};
-
-function forContract(indexingAddresses, contractName) {
-  let inner = indexingAddresses[contractName];
-  if (inner !== undefined) {
-    return inner;
-  } else {
-    return emptyContractDict;
-  }
-}
-
-function register(indexingAddresses, additions) {
-  Utils.Dict.forEach(additions, indexingAddress => insert(indexingAddresses, indexingAddress));
-}
-
-function rollbackInPlace(indexingAddresses, targetBlockNumber) {
-  Utils.Dict.forEach(indexingAddresses, inner => Utils.Dict.forEachWithKey(inner, (indexingContract, address) => {
-    if (indexingContract.registrationBlock > targetBlockNumber) {
-      return Utils.Dict.deleteInPlace(inner, address);
-    }
-  }));
-}
-
-export {
-  deriveEffectiveStartBlock,
-  makeContractConfigs,
-  makeIndexingAddress,
-  make,
-  get,
-  size,
-  contractCount,
-  getContractAddresses,
-  forContract,
-  register,
-  rollbackInPlace,
-}
-/* Utils Not a pure module */

package/src/IndexingAddresses.resi

@@ -1,39 +0,0 @@
-type indexingAddress = Internal.indexingContract
-
-type contractConfig = {startBlock: option<int>}
-
-type t
-
-let deriveEffectiveStartBlock: (~registrationBlock: int, ~contractStartBlock: option<int>) => int
-
-let makeContractConfigs: (
-  ~onEventRegistrations: array<Internal.onEventRegistration>,
-) => dict<contractConfig>
-
-let makeIndexingAddress: (
-  ~contract: Internal.indexingAddress,
-  ~contractConfigs: dict<contractConfig>,
-) => indexingAddress
-
-let make: (~contractConfigs: dict<contractConfig>, ~addresses: array<Internal.indexingAddress>) => t
-
-let get: (t, string) => option<indexingAddress>
-
-let size: t => int
-
-// 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>
-
-// 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
-
-// Deletes addresses registered after `targetBlockNumber` from the index in place.
-let rollbackInPlace: (t, ~targetBlockNumber: int) => unit