envio 3.3.0-alpha.0 → 3.3.0-alpha.10

package/src/sources/SourceManager.resi

@@ -21,18 +21,27 @@ let make: (
 
 let getActiveSource: t => Source.t
 
+type requestStatSample = {
+  sourceName: string,
+  chainId: int,
+  method: string,
+  count: int,
+  seconds: float,
+}
+
+let getRequestStatSamples: t => array<requestStatSample>
+
 let inFlightCount: t => int
 
 let onReorg: (t, ~rollbackTargetBlock: int) => unit
 
-let fetchNext: (
+let dispatch: (
   t,
   ~fetchState: FetchState.t,
   ~executeQuery: FetchState.query => promise<unit>,
   ~waitForNewBlock: (~knownHeight: int) => promise<int>,
   ~onNewBlock: (~knownHeight: int) => unit,
-  ~concurrencyLimit: int,
-  ~bufferLimit: int,
+  ~action: FetchState.nextQuery,
   ~stateId: int,
 ) => promise<unit>
 

package/src/sources/Svm.res

@@ -4,10 +4,31 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.time
   }`)
 
+// 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>
+  )
+
+// 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)
+
+// Ordered block field names. The index of each is the field code shared with the
+// Rust store (`SvmBlockField`) — keep this order in sync.
+let blockFields = ["slot", "time", "hash", "height", "parentSlot", "parentHash"]
+
+// `slot`/`time`/`hash` are always included; every other block field is opt-in
+// via `field_selection.block_fields`. All are materialised from the store.
+//
+// One instruction's selected block fields → store selection bitmask. Computed per
+// event at config build and cached on the event config.
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
+
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
-  blockFields: ["slot"],
-  transactionFields: [],
   blockNumberName: "height",
   blockTimestampName: "time",
   blockHashName: "hash",
@@ -20,15 +41,15 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // parse. The schema is a no-op object that always surfaces `None`.
   onEventBlockFilterSchema: S.object(_ => None),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem => {
     let instruction =
       eventItem.payload->(Utils.magic: Internal.eventPayload => Envio.svmInstruction)
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "program": eventItem.eventConfig.contractName,
-        "instruction": eventItem.eventConfig.name,
+        "program": eventItem.onEventRegistration.eventConfig.contractName,
+        "instruction": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "slot": eventItem.blockNumber,
         "programId": instruction.programId,
@@ -71,26 +92,20 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
     getBlockHashes: (~blockNumbers as _, ~logger as _) =>
       JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer()
+      let timerRef = Performance.now()
       let height = await GetFinalizedSlot.route->Rest.fetch((), ~client)
-      let seconds = timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat
-      Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getSlot")
-      Prometheus.SourceRequestCount.addSeconds(
-        ~sourceName=name,
-        ~chainId,
-        ~method="getSlot",
-        ~seconds,
-      )
-      height
+      let seconds = timerRef->Performance.secondsSince
+      {Source.height, requestStats: [{Source.method: "getSlot", seconds}]}
     },
     getItemsOrThrow: (
       ~fromBlock as _,
       ~toBlock as _,
       ~addressesByContractName as _,
-      ~indexingAddresses as _,
+      ~contractNameByAddress as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,
+      ~itemsTarget as _,
       ~retry as _,
       ~logger as _,
     ) => JsError.throwWithMessage("Svm does not support getting items"),

package/src/sources/Svm.res.mjs

@@ -3,11 +3,13 @@
 import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Prometheus from "../Prometheus.res.mjs";
+import * as Internal from "../Internal.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./TransactionStore.res.mjs";
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
@@ -15,11 +17,22 @@ let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.time
   });
 
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allSvmTransactionFields);
+
+let blockFields = [
+  "slot",
+  "time",
+  "hash",
+  "height",
+  "parentSlot",
+  "parentHash"
+];
+
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
+
 function make(logger) {
   return {
     name: "svm",
-    blockFields: ["slot"],
-    transactionFields: [],
     blockNumberName: "height",
     blockTimestampName: "time",
     blockHashName: "hash",
@@ -32,8 +45,8 @@ function make(logger) {
     toEventLogger: eventItem => {
       let instruction = eventItem.payload;
       return Logging.createChildFrom(logger, {
-        program: eventItem.eventConfig.contractName,
-        instruction: eventItem.eventConfig.name,
+        program: eventItem.onEventRegistration.eventConfig.contractName,
+        instruction: eventItem.onEventRegistration.eventConfig.name,
         chainId: eventItem.chain,
         slot: eventItem.blockNumber,
         programId: instruction.programId
@@ -67,21 +80,31 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
     pollingInterval: 10000,
     getBlockHashes: (param, param$1) => Stdlib_JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer();
+      let timerRef = Performance.now();
       let height = await Rest.fetch(route, undefined, client);
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
-      Prometheus.SourceRequestCount.increment(name, chain, "getSlot");
-      Prometheus.SourceRequestCount.addSeconds(name, chain, "getSlot", seconds);
-      return height;
+      let seconds = Performance.secondsSince(timerRef);
+      return {
+        height: height,
+        requestStats: [{
+            method: "getSlot",
+            seconds: seconds
+          }]
+      };
     },
-    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")
+    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")
   };
 }
 
+let transactionFields = Internal.allSvmTransactionFields;
+
 export {
   cleanUpRawEventFieldsInPlace,
+  transactionFields,
+  eventTransactionFieldMask,
+  blockFields,
+  eventBlockFieldMask,
   make,
   GetFinalizedSlot,
   makeRPCSource,
 }
-/* route Not a pure module */
+/* eventTransactionFieldMask Not a pure module */

package/src/sources/SvmHyperSyncClient.res

@@ -138,29 +138,12 @@ module QueryTypes = {
 }
 
 module ResponseTypes = {
+  // Lean per-slot header for reorg detection and each item's slot/time; the
+  // selectable fields live in the block store and are materialised on demand.
   type block = {
     slot: int,
     blockhash: string,
-    parentSlot?: int,
-    parentBlockhash?: string,
     blockTime?: int,
-    blockHeight?: int,
-  }
-
-  type transaction = {
-    slot: int,
-    transactionIndex: int,
-    signatures: array<string>,
-    feePayer?: string,
-    success?: bool,
-    err?: string,
-    fee?: int,
-    computeUnitsConsumed?: int,
-    accountKeys: array<string>,
-    recentBlockhash?: string,
-    version?: string,
-    loadedAddressesWritable: array<string>,
-    loadedAddressesReadonly: array<string>,
   }
 
   /// Borsh-decoded view attached by the Rust client. `argsJson`/`accountsJson`
@@ -204,22 +187,10 @@ module ResponseTypes = {
     message?: string,
   }
 
-  type tokenBalance = {
-    slot: int,
-    transactionIndex?: int,
-    account?: string,
-    mint?: string,
-    owner?: string,
-    preAmount?: string,
-    postAmount?: string,
-  }
-
   type queryResponseData = {
     blocks: array<block>,
-    transactions: array<transaction>,
     instructions: array<instruction>,
     logs: array<log>,
-    tokenBalances: array<tokenBalance>,
   }
 
   type queryResponse = {
@@ -234,7 +205,9 @@ type queryResponse = ResponseTypes.queryResponse
 
 type t = {
   getHeight: unit => promise<int>,
-  get: (~query: query) => promise<queryResponse>,
+  // Returns the response plus pages of raw transactions and blocks (kept in
+  // Rust), keyed by (slot, transactionIndex) / slot, materialised at batch prep.
+  get: (~query: query) => promise<(queryResponse, TransactionStore.t, BlockStore.t)>,
 }
 
 @send