envio 3.3.0-alpha.8 → 3.3.0-rc.0

package/src/sources/EvmRpcClient.res

@@ -1,32 +1,51 @@
-type cfg = {url: string, httpReqTimeoutMillis?: int, headers?: dict<string>}
-
-// `addresses` omitted matches any address (a wildcard selection). Each `topics`
-// position is `null` (match any) or a list of accepted topic hashes; the
-// single-match case is a one-element list.
-type getLogsParams = {
-  fromBlock: int,
-  toBlock: int,
-  addresses?: array<Address.t>,
-  topics: array<Nullable.t<array<string>>>,
+type cfg = {
+  url: string,
+  httpReqTimeoutMillis?: int,
+  headers?: dict<string>,
+  initialBlockInterval: int,
+  backoffMultiplicative: float,
+  accelerationAdditive: int,
+  intervalCeiling: int,
+  backoffMillis: int,
+  queryTimeoutMillis: int,
 }
 
-// Decoded `params` keyed by contract name, matching the HyperSync decoder's
-// shape so the caller routes by address then picks its contract's params.
+// Only logs that resolved to a registration cross the boundary, each carrying
+// its registration's chain-scoped index.
 type rpcEventItem = {
   log: Rpc.GetLogs.log,
-  params: Nullable.t<dict<Internal.eventParams>>,
+  onEventRegistrationIndex: int,
+  params: Internal.eventParams,
+}
+
+type nextPageParams = {
+  fromBlock: int,
+  toBlockCeiling: int,
+  partitionId: string,
+  // The partition's registration selection, by chain-scoped index. Log
+  // selections and the routing index are derived on the Rust side from the
+  // registrations passed at construction.
+  registrationIndexes: array<int>,
+  addressesByContractName: dict<array<Address.t>>,
+}
+
+type nextPageResponse = {
+  items: array<rpcEventItem>,
+  toBlock: int,
+  requestStats: array<Source.requestStat>,
 }
 
+// The caller provides a range; Rust decides the actual `toBlock` and returns it.
 type t = {
   getHeight: unit => promise<int>,
-  getLogs: getLogsParams => promise<array<rpcEventItem>>,
+  getNextPage: nextPageParams => promise<nextPageResponse>,
 }
 
 @send
 external classNew: (
   Core.evmRpcClientCtor,
   cfg,
-  array<HyperSyncClient.Decoder.eventParamsInput>,
+  array<HyperSyncClient.Registration.input>,
   ~checksumAddresses: bool,
 ) => t = "new"
 
@@ -59,15 +78,31 @@ let coerceErrorOrThrow = exn =>
   | None => exn->throw
   }
 
-let make = (~url, ~checksumAddresses, ~httpReqTimeoutMillis=?, ~headers=?, ~allEventParams=[]) => {
-  let client =
-    Core.getAddon().evmRpcClient->classNew(
-      {url, ?httpReqTimeoutMillis, ?headers},
-      allEventParams,
-      ~checksumAddresses,
-    )
+let make = (
+  ~url,
+  ~checksumAddresses,
+  ~syncConfig: Config.sourceSync,
+  ~httpReqTimeoutMillis=?,
+  ~headers=?,
+  ~eventRegistrations=[],
+) => {
+  let client = Core.getAddon().evmRpcClient->classNew(
+    {
+      url,
+      ?httpReqTimeoutMillis,
+      ?headers,
+      initialBlockInterval: syncConfig.initialBlockInterval,
+      backoffMultiplicative: syncConfig.backoffMultiplicative,
+      accelerationAdditive: syncConfig.accelerationAdditive,
+      intervalCeiling: syncConfig.intervalCeiling,
+      backoffMillis: syncConfig.backoffMillis,
+      queryTimeoutMillis: syncConfig.queryTimeoutMillis,
+    },
+    eventRegistrations,
+    ~checksumAddresses,
+  )
   {
     getHeight: () => client.getHeight()->Promise.catch(coerceErrorOrThrow),
-    getLogs: params => client.getLogs(params)->Promise.catch(coerceErrorOrThrow),
+    getNextPage: params => client.getNextPage(params)->Promise.catch(coerceErrorOrThrow),
   }
 }

package/src/sources/EvmRpcClient.res.mjs

@@ -46,16 +46,22 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, checksumAddresses, httpReqTimeoutMillis, headers, allEventParamsOpt) {
-  let allEventParams = allEventParamsOpt !== undefined ? allEventParamsOpt : [];
+function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt) {
+  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
-    headers: headers
-  }, allEventParams, checksumAddresses);
+    headers: headers,
+    initialBlockInterval: syncConfig.initialBlockInterval,
+    backoffMultiplicative: syncConfig.backoffMultiplicative,
+    accelerationAdditive: syncConfig.accelerationAdditive,
+    intervalCeiling: syncConfig.intervalCeiling,
+    backoffMillis: syncConfig.backoffMillis,
+    queryTimeoutMillis: syncConfig.queryTimeoutMillis
+  }, eventRegistrations, checksumAddresses);
   return {
     getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
-    getLogs: params => Stdlib_Promise.$$catch(client.getLogs(params), coerceErrorOrThrow)
+    getNextPage: params => Stdlib_Promise.$$catch(client.getNextPage(params), coerceErrorOrThrow)
   };
 }
 

package/src/sources/Fuel.res

@@ -35,8 +35,10 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // Analogous to EVM, but keyed by `block.height` instead of
   // `block.number`. See `Evm.res` for the rationale on the two-stage
   // parse and the `_lte`/`_every` rejection.
+  // `S.strict` on the inner object rejects unknown `block` fields — including
+  // `block.number`, which is EVM-only; Fuel filters by `block.height`.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))->S.strict))
   ),
   logger,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),

package/src/sources/Fuel.res.mjs

@@ -19,7 +19,7 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {

package/src/sources/HyperSync.res

@@ -61,23 +61,6 @@ module GetLogs = {
 
   exception Error(error)
 
-  let makeRequestBody = (
-    ~fromBlock,
-    ~toBlockInclusive,
-    ~addressesWithTopics,
-    ~fieldSelection,
-    ~maxNumLogs,
-  ): HyperSyncClient.QueryTypes.query => {
-    fromBlock,
-    toBlockExclusive: ?switch toBlockInclusive {
-    | Some(toBlockInclusive) => Some(toBlockInclusive + 1)
-    | None => None
-    },
-    logs: addressesWithTopics,
-    fieldSelection,
-    maxNumLogs,
-  }
-
   // Rust encodes structured failures as a JSON payload in the napi error's
   // message: `{"kind":"MissingFields","fields":["block.timestamp", ...]}`.
   // JSON.parse + shape check is the recovery protocol — no string-grepping
@@ -107,29 +90,17 @@ module GetLogs = {
     ~client: HyperSyncClient.t,
     ~fromBlock,
     ~toBlock,
-    ~logSelections: array<LogSelection.t>,
-    ~fieldSelection,
     ~maxNumLogs,
+    ~registrationIndexes,
+    ~addressesByContractName,
   ): logsQueryPage => {
-    let addressesWithTopics = logSelections->Array.flatMap(({addresses, topicSelections}) =>
-      topicSelections->Array.map(({topic0, topic1, topic2, topic3}) => {
-        let topics = HyperSyncClient.QueryTypes.makeTopicSelection(
-          ~topic0,
-          ~topic1,
-          ~topic2,
-          ~topic3,
-        )
-        HyperSyncClient.QueryTypes.makeLogSelection(~address=addresses, ~topics)
-      })
-    )
-
-    let query = makeRequestBody(
-      ~fromBlock,
-      ~toBlockInclusive=toBlock,
-      ~addressesWithTopics,
-      ~fieldSelection,
-      ~maxNumLogs,
-    )
+    let query: HyperSyncClient.EventItems.query = {
+      fromBlock,
+      toBlock,
+      maxNumLogs,
+      registrationIndexes,
+      addressesByContractName,
+    }
 
     let (res, transactionStore, blockStore) = switch await client.getEventItems(~query) {
     | res => res

package/src/sources/HyperSync.res.mjs

@@ -12,7 +12,6 @@ import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function reraisIfRateLimited(exn) {
@@ -62,16 +61,6 @@ function mapExn(queryResponse) {
 
 let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
 
-function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, fieldSelection, maxNumLogs) {
-  return {
-    fromBlock: fromBlock,
-    toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
-    logs: addressesWithTopics,
-    fieldSelection: fieldSelection,
-    maxNumLogs: maxNumLogs
-  };
-}
-
 function extractMissingParams(exn) {
   let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
   if (message === undefined) {
@@ -93,15 +82,14 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection, maxNumLogs) {
-  let addressesWithTopics = logSelections.flatMap(param => {
-    let addresses = param.addresses;
-    return param.topicSelections.map(param => {
-      let topics = HyperSyncClient.QueryTypes.makeTopicSelection(param.topic0, param.topic1, param.topic2, param.topic3);
-      return HyperSyncClient.QueryTypes.makeLogSelection(addresses, topics);
-    });
-  });
-  let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection, maxNumLogs);
+async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName) {
+  let query$1 = {
+    fromBlock: fromBlock,
+    toBlock: toBlock,
+    maxNumLogs: maxNumLogs,
+    registrationIndexes: registrationIndexes,
+    addressesByContractName: addressesByContractName
+  };
   let match;
   try {
     match = await client.getEventItems(query$1);
@@ -140,7 +128,13 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
   };
 }
 
-function makeRequestBody$1(fromBlock, toBlock) {
+let GetLogs = {
+  $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
+  query: query
+};
+
+function makeRequestBody(fromBlock, toBlock) {
   return {
     fromBlock: fromBlock,
     toBlock: toBlock + 1 | 0,
@@ -193,7 +187,7 @@ function convertResponse(res) {
 }
 
 async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats) {
-  let body = makeRequestBody$1(fromBlock, toBlock);
+  let body = makeRequestBody(fromBlock, toBlock);
   let logger$1 = Logging.createChildFrom(logger, {
     logType: "HyperSync get block hash query",
     fromBlock: fromBlock,
@@ -282,12 +276,6 @@ function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
   ]);
 }
 
-let GetLogs = {
-  $$Error: $$Error,
-  extractMissingParams: extractMissingParams,
-  query: query
-};
-
 export {
   queryErrorToMsq,
   GetLogs,

package/src/sources/HyperSync.resi

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

package/src/sources/HyperSyncClient.res

@@ -229,29 +229,106 @@ type queryResponse = {
   rollbackGuard: option<ResponseTypes.rollbackGuard>,
 }
 
-module Decoder = {
-  type eventParamsInput = {
+module Registration = {
+  // One topic position of the resolved `where`: static topic values, or
+  // `None` — the "currently registered addresses of this contract" marker,
+  // expanded to padded address topics when Rust builds a query.
+  type topicFilterInput = option<array<string>>
+
+  type topicSelectionInput = {
+    topic0: array<string>,
+    topic1: topicFilterInput,
+    topic2: topicFilterInput,
+    topic3: topicFilterInput,
+  }
+
+  // The full per-(event, chain) registration passed to the Rust clients at
+  // construction: decode metadata, routing identity, and the fetch state
+  // queries are built from.
+  type input = {
+    // Chain-scoped sequential registration index, echoed back on routed items.
+    index: int,
     sighash: string,
     topicCount: int,
     eventName: string,
     contractName: string,
+    isWildcard: bool,
+    dependsOnAddresses: bool,
     params: array<Internal.paramMeta>,
+    topicSelections: array<topicSelectionInput>,
+    // Capitalized field names matching the Rust BlockField/TransactionField
+    // string enums.
+    blockFields: array<string>,
+    transactionFields: array<string>,
+  }
+
+  let toTopicFilterInput = (filter: Internal.topicFilter): topicFilterInput =>
+    switch filter {
+    | Values(values) => Some(values->EvmTypes.Hex.toStrings)
+    | ContractAddresses(_) => None
+    }
+
+  let fromOnEventRegistrations = (
+      onEventRegistrations: array<Internal.evmOnEventRegistration>,
+    ): array<input> => {
+    onEventRegistrations->Array.map(reg => {
+      let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+      {
+        index: reg.index,
+        sighash: event.sighash,
+        topicCount: event.topicCount,
+        eventName: event.name,
+        contractName: event.contractName,
+        isWildcard: reg.isWildcard,
+        dependsOnAddresses: reg.dependsOnAddresses,
+        params: event.paramsMetadata,
+        topicSelections: reg.resolvedWhere.topicSelections->Array.map((
+          ts
+        ): topicSelectionInput => {
+          topic0: ts.topic0->EvmTypes.Hex.toStrings,
+          topic1: ts.topic1->toTopicFilterInput,
+          topic2: ts.topic2->toTopicFilterInput,
+          topic3: ts.topic3->toTopicFilterInput,
+        }),
+        // Capitalized to match the Rust BlockField/TransactionField string
+        // enums.
+        blockFields: event.selectedBlockFields
+        ->Utils.Set.toArray
+        ->Array.map(name => (name :> string)->Utils.String.capitalize),
+        transactionFields: event.selectedTransactionFields
+        ->Utils.Set.toArray
+        ->Array.map(name => (name :> string)->Utils.String.capitalize),
+      }
+    })
   }
 }
 
 module EventItems = {
+  // The whole per-query input: block range, the partition's registration
+  // selection (by id), and its current addresses. Log selections, field
+  // selection, and the routing index are derived on the Rust side.
+  type query = {
+    fromBlock: int,
+    // Inclusive; None queries to the end of available data.
+    toBlock: option<int>,
+    maxNumLogs: int,
+    registrationIndexes: array<int>,
+    addressesByContractName: dict<array<Address.t>>,
+  }
+
   type item = {
     logIndex: int,
     srcAddress: Address.t,
-    topic0: EvmTypes.Hex.t,
-    topicCount: int,
     // Number of the block this log belongs to; the block itself is resolved from
     // `response.blocks`, deduplicated across items sharing a block.
     blockNumber: int,
     // Key (with the block number) into the transaction store; the transaction
     // is resolved from the store on demand.
     transactionIndex: int,
-    params: Nullable.t<dict<Internal.eventParams>>,
+    // The registration this log routed to, by chain-scoped index. Logs that
+    // route to no registration never cross the boundary.
+    onEventRegistrationIndex: int,
+    params: Internal.eventParams,
   }
 
   // The always-needed block fields, one per block number. The block's remaining
@@ -277,7 +354,7 @@ type t = {
   // Returns the response plus page stores owning this page's raw transactions
   // and blocks.
   getEventItems: (
-    ~query: query,
+    ~query: EventItems.query,
   ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
   getHeight: unit => promise<int>,
 }
@@ -287,11 +364,11 @@ external classNew: (
   Core.evmHypersyncClientCtor,
   cfg,
   string,
-  array<Decoder.eventParamsInput>,
+  array<Registration.input>,
 ) => t = "new"
 
-let makeWithAgent = (cfg, ~userAgent, ~eventParams) =>
-  Core.getAddon().evmHypersyncClient->classNew(cfg, userAgent, eventParams)
+let makeWithAgent = (cfg, ~userAgent, ~eventRegistrations) =>
+  Core.getAddon().evmHypersyncClient->classNew(cfg, userAgent, eventRegistrations)
 
 type logLevel = [#trace | #debug | #info | #warn | #error]
 let logLevelSchema: S.t<logLevel> = S.enum([#trace, #debug, #info, #warn, #error])
@@ -309,7 +386,7 @@ let make = (
   ~url,
   ~apiToken,
   ~httpReqTimeoutMillis,
-  ~eventParams,
+  ~eventRegistrations,
   ~enableChecksumAddresses=true,
   ~serializationFormat=?,
   ~enableQueryCaching=?,
@@ -335,6 +412,6 @@ let make = (
       logLevel: logLevelToString(logLevel),
     },
     ~userAgent=`hyperindex/${envioVersion}`,
-    ~eventParams,
+    ~eventRegistrations,
   )
 }

package/src/sources/HyperSyncClient.res.mjs

@@ -36,12 +36,45 @@ let QueryTypes = {
 
 let ResponseTypes = {};
 
-let Decoder = {};
+function toTopicFilterInput(filter) {
+  if (filter.TAG === "Values") {
+    return filter._0;
+  }
+}
+
+function fromOnEventRegistrations(onEventRegistrations) {
+  return onEventRegistrations.map(reg => {
+    let event = reg.eventConfig;
+    return {
+      index: reg.index,
+      sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      isWildcard: reg.isWildcard,
+      dependsOnAddresses: reg.dependsOnAddresses,
+      params: event.paramsMetadata,
+      topicSelections: reg.resolvedWhere.topicSelections.map(ts => ({
+        topic0: ts.topic0,
+        topic1: toTopicFilterInput(ts.topic1),
+        topic2: toTopicFilterInput(ts.topic2),
+        topic3: toTopicFilterInput(ts.topic3)
+      })),
+      blockFields: Array.from(event.selectedBlockFields).map(name => Utils.$$String.capitalize(name)),
+      transactionFields: Array.from(event.selectedTransactionFields).map(name => Utils.$$String.capitalize(name))
+    };
+  });
+}
+
+let Registration = {
+  toTopicFilterInput: toTopicFilterInput,
+  fromOnEventRegistrations: fromOnEventRegistrations
+};
 
 let EventItems = {};
 
-function makeWithAgent(cfg, userAgent, eventParams) {
-  return Core.getAddon().EvmHypersyncClient.new(cfg, userAgent, eventParams);
+function makeWithAgent(cfg, userAgent, eventRegistrations) {
+  return Core.getAddon().EvmHypersyncClient.new(cfg, userAgent, eventRegistrations);
 }
 
 let logLevelSchema = S$RescriptSchema.$$enum([
@@ -66,7 +99,7 @@ function logLevelToString(level) {
   }
 }
 
-function make(url, apiToken, httpReqTimeoutMillis, eventParams, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs, logLevelOpt) {
+function make(url, apiToken, httpReqTimeoutMillis, eventRegistrations, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs, logLevelOpt) {
   let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
   let logLevel = logLevelOpt !== undefined ? logLevelOpt : "info";
   let envioVersion = Utils.EnvioPackage.value.version;
@@ -82,14 +115,14 @@ function make(url, apiToken, httpReqTimeoutMillis, eventParams, enableChecksumAd
     serializationFormat: serializationFormat,
     enableQueryCaching: enableQueryCaching,
     logLevel: logLevelToString(logLevel)
-  }, `hyperindex/` + envioVersion, eventParams);
+  }, `hyperindex/` + envioVersion, eventRegistrations);
 }
 
 export {
   serializationFormatSchema,
   QueryTypes,
   ResponseTypes,
-  Decoder,
+  Registration,
   EventItems,
   makeWithAgent,
   logLevelSchema,