envio 3.0.0-alpha.1 → 3.0.0-alpha.3

package/src/sources/Solana.res

@@ -0,0 +1,59 @@
+@get external getNumber: Internal.eventBlock => int = "height"
+@get external getTimestamp: Internal.eventBlock => int = "time"
+@get external getId: Internal.eventBlock => string = "hash"
+
+let cleanUpRawEventFieldsInPlace: Js.Json.t => unit = %raw(`fields => {
+    delete fields.hash
+    delete fields.height
+    delete fields.time
+  }`)
+
+let ecosystem: Ecosystem.t = {
+  name: Solana,
+  blockFields: ["slot"],
+  transactionFields: [],
+  blockNumberName: "height",
+  blockTimestampName: "time",
+  blockHashName: "hash",
+  getNumber,
+  getTimestamp,
+  getId,
+  cleanUpRawEventFieldsInPlace,
+}
+
+module GetFinalizedSlot = {
+  let route = Rpc.makeRpcRoute(
+    "getSlot",
+    S.tuple(s => {
+      s.tag(0, {"commitment": "finalized"})
+      ()
+    }),
+    S.int,
+  )
+}
+
+let makeRPCSource = (~chain, ~rpc: string): Source.t => {
+  let client = Rest.client(rpc)
+
+  {
+    name: "Solana",
+    sourceFor: Sync,
+    chain,
+    poweredByHyperSync: false,
+    pollingInterval: 10_000,
+    getBlockHashes: (~blockNumbers as _, ~logger as _) =>
+      Js.Exn.raiseError("Solana does not support getting block hashes"),
+    getHeightOrThrow: () => GetFinalizedSlot.route->Rest.fetch((), ~client),
+    getItemsOrThrow: (
+      ~fromBlock as _,
+      ~toBlock as _,
+      ~addressesByContractName as _,
+      ~indexingContracts as _,
+      ~knownHeight as _,
+      ~partitionId as _,
+      ~selection as _,
+      ~retry as _,
+      ~logger as _,
+    ) => Js.Exn.raiseError("Solana does not support getting items"),
+  }
+}

package/src/sources/Solana.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Rpc from "./Rpc.res.mjs";
+import * as Rest from "../vendored/Rest.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var cleanUpRawEventFieldsInPlace = (fields => {
+    delete fields.hash
+    delete fields.height
+    delete fields.time
+  });
+
+var ecosystem_blockFields = ["slot"];
+
+var ecosystem_transactionFields = [];
+
+function ecosystem_getNumber(prim) {
+  return prim.height;
+}
+
+function ecosystem_getTimestamp(prim) {
+  return prim.time;
+}
+
+function ecosystem_getId(prim) {
+  return prim.hash;
+}
+
+var ecosystem = {
+  name: "solana",
+  blockFields: ecosystem_blockFields,
+  transactionFields: ecosystem_transactionFields,
+  blockNumberName: "height",
+  blockTimestampName: "time",
+  blockHashName: "hash",
+  getNumber: ecosystem_getNumber,
+  getTimestamp: ecosystem_getTimestamp,
+  getId: ecosystem_getId,
+  cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace
+};
+
+var route = Rpc.makeRpcRoute("getSlot", S$RescriptSchema.tuple(function (s) {
+          s.tag(0, {
+                commitment: "finalized"
+              });
+        }), S$RescriptSchema.$$int);
+
+var GetFinalizedSlot = {
+  route: route
+};
+
+function makeRPCSource(chain, rpc) {
+  var client = Rest.client(rpc, undefined);
+  return {
+          name: "Solana",
+          sourceFor: "Sync",
+          chain: chain,
+          poweredByHyperSync: false,
+          pollingInterval: 10000,
+          getBlockHashes: (function (param, param$1) {
+              return Js_exn.raiseError("Solana does not support getting block hashes");
+            }),
+          getHeightOrThrow: (function () {
+              return Rest.$$fetch(route, undefined, client);
+            }),
+          getItemsOrThrow: (function (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) {
+              return Js_exn.raiseError("Solana does not support getting items");
+            })
+        };
+}
+
+export {
+  cleanUpRawEventFieldsInPlace ,
+  ecosystem ,
+  GetFinalizedSlot ,
+  makeRPCSource ,
+}
+/* route Not a pure module */

package/src/sources/Source.res

@@ -11,7 +11,7 @@ type blockRangeFetchStats = {
 Thes response returned from a block range fetch
 */
 type blockRangeFetchResponse = {
-  currentBlockHeight: int,
+  knownHeight: int,
   reorgGuard: ReorgDetection.reorgGuard,
   parsedQueueItems: array<Internal.item>,
   fromBlockQueried: int,
@@ -50,7 +50,7 @@ type t = {
     ~toBlock: option<int>,
     ~addressesByContractName: dict<array<Address.t>>,
     ~indexingContracts: dict<Internal.indexingContract>,
-    ~currentBlockHeight: int,
+    ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,
     ~retry: int,

package/src/sources/SourceManager.res

@@ -92,7 +92,6 @@ let trackNewStatus = (sourceManager: t, ~newStatus) => {
 let fetchNext = async (
   sourceManager: t,
   ~fetchState: FetchState.t,
-  ~currentBlockHeight,
   ~executeQuery,
   ~waitForNewBlock,
   ~onNewBlock,
@@ -100,13 +99,14 @@ let fetchNext = async (
 ) => {
   let {maxPartitionConcurrency} = sourceManager
 
-  switch fetchState->FetchState.getNextQuery(
+  let nextQuery = fetchState->FetchState.getNextQuery(
     ~concurrencyLimit={
       maxPartitionConcurrency - sourceManager.fetchingPartitionsCount
     },
-    ~currentBlockHeight,
     ~stateId,
-  ) {
+  )
+
+  switch nextQuery {
   | ReachedMaxConcurrency
   | NothingToQuery => ()
   | WaitingForNewBlock =>
@@ -116,12 +116,12 @@ let fetchNext = async (
     | None =>
       sourceManager->trackNewStatus(~newStatus=WaitingForNewBlock)
       sourceManager.waitingForNewBlockStateId = Some(stateId)
-      let currentBlockHeight = await waitForNewBlock(~currentBlockHeight)
+      let knownHeight = await waitForNewBlock(~knownHeight=fetchState.knownHeight)
       switch sourceManager.waitingForNewBlockStateId {
       | Some(waitingStateId) if waitingStateId === stateId => {
           sourceManager->trackNewStatus(~newStatus=Idle)
           sourceManager.waitingForNewBlockStateId = None
-          onNewBlock(~currentBlockHeight)
+          onNewBlock(~knownHeight)
         }
       | Some(_) // Don't reset it if we are waiting for another state
       | None => ()
@@ -162,14 +162,14 @@ type status = Active | Stalled | Done
 let getSourceNewHeight = async (
   sourceManager,
   ~source: Source.t,
-  ~currentBlockHeight,
+  ~knownHeight,
   ~status: ref<status>,
   ~logger,
 ) => {
   let newHeight = ref(0)
   let retry = ref(0)
 
-  while newHeight.contents <= currentBlockHeight && status.contents !== Done {
+  while newHeight.contents <= knownHeight && status.contents !== Done {
     try {
       // Use to detect if the source is taking too long to respond
       let endTimer = Prometheus.SourceGetHeightDuration.startTimer({
@@ -180,7 +180,7 @@ let getSourceNewHeight = async (
       endTimer()
 
       newHeight := height
-      if height <= currentBlockHeight {
+      if height <= knownHeight {
         retry := 0
         // Slowdown polling when the chain isn't progressing
         let pollingInterval = if status.contents === Stalled {
@@ -211,35 +211,35 @@ let getSourceNewHeight = async (
 }
 
 // Polls for a block height greater than the given block number to ensure a new block is available for indexing.
-let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
+let waitForNewBlock = async (sourceManager: t, ~knownHeight) => {
   let {sources} = sourceManager
 
   let logger = Logging.createChild(
     ~params={
       "chainId": sourceManager.activeSource.chain->ChainMap.Chain.toChainId,
-      "currentBlockHeight": currentBlockHeight,
+      "knownHeight": knownHeight,
     },
   )
   logger->Logging.childTrace("Initiating check for new blocks.")
 
   // Only include Live sources if we've actually synced some blocks
-  // (currentBlockHeight > 0 means we've fetched at least one batch)
+  // (knownHeight > 0 means we've fetched at least one batch)
   // This prevents Live RPC from winning the initial height race and
   // becoming activeSource, which would bypass HyperSync's smart block detection
-  let isInitialHeightFetch = currentBlockHeight === 0
+  let isInitialHeightFetch = knownHeight === 0
 
   let syncSources = []
   let fallbackSources = []
   sources->Utils.Set.forEach(source => {
     if (
       source.sourceFor === Sync ||
-        // Include Live sources only after initial sync has started
-        // Live sources are optimized for real-time indexing with lower latency
-        (source.sourceFor === Live && !isInitialHeightFetch) ||
-        // Even if the active source is a fallback, still include
-        // it to the list. So we don't wait for a timeout again
-        // if all main sync sources are still not valid
-        source === sourceManager.activeSource
+      // Include Live sources only after initial sync has started
+      // Live sources are optimized for real-time indexing with lower latency
+      source.sourceFor === Live && !isInitialHeightFetch ||
+      // Even if the active source is a fallback, still include
+      // it to the list. So we don't wait for a timeout again
+      // if all main sync sources are still not valid
+      source === sourceManager.activeSource
     ) {
       syncSources->Array.push(source)
     } else {
@@ -252,10 +252,7 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
   let (source, newBlockHeight) = await Promise.race(
     syncSources
     ->Array.map(async source => {
-      (
-        source,
-        await sourceManager->getSourceNewHeight(~source, ~currentBlockHeight, ~status, ~logger),
-      )
+      (source, await sourceManager->getSourceNewHeight(~source, ~knownHeight, ~status, ~logger))
     })
     ->Array.concat([
       Utils.delay(sourceManager.newBlockFallbackStallTimeout)->Promise.then(() => {
@@ -281,12 +278,7 @@ let waitForNewBlock = async (sourceManager: t, ~currentBlockHeight) => {
           fallbackSources->Array.map(async source => {
             (
               source,
-              await sourceManager->getSourceNewHeight(
-                ~source,
-                ~currentBlockHeight,
-                ~status,
-                ~logger,
-              ),
+              await sourceManager->getSourceNewHeight(~source, ~knownHeight, ~status, ~logger),
             )
           }),
         )
@@ -349,7 +341,7 @@ let getNextSyncSource = (
   }
 }
 
-let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBlockHeight) => {
+let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~knownHeight) => {
   let toBlockRef = ref(
     switch query.target {
     | Head => None
@@ -389,7 +381,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~currentBl
         ~addressesByContractName=query.addressesByContractName,
         ~indexingContracts=query.indexingContracts,
         ~partitionId=query.partitionId,
-        ~currentBlockHeight,
+        ~knownHeight,
         ~selection=query.selection,
         ~retry,
         ~logger,

package/src/sources/SourceManager.res.mjs

@@ -68,10 +68,10 @@ function trackNewStatus(sourceManager, newStatus) {
   sourceManager.status = newStatus;
 }
 
-async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQuery, waitForNewBlock, onNewBlock, stateId) {
-  var queries = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, currentBlockHeight, stateId);
-  if (typeof queries !== "object") {
-    switch (queries) {
+async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, stateId) {
+  var nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, stateId);
+  if (typeof nextQuery !== "object") {
+    switch (nextQuery) {
       case "WaitingForNewBlock" :
           var waitingStateId = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId !== undefined && waitingStateId >= stateId) {
@@ -79,12 +79,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
           }
           trackNewStatus(sourceManager, "WaitingForNewBlock");
           sourceManager.waitingForNewBlockStateId = stateId;
-          var currentBlockHeight$1 = await waitForNewBlock(currentBlockHeight);
+          var knownHeight = await waitForNewBlock(fetchState.knownHeight);
           var waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
             trackNewStatus(sourceManager, "Idle");
             sourceManager.waitingForNewBlockStateId = undefined;
-            return onNewBlock(currentBlockHeight$1);
+            return onNewBlock(knownHeight);
           } else {
             return ;
           }
@@ -94,12 +94,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
       
     }
   } else {
-    var queries$1 = queries._0;
-    FetchState.startFetchingQueries(fetchState, queries$1, stateId);
-    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries$1.length | 0;
+    var queries = nextQuery._0;
+    FetchState.startFetchingQueries(fetchState, queries, stateId);
+    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries.length | 0;
     Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
     trackNewStatus(sourceManager, "Querieng");
-    await Promise.all(Belt_Array.map(queries$1, (function (q) {
+    await Promise.all(Belt_Array.map(queries, (function (q) {
                 var promise = executeQuery(q);
                 promise.then(function (param) {
                       sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount - 1 | 0;
@@ -115,10 +115,10 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
   }
 }
 
-async function getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger) {
+async function getSourceNewHeight(sourceManager, source, knownHeight, status, logger) {
   var newHeight = 0;
   var retry = 0;
-  while(newHeight <= currentBlockHeight && status.contents !== "Done") {
+  while(newHeight <= knownHeight && status.contents !== "Done") {
     try {
       var endTimer = Prometheus.SourceGetHeightDuration.startTimer({
             source: source.name,
@@ -127,7 +127,7 @@ async function getSourceNewHeight(sourceManager, source, currentBlockHeight, sta
       var height = await source.getHeightOrThrow();
       endTimer();
       newHeight = height;
-      if (height <= currentBlockHeight) {
+      if (height <= knownHeight) {
         retry = 0;
         var pollingInterval = status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval;
         await Utils.delay(pollingInterval);
@@ -150,13 +150,13 @@ async function getSourceNewHeight(sourceManager, source, currentBlockHeight, sta
   return newHeight;
 }
 
-async function waitForNewBlock(sourceManager, currentBlockHeight) {
+async function waitForNewBlock(sourceManager, knownHeight) {
   var logger = Logging.createChild({
         chainId: sourceManager.activeSource.chain,
-        currentBlockHeight: currentBlockHeight
+        knownHeight: knownHeight
       });
   Logging.childTrace(logger, "Initiating check for new blocks.");
-  var isInitialHeightFetch = currentBlockHeight === 0;
+  var isInitialHeightFetch = knownHeight === 0;
   var syncSources = [];
   var fallbackSources = [];
   sourceManager.sources.forEach(function (source) {
@@ -172,7 +172,7 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
   var match = await Promise.race(Belt_Array.concat(Belt_Array.map(syncSources, (async function (source) {
                   return [
                           source,
-                          await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                          await getSourceNewHeight(sourceManager, source, knownHeight, status, logger)
                         ];
                 })), [Utils.delay(sourceManager.newBlockFallbackStallTimeout).then(function () {
                   if (status.contents !== "Done") {
@@ -186,7 +186,7 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
                   return Promise.race(Belt_Array.map(fallbackSources, (async function (source) {
                                     return [
                                             source,
-                                            await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                                            await getSourceNewHeight(sourceManager, source, knownHeight, status, logger)
                                           ];
                                   })));
                 })]));
@@ -247,7 +247,7 @@ function getNextSyncSource(sourceManager, initialSource, currentSource, attemptF
   }
 }
 
-async function executeQuery(sourceManager, query, currentBlockHeight) {
+async function executeQuery(sourceManager, query, knownHeight) {
   var match = query.target;
   var toBlockRef;
   toBlockRef = typeof match !== "object" ? undefined : (
@@ -273,7 +273,7 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
           retry: retry
         });
     try {
-      var response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingContracts, currentBlockHeight, query.partitionId, query.selection, retry, logger);
+      var response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingContracts, knownHeight, query.partitionId, query.selection, retry, logger);
       Logging.childTrace(logger, {
             msg: "Fetched block range from server",
             toBlock: response.latestFetchedBlockNumber,

package/src/sources/SourceManager.resi

@@ -13,19 +13,18 @@ let getActiveSource: t => Source.t
 let fetchNext: (
   t,
   ~fetchState: FetchState.t,
-  ~currentBlockHeight: int,
   ~executeQuery: FetchState.query => promise<unit>,
-  ~waitForNewBlock: (~currentBlockHeight: int) => promise<int>,
-  ~onNewBlock: (~currentBlockHeight: int) => unit,
+  ~waitForNewBlock: (~knownHeight: int) => promise<int>,
+  ~onNewBlock: (~knownHeight: int) => unit,
   ~stateId: int,
 ) => promise<unit>
 
-let waitForNewBlock: (t, ~currentBlockHeight: int) => promise<int>
+let waitForNewBlock: (t, ~knownHeight: int) => promise<int>
 
 let executeQuery: (
   t,
   ~query: FetchState.query,
-  ~currentBlockHeight: int,
+  ~knownHeight: int,
 ) => promise<Source.blockRangeFetchResponse>
 
 let makeGetHeightRetryInterval: (

package/src/Platform.res

@@ -1,140 +0,0 @@
-type name = | @as("evm") Evm | @as("fuel") Fuel
-
-type t = {
-  name: name,
-  blockFields: array<string>,
-  transactionFields: array<string>,
-  blockNumberName: string,
-  blockTimestampName: string,
-  blockHashName: string,
-  getNumber: Internal.eventBlock => int,
-  getTimestamp: Internal.eventBlock => int,
-  getId: Internal.eventBlock => string,
-  cleanUpRawEventFieldsInPlace: Js.Json.t => unit,
-}
-
-module Evm = {
-  @get external getNumber: Internal.eventBlock => int = "number"
-  @get external getTimestamp: Internal.eventBlock => int = "timestamp"
-  @get external getId: Internal.eventBlock => string = "hash"
-
-  let cleanUpRawEventFieldsInPlace: Js.Json.t => unit = %raw(`fields => {
-    delete fields.hash
-    delete fields.number
-    delete fields.timestamp
-  }`)
-}
-
-let evm: t = {
-  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",
-  getNumber: Evm.getNumber,
-  getTimestamp: Evm.getTimestamp,
-  getId: Evm.getId,
-  cleanUpRawEventFieldsInPlace: Evm.cleanUpRawEventFieldsInPlace,
-}
-
-module Fuel = {
-  @get external getNumber: Internal.eventBlock => int = "height"
-  @get external getTimestamp: Internal.eventBlock => int = "time"
-  @get external getId: Internal.eventBlock => string = "id"
-
-  let cleanUpRawEventFieldsInPlace: Js.Json.t => unit = %raw(`fields => {
-    delete fields.id
-    delete fields.height
-    delete fields.time
-  }`)
-}
-
-let fuel: t = {
-  name: Fuel,
-  blockFields: ["id", "height", "time"],
-  transactionFields: ["id"],
-  blockNumberName: "height",
-  blockTimestampName: "time",
-  blockHashName: "id",
-  getNumber: Fuel.getNumber,
-  getTimestamp: Fuel.getTimestamp,
-  getId: Fuel.getId,
-  cleanUpRawEventFieldsInPlace: Fuel.cleanUpRawEventFieldsInPlace,
-}
-
-let fromName = (name: name): t => {
-  switch name {
-  | Evm => evm
-  | Fuel => fuel
-  }
-}
-
-// Create a block event object for block handlers based on platform
-let makeBlockEvent = (~blockNumber: int, platform: t): Internal.blockEvent => {
-  let blockEvent = Js.Dict.empty()
-  blockEvent->Js.Dict.set(platform.blockNumberName, blockNumber->Utils.magic)
-  blockEvent->Utils.magic
-}