envio 3.3.0-alpha.3 → 3.3.0-alpha.5

package/src/sources/RpcSource.res

@@ -224,7 +224,7 @@ let getSuggestedBlockIntervalFromExn = {
 }
 
 type eventBatchQuery = {
-  logs: array<Rpc.GetLogs.log>,
+  items: array<EvmRpcClient.rpcEventItem>,
   latestFetchedBlockInfo: blockInfo,
 }
 
@@ -234,10 +234,10 @@ let getNextPage = (
   ~fromBlock,
   ~toBlock,
   ~addresses,
-  ~topicQuery,
+  ~topicQuery: Rpc.GetLogs.topicQuery,
   ~loadBlock,
   ~syncConfig as sc: Config.sourceSync,
-  ~client,
+  ~rpcClient: EvmRpcClient.t,
   ~mutSuggestedBlockIntervals,
   ~partitionId,
   ~sourceName,
@@ -253,17 +253,20 @@ let getNextPage = (
 
   let latestFetchedBlockPromise = loadBlock(toBlock)
   Prometheus.SourceRequestCount.increment(~sourceName, ~chainId, ~method="eth_getLogs")
-  let logsPromise = Rpc.getLogs(
-    ~client,
-    ~param={
-      address: ?addresses,
-      topics: topicQuery,
-      fromBlock,
-      toBlock,
-    },
-  )->Promise.then(async logs => {
+  let logsPromise = rpcClient.getLogs({
+    fromBlock,
+    toBlock,
+    ?addresses,
+    topics: topicQuery->Array.map(filter =>
+      switch filter {
+      | Rpc.GetLogs.Null => Nullable.null
+      | Single(topic) => Nullable.make([topic])
+      | Multiple(topics) => Nullable.make(topics)
+      }
+    ),
+  })->Promise.then(async items => {
     {
-      logs,
+      items,
       latestFetchedBlockInfo: await latestFetchedBlockPromise,
     }
   })
@@ -855,6 +858,7 @@ type options = {
   allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
   lowercaseAddresses: bool,
   ws?: string,
+  headers?: dict<string>,
 }
 
 let make = (
@@ -867,6 +871,7 @@ let make = (
     allEventParams,
     lowercaseAddresses,
     ?ws,
+    ?headers,
   }: options,
 ): t => {
   let chainId = chain->ChainMap.Chain.toChainId
@@ -883,8 +888,13 @@ let make = (
 
   let mutSuggestedBlockIntervals = Dict.make()
 
-  let client = Rpc.makeClient(url)
-  let rpcClient = EvmRpcClient.make(~url)
+  let client = Rpc.makeClient(url, ~headers?)
+  let rpcClient = EvmRpcClient.make(
+    ~url,
+    ~allEventParams,
+    ~checksumAddresses=!lowercaseAddresses,
+    ~headers?,
+  )
 
   let makeTransactionLoader = () =>
     LazyLoader.make(
@@ -1000,36 +1010,6 @@ let make = (
     ~lowercaseAddresses,
   )
 
-  let convertLogToHyperSyncEvent = (log: Rpc.GetLogs.log): HyperSyncClient.ResponseTypes.event => {
-    let hyperSyncLog: HyperSyncClient.ResponseTypes.log = {
-      removed: log.removed,
-      index: log.logIndex,
-      transactionIndex: log.transactionIndex,
-      transactionHash: log.transactionHash,
-      blockHash: log.blockHash,
-      blockNumber: log.blockNumber,
-      address: log.address,
-      data: log.data,
-      topics: log.topics->(Utils.magic: array<string> => array<Nullable.t<EvmTypes.Hex.t>>),
-    }
-    {log: hyperSyncLog}
-  }
-
-  let hscDecoder: ref<option<HyperSyncClient.Decoder.tWithParams>> = ref(None)
-  let getHscDecoder = () => {
-    switch hscDecoder.contents {
-    | Some(decoder) => decoder
-    | None => {
-        let decoder = HyperSyncClient.Decoder.fromParams(
-          allEventParams,
-          ~checksumAddresses=!lowercaseAddresses,
-        )
-        hscDecoder := Some(decoder)
-        decoder
-      }
-    }
-  }
-
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
@@ -1073,7 +1053,7 @@ let make = (
     let {getLogSelectionOrThrow} = getSelectionConfig(selection)
     let {addresses, topicQuery} = getLogSelectionOrThrow(~addressesByContractName)
 
-    let {logs, latestFetchedBlockInfo} = await getNextPage(
+    let {items, latestFetchedBlockInfo} = await getNextPage(
       ~fromBlock,
       ~toBlock=suggestedToBlock,
       ~addresses,
@@ -1083,7 +1063,7 @@ let make = (
         ->LazyLoader.get(blockNumber)
         ->Promise.thenResolve(parseBlockInfo),
       ~syncConfig,
-      ~client,
+      ~rpcClient,
       ~mutSuggestedBlockIntervals,
       ~partitionId,
       ~sourceName=name,
@@ -1110,31 +1090,8 @@ let make = (
       )
     }
 
-    // Convert RPC logs to HyperSync events
-    let hyperSyncEvents = logs->Array.map(convertLogToHyperSyncEvent)
-
-    // Decode using HyperSyncClient decoder
-    let parsedEvents = try await getHscDecoder().decodeLogs(hyperSyncEvents) catch {
-    | exn =>
-      throw(
-        Source.GetItemsError(
-          FailedGettingItems({
-            exn,
-            attemptedToBlock: toBlock,
-            retry: ImpossibleForTheQuery({
-              message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
-            }),
-          }),
-        ),
-      )
-    }
-
-    let parsedQueueItems = await logs
-    ->Array.zip(parsedEvents)
-    ->Array.filterMap(((
-      log: Rpc.GetLogs.log,
-      maybeDecodedEvent: Nullable.t<dict<Internal.eventParams>>,
-    )) => {
+    let parsedQueueItems = await items
+    ->Array.filterMap(({log, params: maybeDecodedEvent}: EvmRpcClient.rpcEventItem) => {
       let topic0 = log.topics[0]->Option.getOr("0x0")
       let routedAddress = if lowercaseAddresses {
         log.address->Address.Evm.fromAddressLowercaseOrThrow
@@ -1242,7 +1199,7 @@ let make = (
     | Some(b) => pushBlockInfo(b)
     | None => ()
     }
-    logs->Array.forEach(log =>
+    items->Array.forEach(({log}) =>
       blockHashes
       ->Array.push({ReorgDetection.blockNumber: log.blockNumber, blockHash: log.blockHash})
       ->ignore

package/src/sources/RpcSource.res.mjs

@@ -21,7 +21,6 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -221,20 +220,28 @@ function getSuggestedBlockIntervalFromExn(exn) {
 
 let maxSuggestedBlockIntervalKey = "max";
 
-function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, client, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
+function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, rpcClient, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
   let queryTimoutPromise = Time.resolvePromiseAfterDelay(sc.queryTimeoutMillis).then(() => Promise.reject({
     RE_EXN_ID: QueryTimout,
     _1: `Query took longer than ` + (sc.queryTimeoutMillis / 1000 | 0).toString() + ` seconds`
   }));
   let latestFetchedBlockPromise = loadBlock(toBlock);
   Prometheus.SourceRequestCount.increment(sourceName, chainId, "eth_getLogs");
-  let logsPromise = Rpc.getLogs(client, {
+  let logsPromise = rpcClient.getLogs({
     fromBlock: fromBlock,
     toBlock: toBlock,
-    address: addresses,
-    topics: topicQuery
-  }).then(async logs => ({
-    logs: logs,
+    addresses: addresses,
+    topics: topicQuery.map(filter => {
+      if (filter === null) {
+        return null;
+      } else if (typeof filter === "string") {
+        return [filter];
+      } else {
+        return filter;
+      }
+    })
+  }).then(async items => ({
+    items: items,
     latestFetchedBlockInfo: await latestFetchedBlockPromise
   }));
   return Stdlib_Promise.$$catch(Promise.race([
@@ -918,8 +925,8 @@ function makeThrowingGetEventTransaction(getTransactionJson, getReceiptJson, low
 }
 
 function make(param) {
+  let headers = param.headers;
   let lowercaseAddresses = param.lowercaseAddresses;
-  let allEventParams = param.allEventParams;
   let eventRouter = param.eventRouter;
   let chain = param.chain;
   let url = param.url;
@@ -929,8 +936,8 @@ function make(param) {
   let name = `RPC (` + urlHost + `)`;
   let getSelectionConfig = memoGetSelectionConfig(chain);
   let mutSuggestedBlockIntervals = {};
-  let client = Rpc.makeClient(url);
-  let rpcClient = EvmRpcClient.make(url, undefined);
+  let client = Rpc.makeClient(url, headers);
+  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, undefined, headers, param.allEventParams);
   let makeTransactionLoader = () => LazyLoader.make(transactionHash => {
     Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionByHash");
     return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client);
@@ -998,43 +1005,6 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let convertLogToHyperSyncEvent = log => {
-    let hyperSyncLog_removed = log.removed;
-    let hyperSyncLog_logIndex = log.logIndex;
-    let hyperSyncLog_transactionIndex = log.transactionIndex;
-    let hyperSyncLog_transactionHash = log.transactionHash;
-    let hyperSyncLog_blockHash = log.blockHash;
-    let hyperSyncLog_blockNumber = log.blockNumber;
-    let hyperSyncLog_address = Primitive_option.some(log.address);
-    let hyperSyncLog_data = log.data;
-    let hyperSyncLog_topics = log.topics;
-    let hyperSyncLog = {
-      removed: hyperSyncLog_removed,
-      logIndex: hyperSyncLog_logIndex,
-      transactionIndex: hyperSyncLog_transactionIndex,
-      transactionHash: hyperSyncLog_transactionHash,
-      blockHash: hyperSyncLog_blockHash,
-      blockNumber: hyperSyncLog_blockNumber,
-      address: hyperSyncLog_address,
-      data: hyperSyncLog_data,
-      topics: hyperSyncLog_topics
-    };
-    return {
-      log: hyperSyncLog
-    };
-  };
-  let hscDecoder = {
-    contents: undefined
-  };
-  let getHscDecoder = () => {
-    let decoder = hscDecoder.contents;
-    if (decoder !== undefined) {
-      return decoder;
-    }
-    let decoder$1 = HyperSyncClient.Decoder.fromParams(allEventParams, !lowercaseAddresses);
-    hscDecoder.contents = decoder$1;
-    return decoder$1;
-  };
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, retry, param) => {
     let startFetchingBatchTimeRef = Performance.now();
     let maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
@@ -1044,42 +1014,22 @@ function make(param) {
     let firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(json => parseBlockInfo(json)) : Promise.resolve(undefined);
     let match = getSelectionConfig(selection);
     let match$1 = match.getLogSelectionOrThrow(addressesByContractName);
-    let match$2 = await getNextPage(fromBlock, suggestedToBlock, match$1.addresses, match$1.topicQuery, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, client, mutSuggestedBlockIntervals, partitionId, name, chain);
+    let match$2 = await getNextPage(fromBlock, suggestedToBlock, match$1.addresses, match$1.topicQuery, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, rpcClient, mutSuggestedBlockIntervals, partitionId, name, chain);
     let latestFetchedBlockInfo = match$2.latestFetchedBlockInfo;
-    let logs = match$2.logs;
+    let items = match$2.items;
     let executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
     if (executedBlockInterval >= suggestedBlockInterval && !(maxSuggestedBlockIntervalKey in mutSuggestedBlockIntervals)) {
       mutSuggestedBlockIntervals[partitionId] = Primitive_int.min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
     }
-    let hyperSyncEvents = logs.map(convertLogToHyperSyncEvent);
-    let parsedEvents;
-    try {
-      parsedEvents = await getHscDecoder().decodeLogs(hyperSyncEvents);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: Source.GetItemsError,
-        _1: {
-          TAG: "FailedGettingItems",
-          exn: exn,
-          attemptedToBlock: toBlock$1,
-          retry: {
-            TAG: "ImpossibleForTheQuery",
-            message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
-          }
-        },
-        Error: new Error()
-      };
-    }
-    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(Stdlib_Array.zip(logs, parsedEvents), param => {
-      let log = param[0];
+    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(items, param => {
+      let log = param.log;
       let topic0 = Stdlib_Option.getOr(log.topics[0], "0x0");
       let routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : Address.Evm.fromAddressOrThrow(log.address);
       let eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, contractNameByAddress);
       if (eventConfig === undefined) {
         return;
       }
-      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param[1]), __x => __x[eventConfig.contractName]);
+      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param.params), __x => __x[eventConfig.contractName]);
       if (decoded === undefined) {
         return;
       }
@@ -1165,7 +1115,8 @@ function make(param) {
     if (optFirstBlockParent !== undefined) {
       pushBlockInfo(optFirstBlockParent);
     }
-    logs.forEach(log => {
+    items.forEach(param => {
+      let log = param.log;
       blockHashes.push({
         blockHash: log.blockHash,
         blockNumber: log.blockNumber

package/src/sources/SourceManager.res

@@ -676,7 +676,7 @@ let executeQuery = async (
         ~fromBlock=query.fromBlock,
         ~toBlock,
         ~addressesByContractName=query.addressesByContractName,
-        ~contractNameByAddress=query.contractNameByAddress,
+        ~contractNameByAddress=query.addressesByContractName->FetchState.deriveContractNameByAddress,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,

package/src/sources/SourceManager.res.mjs

@@ -500,7 +500,7 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
       retry: retry
     });
     try {
-      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.contractNameByAddress, knownHeight, query.partitionId, query.selection, retry, logger$2);
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, FetchState.deriveContractNameByAddress(query.addressesByContractName), knownHeight, query.partitionId, query.selection, retry, logger$2);
       sourceState.lastFailedAt = undefined;
       responseRef = response;
     } catch (raw_error) {

package/src/sources/Svm.res

@@ -4,23 +4,17 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.time
   }`)
 
-// Ordered transaction field names. The index of each is the field code shared
-// with the Rust store (`SvmTxField`) — keep this order in sync.
-let transactionFields = [
-  "transactionIndex",
-  "signatures",
-  "feePayer",
-  "success",
-  "err",
-  "fee",
-  "computeUnitsConsumed",
-  "accountKeys",
-  "recentBlockhash",
-  "version",
-  "tokenBalances",
-]
+// Ordered transaction field names, the field codes shared with the Rust store
+// (`SvmTxField`). Derived from the typed field list so the two can't drift;
+// `Internal.allSvmTransactionFields` is pinned to the Rust ordinal order by a test.
+let transactionFields =
+  Internal.allSvmTransactionFields->(
+    Utils.magic: array<Internal.svmTransactionField> => array<string>
+  )
 
-let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
+// One instruction's selected transaction fields → store selection bitmask.
+// Computed per event at config build and cached on the event config.
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
@@ -36,7 +30,6 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // parse. The schema is a no-op object that always surfaces `None`.
   onEventBlockFilterSchema: S.object(_ => None),
   logger,
-  transactionFieldMask,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem => {
     let instruction =

package/src/sources/Svm.res.mjs

@@ -4,6 +4,7 @@ import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logging from "../Logging.res.mjs";
+import * as Internal from "../Internal.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -16,21 +17,7 @@ let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.time
   });
 
-let transactionFields = [
-  "transactionIndex",
-  "signatures",
-  "feePayer",
-  "success",
-  "err",
-  "fee",
-  "computeUnitsConsumed",
-  "accountKeys",
-  "recentBlockhash",
-  "version",
-  "tokenBalances"
-];
-
-let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields);
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allSvmTransactionFields);
 
 function make(logger) {
   return {
@@ -44,7 +31,6 @@ function make(logger) {
     onEventBlockFilterSchema: S$RescriptSchema.object(param => {}),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
-    transactionFieldMask: transactionFieldMask,
     toEventLogger: eventItem => {
       let instruction = eventItem.payload;
       return Logging.createChildFrom(logger, {
@@ -94,12 +80,14 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
   };
 }
 
+let transactionFields = Internal.allSvmTransactionFields;
+
 export {
   cleanUpRawEventFieldsInPlace,
   transactionFields,
-  transactionFieldMask,
+  eventTransactionFieldMask,
   make,
   GetFinalizedSlot,
   makeRPCSource,
 }
-/* transactionFieldMask Not a pure module */
+/* eventTransactionFieldMask Not a pure module */