envio 3.0.2 → 3.1.0-rc.0

package/src/sources/HyperFuelSource.res.mjs

@@ -12,7 +12,6 @@ import * as EventRouter from "./EventRouter.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let EventRoutingFailed = /* @__PURE__ */Primitive_exceptions.create("HyperFuelSource.EventRoutingFailed");
@@ -182,7 +181,6 @@ function make(param) {
   let name = "HyperFuel";
   let getSelectionConfig = memoGetSelectionConfig(chain);
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, param, selection, retry, logger) => {
-    let mkLogAndRaise = (extra, extra$1) => ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     let totalTimeRef = Hrtime.makeTimer();
     let selectionConfig = getSelectionConfig(selection);
     let recieptsSelection = selectionConfig.getRecieptsSelection(addressesByContractName);
@@ -238,34 +236,6 @@ function make(param) {
     let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
-    let match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
-    let lastBlockQueriedPromise;
-    let exit = 0;
-    if (match !== undefined) {
-      let block = match.block;
-      if (block.height === heighestBlockQueried) {
-        lastBlockQueriedPromise = Promise.resolve({
-          blockHash: block.id,
-          blockNumber: block.height,
-          blockTimestamp: block.time
-        });
-      } else {
-        exit = 1;
-      }
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      lastBlockQueriedPromise = Stdlib_Promise.$$catch(HyperFuel.queryBlockData(endpointUrl, heighestBlockQueried, logger).then(res => {
-        if (res !== undefined) {
-          return res;
-        } else {
-          return mkLogAndRaise(`Failure, blockData for block ` + heighestBlockQueried.toString() + ` unexpectedly returned None`, {
-            RE_EXN_ID: "Not_found"
-          });
-        }
-      }), exn => mkLogAndRaise(`Failed to query blockData for block ` + heighestBlockQueried.toString(), exn));
-    }
     let parsingTimeRef = Hrtime.makeTimer();
     let parsedQueueItems = pageUnsafe.items.map(item => {
       let block = item.block;
@@ -383,11 +353,21 @@ function make(param) {
       };
     });
     let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
-    let rangeLastBlock = await lastBlockQueriedPromise;
-    let reorgGuard = {
-      rangeLastBlock: rangeLastBlock,
-      prevRangeLastBlock: undefined
-    };
+    let blockHashes = pageUnsafe.items.map(param => {
+      let block = param.block;
+      return {
+        blockHash: block.id,
+        blockNumber: block.height
+      };
+    });
+    let match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
+    let latestFetchedBlockTimestamp;
+    if (match !== undefined) {
+      let block = match.block;
+      latestFetchedBlockTimestamp = block.height === heighestBlockQueried ? block.time : 0;
+    } else {
+      latestFetchedBlockTimestamp = 0;
+    }
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
     let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
@@ -398,11 +378,11 @@ function make(param) {
     };
     return {
       knownHeight: knownHeight$1,
-      reorgGuard: reorgGuard,
+      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       fromBlockQueried: fromBlock,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockNumber: heighestBlockQueried,
+      latestFetchedBlockTimestamp: latestFetchedBlockTimestamp,
       stats: stats
     };
   };

package/src/sources/HyperSync.res

@@ -1,30 +1,10 @@
-module Log = {
-  type t = {
-    address: Address.t,
-    data: string,
-    topics: array<EvmTypes.Hex.t>,
-    logIndex: int,
-  }
-
-  let fieldNames = ["address", "data", "topics", "logIndex"]
-}
-
-type hyperSyncPage<'item> = {
-  items: array<'item>,
+type logsQueryPage = {
+  items: array<HyperSyncClient.EventItems.item>,
   nextBlock: int,
   archiveHeight: int,
   rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
-  events: array<HyperSyncClient.ResponseTypes.event>,
 }
 
-type logsQueryPageItem = {
-  log: Log.t,
-  block: HyperSyncClient.ResponseTypes.block,
-  transaction: Internal.eventTransaction,
-}
-
-type logsQueryPage = hyperSyncPage<logsQueryPageItem>
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -74,94 +54,37 @@ module GetLogs = {
     fieldSelection,
   }
 
-  @inline
-  let addMissingParams = (acc, fieldNames, returnedObj, ~prefix) => {
-    if fieldNames->Utils.Array.notEmpty {
-      if !(returnedObj->Obj.magic) {
-        acc->Array.push(prefix)->ignore
-      } else {
-        for idx in 0 to fieldNames->Array.length - 1 {
-          let fieldName = fieldNames->Array.getUnsafe(idx)
-          switch returnedObj
-          ->(Utils.magic: 'a => dict<unknown>)
-          ->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-          | Some(_) => ()
-          | None => acc->Array.push(prefix ++ "." ++ fieldName)->ignore
-          }
+  // 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
+  // on anyhow's Debug format.
+  let extractMissingParams = (exn: exn): option<array<string>> => {
+    let message = switch exn {
+    | JsExn(jsExn) => jsExn->JsExn.message
+    | _ => None
+    }
+    switch message {
+    | None => None
+    | Some(msg) =>
+      switch msg->JSON.parseOrThrow->JSON.Decode.object {
+      | exception _ => None
+      | None => None
+      | Some(obj) =>
+        switch (obj->Dict.get("kind"), obj->Dict.get("fields")) {
+        | (Some(String("MissingFields")), Some(Array(fields))) =>
+          Some(fields->Array.filterMap(JSON.Decode.string))
+        | _ => None
         }
       }
     }
   }
 
-  //Note this function can throw an error
-  let convertEvent = (
-    event: HyperSyncClient.ResponseTypes.event,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
-  ): logsQueryPageItem => {
-    let missingParams = []
-    missingParams->addMissingParams(Log.fieldNames, event.log, ~prefix="log")
-    missingParams->addMissingParams(nonOptionalBlockFieldNames, event.block, ~prefix="block")
-    missingParams->addMissingParams(
-      nonOptionalTransactionFieldNames,
-      event.transaction,
-      ~prefix="transaction",
-    )
-    if missingParams->Array.length > 0 {
-      throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
-    }
-
-    //Topics can be nullable and still need to be filtered
-    let logUnsanitized: Log.t = event.log->(Utils.magic: HyperSyncClient.ResponseTypes.log => Log.t)
-    let topics = event.log.topics->Option.getUnsafe->Array.filterMap(Nullable.toOption)
-    let address = event.log.address->Option.getUnsafe
-    let log = {
-      ...logUnsanitized,
-      topics,
-      address,
-    }
-
-    {
-      log,
-      block: event.block->(
-        Utils.magic: option<
-          HyperSyncClient.ResponseTypes.block,
-        > => HyperSyncClient.ResponseTypes.block
-      ),
-      transaction: event.transaction->(
-        Utils.magic: option<HyperSyncClient.ResponseTypes.transaction> => Internal.eventTransaction
-      ),
-    }
-  }
-
-  let convertResponse = (
-    res: HyperSyncClient.ResponseTypes.eventResponse,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
-  ): logsQueryPage => {
-    let {nextBlock, archiveHeight, rollbackGuard} = res
-    let items =
-      res.data->Array.map(item =>
-        item->convertEvent(~nonOptionalBlockFieldNames, ~nonOptionalTransactionFieldNames)
-      )
-    let page: logsQueryPage = {
-      items,
-      nextBlock,
-      archiveHeight: archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
-      events: res.data,
-      rollbackGuard,
-    }
-    page
-  }
-
   let query = async (
     ~client: HyperSyncClient.t,
     ~fromBlock,
     ~toBlock,
     ~logSelections: array<LogSelection.t>,
     ~fieldSelection,
-    ~nonOptionalBlockFieldNames,
-    ~nonOptionalTransactionFieldNames,
   ): logsQueryPage => {
     let addressesWithTopics = logSelections->Array.flatMap(({addresses, topicSelections}) =>
       topicSelections->Array.map(({topic0, topic1, topic2, topic3}) => {
@@ -182,13 +105,25 @@ module GetLogs = {
       ~fieldSelection,
     )
 
-    let res = await client.getEvents(~query)
+    let res = switch await client.getEventItems(~query) {
+    | res => res
+    | exception exn =>
+      switch extractMissingParams(exn) {
+      | Some(missingParams) => throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
+      | None => throw(exn)
+      }
+    }
     if res.nextBlock <= fromBlock {
       // Might happen when /height response was from another instance of HyperSync
       throw(Error(WrongInstance))
     }
 
-    res->convertResponse(~nonOptionalBlockFieldNames, ~nonOptionalTransactionFieldNames)
+    {
+      items: res.items,
+      nextBlock: res.nextBlock,
+      archiveHeight: res.archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
+      rollbackGuard: res.rollbackGuard,
+    }
   }
 }
 

package/src/sources/HyperSync.res.mjs

@@ -4,21 +4,15 @@ import * as Time from "../Time.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let fieldNames = [
-  "address",
-  "data",
-  "topics",
-  "logIndex"
-];
-
 let HyperSyncQueryError = /* @__PURE__ */Primitive_exceptions.create("HyperSync.HyperSyncQueryError");
 
 function queryErrorToMsq(e) {
@@ -55,7 +49,28 @@ function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, field
   };
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection, nonOptionalBlockFieldNames, nonOptionalTransactionFieldNames) {
+function extractMissingParams(exn) {
+  let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
+  if (message === undefined) {
+    return;
+  }
+  let obj;
+  try {
+    obj = Stdlib_JSON.Decode.object(JSON.parse(message));
+  } catch (exn$1) {
+    return;
+  }
+  if (obj === undefined) {
+    return;
+  }
+  let match = obj["kind"];
+  let match$1 = obj["fields"];
+  if (match === "MissingFields" && Array.isArray(match$1)) {
+    return Stdlib_Array.filterMap(match$1, Stdlib_JSON.Decode.string);
+  }
+}
+
+async function query(client, fromBlock, toBlock, logSelections, fieldSelection) {
   let addressesWithTopics = logSelections.flatMap(param => {
     let addresses = param.addresses;
     return param.topicSelections.map(param => {
@@ -64,65 +79,13 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
     });
   });
   let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection);
-  let res = await client.getEvents(query$1);
-  if (res.nextBlock <= fromBlock) {
-    throw {
-      RE_EXN_ID: $$Error,
-      _1: "WrongInstance",
-      Error: new Error()
-    };
-  }
-  let items = res.data.map(item => {
-    let missingParams = [];
-    let returnedObj = item.log;
-    if (Utils.$$Array.notEmpty(fieldNames)) {
-      if (returnedObj) {
-        for (let idx = 0, idx_finish = fieldNames.length; idx < idx_finish; ++idx) {
-          let fieldName = fieldNames[idx];
-          let match = returnedObj[fieldName];
-          if (match !== undefined) {
-            
-          } else {
-            missingParams.push("log." + fieldName);
-          }
-        }
-      } else {
-        missingParams.push("log");
-      }
-    }
-    let returnedObj$1 = item.block;
-    if (Utils.$$Array.notEmpty(nonOptionalBlockFieldNames)) {
-      if (returnedObj$1) {
-        for (let idx$1 = 0, idx_finish$1 = nonOptionalBlockFieldNames.length; idx$1 < idx_finish$1; ++idx$1) {
-          let fieldName$1 = nonOptionalBlockFieldNames[idx$1];
-          let match$1 = returnedObj$1[fieldName$1];
-          if (match$1 !== undefined) {
-            
-          } else {
-            missingParams.push("block." + fieldName$1);
-          }
-        }
-      } else {
-        missingParams.push("block");
-      }
-    }
-    let returnedObj$2 = item.transaction;
-    if (Utils.$$Array.notEmpty(nonOptionalTransactionFieldNames)) {
-      if (returnedObj$2) {
-        for (let idx$2 = 0, idx_finish$2 = nonOptionalTransactionFieldNames.length; idx$2 < idx_finish$2; ++idx$2) {
-          let fieldName$2 = nonOptionalTransactionFieldNames[idx$2];
-          let match$2 = returnedObj$2[fieldName$2];
-          if (match$2 !== undefined) {
-            
-          } else {
-            missingParams.push("transaction." + fieldName$2);
-          }
-        }
-      } else {
-        missingParams.push("transaction");
-      }
-    }
-    if (missingParams.length !== 0) {
+  let res;
+  try {
+    res = await client.getEventItems(query$1);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let missingParams = extractMissingParams(exn);
+    if (missingParams !== undefined) {
       throw {
         RE_EXN_ID: $$Error,
         _1: {
@@ -132,35 +95,20 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
         Error: new Error()
       };
     }
-    let logUnsanitized = item.log;
-    let topics = Stdlib_Array.filterMap(item.log.topics, prim => {
-      if (prim == null) {
-        return;
-      } else {
-        return Primitive_option.some(prim);
-      }
-    });
-    let address = item.log.address;
-    let log_data = logUnsanitized.data;
-    let log_logIndex = logUnsanitized.logIndex;
-    let log = {
-      address: address,
-      data: log_data,
-      topics: topics,
-      logIndex: log_logIndex
-    };
-    return {
-      log: log,
-      block: item.block,
-      transaction: item.transaction
+    throw exn;
+  }
+  if (res.nextBlock <= fromBlock) {
+    throw {
+      RE_EXN_ID: $$Error,
+      _1: "WrongInstance",
+      Error: new Error()
     };
-  });
+  }
   return {
-    items: items,
+    items: res.items,
     nextBlock: res.nextBlock,
     archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
-    rollbackGuard: res.rollbackGuard,
-    events: res.data
+    rollbackGuard: res.rollbackGuard
   };
 }
 
@@ -289,15 +237,13 @@ function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
   return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger).then(res => Stdlib_Result.map(res, res => res[0]));
 }
 
-let Log = {};
-
 let GetLogs = {
   $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
   query: query
 };
 
 export {
-  Log,
   queryErrorToMsq,
   GetLogs,
   queryBlockData$1 as queryBlockData,

package/src/sources/HyperSync.resi

@@ -1,28 +1,10 @@
-type hyperSyncPage<'item> = {
-  items: array<'item>,
+type logsQueryPage = {
+  items: array<HyperSyncClient.EventItems.item>,
   nextBlock: int,
   archiveHeight: int,
   rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
-  events: array<HyperSyncClient.ResponseTypes.event>,
 }
 
-module Log: {
-  type t = {
-    address: Address.t,
-    data: string,
-    topics: array<EvmTypes.Hex.t>,
-    logIndex: int,
-  }
-}
-
-type logsQueryPageItem = {
-  log: Log.t,
-  block: HyperSyncClient.ResponseTypes.block,
-  transaction: Internal.eventTransaction,
-}
-
-type logsQueryPage = hyperSyncPage<logsQueryPageItem>
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -41,14 +23,14 @@ module GetLogs: {
 
   exception Error(error)
 
+  let extractMissingParams: exn => option<array<string>>
+
   let query: (
     ~client: HyperSyncClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~logSelections: array<LogSelection.t>,
     ~fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
-    ~nonOptionalBlockFieldNames: array<string>,
-    ~nonOptionalTransactionFieldNames: array<string>,
   ) => promise<logsQueryPage>
 }