envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/sources/Evm.res.mjs

@@ -1,8 +1,47 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Logging from "../Logging.res.mjs";
+import * as Internal from "../Internal.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./TransactionStore.res.mjs";
+
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allEvmTransactionFields);
+
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash"
+];
+
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
@@ -13,82 +52,18 @@ let cleanUpRawEventFieldsInPlace = (fields => {
 function make(logger) {
   return {
     name: "evm",
-    blockFields: [
-      "number",
-      "timestamp",
-      "hash",
-      "parentHash",
-      "nonce",
-      "sha3Uncles",
-      "logsBloom",
-      "transactionsRoot",
-      "stateRoot",
-      "receiptsRoot",
-      "miner",
-      "difficulty",
-      "totalDifficulty",
-      "extraData",
-      "size",
-      "gasLimit",
-      "gasUsed",
-      "uncles",
-      "baseFeePerGas",
-      "blobGasUsed",
-      "excessBlobGas",
-      "parentBeaconBlockRoot",
-      "withdrawalsRoot",
-      "l1BlockNumber",
-      "sendCount",
-      "sendRoot",
-      "mixHash"
-    ],
-    transactionFields: [
-      "transactionIndex",
-      "hash",
-      "from",
-      "to",
-      "gas",
-      "gasPrice",
-      "maxPriorityFeePerGas",
-      "maxFeePerGas",
-      "cumulativeGasUsed",
-      "effectiveGasPrice",
-      "gasUsed",
-      "input",
-      "nonce",
-      "value",
-      "v",
-      "r",
-      "s",
-      "contractAddress",
-      "logsBloom",
-      "root",
-      "status",
-      "yParity",
-      "chainId",
-      "maxFeePerBlobGas",
-      "blobVersionedHashes",
-      "type",
-      "l1Fee",
-      "l1GasPrice",
-      "l1GasUsed",
-      "l1FeeScalar",
-      "gasUsedForL1",
-      "accessList",
-      "authorizationList"
-    ],
     blockNumberName: "number",
     blockTimestampName: "timestamp",
     blockHashName: "hash",
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -96,13 +71,22 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let eventConfig = eventItem.onEventRegistration.eventConfig;
+      let block = payload.block;
+      let header = block !== undefined ? Primitive_option.valFromOption(block) : Stdlib_JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event");
+      return RawEvent.make(eventItem, payload.block, payload.transaction, eventConfig.paramsMetadata.length === 0 ? undefined : payload.params, payload.srcAddress, header.hash, header.timestamp, cleanUpRawEventFieldsInPlace);
     }
   };
 }
 
+let transactionFields = Internal.allEvmTransactionFields;
+
 export {
+  transactionFields,
+  eventTransactionFieldMask,
+  blockFields,
+  eventBlockFieldMask,
   cleanUpRawEventFieldsInPlace,
   make,
 }
-/* Logging Not a pure module */
+/* eventTransactionFieldMask Not a pure module */

package/src/sources/EvmChain.res

@@ -3,6 +3,7 @@ type rpc = {
   sourceFor: Source.sourceFor,
   syncConfig?: Config.sourceSyncOptions,
   ws?: string,
+  headers?: dict<string>,
 }
 
 let getSyncConfig = (
@@ -31,54 +32,26 @@ let getSyncConfig = (
     intervalCeiling: Env.Configurable.SyncConfig.intervalCeiling->Option.getOr(
       intervalCeiling->Option.getOr(10_000),
     ),
-    backoffMillis: backoffMillis->Option.getOr(5000),
+    backoffMillis: backoffMillis->Option.getOr(2000),
     queryTimeoutMillis,
     fallbackStallTimeout: fallbackStallTimeout->Option.getOr(queryTimeoutMillis / 2),
     pollingInterval: pollingInterval->Option.getOr(1000),
   }
 }
 
-let collectEventParams = (contracts: array<Internal.evmContractConfig>): array<
-  HyperSyncClient.Decoder.eventParamsInput,
-> => {
-  let result = []
-  contracts->Array.forEach(contract => {
-    contract.events->Array.forEach(event => {
-      result
-      ->Array.push({
-        HyperSyncClient.Decoder.sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata,
-      })
-      ->ignore
-    })
-  })
-  result
-}
-
 let makeSources = (
   ~chain,
-  ~contracts: array<Internal.evmContractConfig>,
+  ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
   ~hyperSync,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
-  let eventRouter =
-    contracts
-    ->Array.flatMap(contract => contract.events)
-    ->EventRouter.fromEvmEventModsOrThrow(~chain)
-
-  let allEventParams = collectEventParams(contracts)
-
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
       HyperSyncSource.make({
         chain,
         endpointUrl,
-        allEventParams,
-        eventRouter,
+        onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses,
@@ -89,16 +62,16 @@ let makeSources = (
     ]
   | _ => []
   }
-  rpcs->Array.forEach(({?syncConfig, url, sourceFor, ?ws}) => {
+  rpcs->Array.forEach(({?syncConfig, url, sourceFor, ?ws, ?headers}) => {
     let source = RpcSource.make({
       chain,
       sourceFor,
       syncConfig: getSyncConfig(syncConfig->Option.getOr({})),
       url,
-      eventRouter,
-      allEventParams,
+      onEventRegistrations,
       lowercaseAddresses,
       ?ws,
+      ?headers,
     })
     let _ = sources->Array.push(source)
   })

package/src/sources/EvmChain.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Env from "../Env.res.mjs";
 import * as RpcSource from "./RpcSource.res.mjs";
-import * as EventRouter from "./EventRouter.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as HyperSyncSource from "./HyperSyncSource.res.mjs";
 
@@ -13,37 +12,18 @@ function getSyncConfig(param) {
     backoffMultiplicative: Stdlib_Option.getOr(Env.Configurable.SyncConfig.backoffMultiplicative, Stdlib_Option.getOr(param.backoffMultiplicative, 0.8)),
     accelerationAdditive: Stdlib_Option.getOr(Env.Configurable.SyncConfig.accelerationAdditive, Stdlib_Option.getOr(param.accelerationAdditive, 500)),
     intervalCeiling: Stdlib_Option.getOr(Env.Configurable.SyncConfig.intervalCeiling, Stdlib_Option.getOr(param.intervalCeiling, 10000)),
-    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 5000),
+    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 2000),
     queryTimeoutMillis: queryTimeoutMillis,
     fallbackStallTimeout: Stdlib_Option.getOr(param.fallbackStallTimeout, queryTimeoutMillis / 2 | 0),
     pollingInterval: Stdlib_Option.getOr(param.pollingInterval, 1000)
   };
 }
 
-function collectEventParams(contracts) {
-  let result = [];
-  contracts.forEach(contract => {
-    contract.events.forEach(event => {
-      result.push({
-        sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata
-      });
-    });
-  });
-  return result;
-}
-
-function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
-  let eventRouter = EventRouter.fromEvmEventModsOrThrow(contracts.flatMap(contract => contract.events), chain);
-  let allEventParams = collectEventParams(contracts);
+function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
   let sources = hyperSync !== undefined ? [HyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,
-        allEventParams: allEventParams,
-        eventRouter: eventRouter,
+        onEventRegistrations: onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses: lowercaseAddresses,
@@ -57,10 +37,10 @@ function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
       syncConfig: getSyncConfig(Stdlib_Option.getOr(param.syncConfig, {})),
       url: param.url,
       chain: chain,
-      eventRouter: eventRouter,
-      allEventParams: allEventParams,
+      onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
-      ws: param.ws
+      ws: param.ws,
+      headers: param.headers
     });
     sources.push(source);
   });
@@ -69,7 +49,6 @@ function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
 
 export {
   getSyncConfig,
-  collectEventParams,
   makeSources,
 }
 /* Env Not a pure module */

package/src/sources/EvmRpcClient.res

@@ -1,9 +1,53 @@
-type cfg = {url: string, httpReqTimeoutMillis?: int}
+type cfg = {
+  url: string,
+  httpReqTimeoutMillis?: int,
+  headers?: dict<string>,
+  initialBlockInterval: int,
+  backoffMultiplicative: float,
+  accelerationAdditive: int,
+  intervalCeiling: int,
+  backoffMillis: int,
+  queryTimeoutMillis: int,
+}
+
+// Only logs that resolved to a registration cross the boundary, each carrying
+// its registration's chain-scoped index.
+type rpcEventItem = {
+  log: Rpc.GetLogs.log,
+  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>,
+}
 
-type t = {getHeight: unit => promise<int>}
+// The caller provides a range; Rust decides the actual `toBlock` and returns it.
+type t = {
+  getHeight: unit => promise<int>,
+  getNextPage: nextPageParams => promise<nextPageResponse>,
+}
 
 @send
-external classNew: (Core.evmRpcClientCtor, cfg) => t = "new"
+external classNew: (
+  Core.evmRpcClientCtor,
+  cfg,
+  array<HyperSyncClient.Registration.input>,
+  ~checksumAddresses: bool,
+) => t = "new"
 
 // Rust encodes JSON-RPC errors as a JSON payload in the napi error's
 // message: `{"kind":"JsonRpcError","code":-32005,"message":"..."}`.
@@ -34,9 +78,31 @@ let coerceErrorOrThrow = exn =>
   | None => exn->throw
   }
 
-let make = (~url, ~httpReqTimeoutMillis=?) => {
-  let client = Core.getAddon().evmRpcClient->classNew({url, ?httpReqTimeoutMillis})
+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),
+    getNextPage: params => client.getNextPage(params)->Promise.catch(coerceErrorOrThrow),
   }
 }

package/src/sources/EvmRpcClient.res.mjs

@@ -46,13 +46,22 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, httpReqTimeoutMillis) {
+function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt) {
+  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
-    httpReqTimeoutMillis: httpReqTimeoutMillis
-  });
+    httpReqTimeoutMillis: httpReqTimeoutMillis,
+    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)
+    getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
+    getNextPage: params => Stdlib_Promise.$$catch(client.getNextPage(params), coerceErrorOrThrow)
   };
 }
 

package/src/sources/FieldMask.res

@@ -0,0 +1,39 @@
+// Selection-bitmask helpers shared by the per-chain field stores
+// (`TransactionStore`, `BlockStore`). A field's bit index is its position in the
+// ecosystem's ordered field-name array — the same code the Rust store uses.
+
+// Field-name → bit-index map from an ordered field-name array.
+let fieldCodes = (fields: array<string>): dict<int> => {
+  let codes = Dict.make()
+  fields->Array.forEachWithIndex((name, i) => codes->Dict.set(name, i))
+  codes
+}
+
+let pow2: int => float = %raw(`c => Math.pow(2, c)`)
+
+// One event's selected fields as a bitmask float (bit `code` set ⇔ selected).
+// Each field appears once, so summing `pow2(code)` sets distinct bits with no
+// overlap; the result stays exact in f64 (codes span 0..31, so a mask is at most
+// 2^32-1).
+let maskFromFields = (selectedFields: Utils.Set.t<string>, ~codes: dict<int>): float => {
+  let mask = ref(0.)
+  selectedFields->Utils.Set.forEach(name =>
+    switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+    | Some(code) => mask := mask.contents +. pow2(code)
+    | None => ()
+    }
+  )
+  mask.contents
+}
+
+// Build an ecosystem's per-event mask function from its ordered field-name
+// array. The field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (Utils.Set.t<string> => float) => {
+  let codes = fieldCodes(fields)
+  selectedFields => selectedFields->maskFromFields(~codes)
+}
+
+// Bitwise OR of two per-event masks. Masks fit in 32 bits (≤32 fields), so
+// `>>> 0` recovers the unsigned value that a plain `|` renders negative once bit
+// 31 is set.
+let orMask: (float, float) => float = %raw(`(a, b) => (a | b) >>> 0`)

package/src/sources/FieldMask.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function fieldCodes(fields) {
+  let codes = {};
+  fields.forEach((name, i) => {
+    codes[name] = i;
+  });
+  return codes;
+}
+
+let pow2 = (c => Math.pow(2, c));
+
+function maskFromFields(selectedFields, codes) {
+  let mask = {
+    contents: 0
+  };
+  selectedFields.forEach(name => {
+    let code = codes[name];
+    if (code !== undefined) {
+      mask.contents = mask.contents + pow2(code);
+      return;
+    }
+  });
+  return mask.contents;
+}
+
+function makeMaskFn(fields) {
+  let codes = fieldCodes(fields);
+  return selectedFields => maskFromFields(selectedFields, codes);
+}
+
+let orMask = ((a, b) => (a | b) >>> 0);
+
+export {
+  fieldCodes,
+  pow2,
+  maskFromFields,
+  makeMaskFn,
+  orMask,
+}
+/* No side effect */

package/src/sources/Fuel.res

@@ -21,8 +21,6 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
 
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Fuel,
-  blockFields: ["id", "height", "time"],
-  transactionFields: ["id"],
   blockNumberName: "height",
   blockTimestampName: "time",
   blockHashName: "id",
@@ -37,17 +35,19 @@ 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->Internal.payloadToEvent,
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem =>
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -56,11 +56,14 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     ),
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
+    let header = payload.block->(Utils.magic: Internal.eventBlock => {"id": string, "time": int})
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
       ~params=payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["id"],
+      ~blockTimestamp=header["time"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },

package/src/sources/Fuel.res.mjs

@@ -13,24 +13,18 @@ let cleanUpRawEventFieldsInPlace = (fields => {
 function make(logger) {
   return {
     name: "fuel",
-    blockFields: [
-      "id",
-      "height",
-      "time"
-    ],
-    transactionFields: ["id"],
     blockNumberName: "height",
     blockTimestampName: "time",
     blockHashName: "id",
     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, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -38,7 +32,8 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let header = payload.block;
+      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, header.id, header.time, cleanUpRawEventFieldsInPlace);
     }
   };
 }