envio 3.2.1 → 3.3.0-alpha.0

package/src/sources/HyperFuel.res

@@ -1,21 +1,3 @@
-//Manage clients in cache so we don't need to reinstantiate each time
-//Ideally client should be passed in as a param to the functions but
-//we are still sharing the same signature with eth archive query builder
-
-module CachedClients = {
-  let cache: dict<HyperFuelClient.t> = Dict.make()
-
-  let getClient = url => {
-    switch cache->Utils.Dict.dangerouslyGetNonOption(url) {
-    | Some(client) => client
-    | None =>
-      let newClient = HyperFuelClient.make({url: url})
-      cache->Dict.set(url, newClient)
-      newClient
-    }
-  }
-}
-
 type hyperSyncPage<'item> = {
   items: array<'item>,
   nextBlock: int,
@@ -36,29 +18,8 @@ type item = {
   block: block,
 }
 
-type blockNumberAndHash = {
-  blockNumber: int,
-  hash: string,
-}
-
 type logsQueryPage = hyperSyncPage<item>
 
-type missingParams = {
-  queryName: string,
-  missingParams: array<string>,
-}
-type queryError = UnexpectedMissingParams(missingParams)
-
-let queryErrorToMsq = (e: queryError): string => {
-  switch e {
-  | UnexpectedMissingParams({queryName, missingParams}) =>
-    `${queryName} query failed due to unexpected missing params on response:
-      ${missingParams->Array.joinUnsafe(", ")}`
-  }
-}
-
-type queryResponse<'a> = result<'a, queryError>
-
 module GetLogs = {
   type error =
     | UnexpectedMissingParams({missingParams: array<string>})
@@ -66,6 +27,31 @@ module GetLogs = {
 
   exception Error(error)
 
+  // Rust encodes structured failures as a JSON payload in the napi error's
+  // message: `{"kind":"MissingFields","fields":["receipt.txId", ...]}`.
+  // 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
+        }
+      }
+    }
+  }
+
   let makeRequestBody = (
     ~fromBlock,
     ~toBlockInclusive,
@@ -121,9 +107,7 @@ module GetLogs = {
     let {receipts, blocks} = response_data
 
     let blocksDict = Dict.make()
-    blocks
-    ->(Utils.magic: option<'a> => 'a)
-    ->Array.forEach(block => {
+    blocks->Array.forEach(block => {
       blocksDict->Dict.set(block.height->(Utils.magic: int => string), block)
     })
 
@@ -166,93 +150,30 @@ module GetLogs = {
     page
   }
 
-  let query = async (~serverUrl, ~fromBlock, ~toBlock, ~recieptsSelection): logsQueryPage => {
+  let query = async (
+    ~client: HyperFuelClient.t,
+    ~fromBlock,
+    ~toBlock,
+    ~recieptsSelection,
+  ): logsQueryPage => {
     let query: HyperFuelClient.QueryTypes.query = makeRequestBody(
       ~fromBlock,
       ~toBlockInclusive=toBlock,
       ~recieptsSelection,
     )
 
-    let hyperFuelClient = CachedClients.getClient(serverUrl)
-
-    let res = await hyperFuelClient->HyperFuelClient.getSelectedData(query)
+    let res = switch await client->HyperFuelClient.getSelectedData(query) {
+    | res => res
+    | exception exn =>
+      switch exn->extractMissingParams {
+      | 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
+      // Might happen when /height response was from another instance of HyperFuel
       throw(Error(WrongInstance))
     }
     res->convertResponse
   }
 }
-
-module BlockData = {
-  let convertResponse = (res: HyperFuelClient.queryResponseTyped): option<
-    ReorgDetection.blockDataWithTimestamp,
-  > => {
-    res.data.blocks->Option.flatMap(blocks => {
-      blocks
-      ->Array.get(0)
-      ->Option.map(block => {
-        switch block {
-        | {height: blockNumber, time: timestamp, id: blockHash} =>
-          (
-            {
-              blockTimestamp: timestamp,
-              blockNumber,
-              blockHash,
-            }: ReorgDetection.blockDataWithTimestamp
-          )
-        }
-      })
-    })
-  }
-
-  let rec queryBlockData = async (~serverUrl, ~blockNumber, ~logger): option<
-    ReorgDetection.blockDataWithTimestamp,
-  > => {
-    let query: HyperFuelClient.QueryTypes.query = {
-      fromBlock: blockNumber,
-      toBlockExclusive: blockNumber + 1,
-      // FIXME: Theoretically it should work without the outputs filter, but it doesn't for some reason
-      outputs: [%raw(`{}`)],
-      // FIXME: Had to add inputs {} as well, since it failed on block 1211599 during wildcard Call indexing
-      inputs: [%raw(`{}`)],
-      fieldSelection: {
-        block: [Height, Id, Time],
-      },
-      includeAllBlocks: true,
-    }
-
-    let hyperFuelClient = CachedClients.getClient(serverUrl)
-
-    let logger = Logging.createChildFrom(
-      ~logger,
-      ~params={"logType": "hypersync get blockhash query", "blockNumber": blockNumber},
-    )
-
-    let executeQuery = () => hyperFuelClient->HyperFuelClient.getSelectedData(query)
-
-    let res = await executeQuery->Time.retryAsyncWithExponentialBackOff(~logger)
-
-    // If the block is not found, retry the query. This can occur since replicas of hypersync might not hack caught up yet
-    if res.nextBlock <= blockNumber {
-      let logger = Logging.createChild(~params={"url": serverUrl})
-      let delayMilliseconds = 100
-      logger->Logging.childInfo(
-        `Block #${blockNumber->Int.toString} not found in HyperFuel. HyperFuel has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${delayMilliseconds->Int.toString}ms.`,
-      )
-      await Time.resolvePromiseAfterDelay(~delayMilliseconds)
-      await queryBlockData(~serverUrl, ~blockNumber, ~logger)
-    } else {
-      res->convertResponse
-    }
-  }
-}
-
-let queryBlockData = BlockData.queryBlockData
-
-let heightRoute = Rest.route(() => {
-  path: "/height",
-  method: Get,
-  input: _ => (),
-  responses: [s => s.field("height", S.int)],
-})

package/src/sources/HyperFuel.res.mjs

@@ -1,35 +1,35 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Time from "../Time.res.mjs";
-import * as Logging from "../Logging.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 HyperFuelClient from "./HyperFuelClient.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";
 
-let cache = {};
+let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperFuel.GetLogs.Error");
 
-function getClient(url) {
-  let client = cache[url];
-  if (client !== undefined) {
-    return Primitive_option.valFromOption(client);
+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);
   }
-  let newClient = HyperFuelClient.make({
-    url: url
-  });
-  cache[url] = newClient;
-  return newClient;
-}
-
-function queryErrorToMsq(e) {
-  let match = e._0;
-  return match.queryName + ` query failed due to unexpected missing params on response:
-      ` + match.missingParams.join(", ");
 }
 
-let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperFuel.GetLogs.Error");
-
 function makeRequestBody(fromBlock, toBlockInclusive, recieptsSelection) {
   return {
     fromBlock: fromBlock,
@@ -101,10 +101,26 @@ function decodeLogQueryPageItems(response_data) {
   return items;
 }
 
-async function query(serverUrl, fromBlock, toBlock, recieptsSelection) {
+async function query(client, fromBlock, toBlock, recieptsSelection) {
   let query$1 = makeRequestBody(fromBlock, toBlock, recieptsSelection);
-  let hyperFuelClient = getClient(serverUrl);
-  let res = await hyperFuelClient.getSelectedData(query$1);
+  let res;
+  try {
+    res = await client.getSelectedData(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: {
+          TAG: "UnexpectedMissingParams",
+          missingParams: missingParams
+        },
+        Error: new Error()
+      };
+    }
+    throw exn;
+  }
   if (res.nextBlock <= fromBlock) {
     throw {
       RE_EXN_ID: $$Error,
@@ -119,66 +135,12 @@ async function query(serverUrl, fromBlock, toBlock, recieptsSelection) {
   };
 }
 
-async function queryBlockData(serverUrl, blockNumber, logger) {
-  let query_toBlock = blockNumber + 1 | 0;
-  let query_inputs = [{}];
-  let query_outputs = [{}];
-  let query_includeAllBlocks = true;
-  let query_fieldSelection = {
-    block: [
-      "height",
-      "id",
-      "time"
-    ]
-  };
-  let query = {
-    fromBlock: blockNumber,
-    toBlock: query_toBlock,
-    inputs: query_inputs,
-    outputs: query_outputs,
-    includeAllBlocks: query_includeAllBlocks,
-    fieldSelection: query_fieldSelection
-  };
-  let hyperFuelClient = getClient(serverUrl);
-  let logger$1 = Logging.createChildFrom(logger, {
-    logType: "hypersync get blockhash query",
-    blockNumber: blockNumber
-  });
-  let executeQuery = () => hyperFuelClient.getSelectedData(query);
-  let res = await Time.retryAsyncWithExponentialBackOff(undefined, undefined, undefined, undefined, logger$1, executeQuery);
-  if (res.nextBlock > blockNumber) {
-    return Stdlib_Option.flatMap(res.data.blocks, blocks => Stdlib_Option.map(blocks[0], block => ({
-      blockHash: block.id,
-      blockNumber: block.height,
-      blockTimestamp: block.time
-    })));
-  }
-  let logger$2 = Logging.createChild({
-    url: serverUrl
-  });
-  Logging.childInfo(logger$2, `Block #` + blockNumber.toString() + ` not found in HyperFuel. HyperFuel has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + (100).toString() + `ms.`);
-  await Time.resolvePromiseAfterDelay(100);
-  return await queryBlockData(serverUrl, blockNumber, logger$2);
-}
-
-function heightRoute() {
-  return {
-    method: "GET",
-    path: "/height",
-    input: param => {},
-    responses: [s => s.field("height", S$RescriptSchema.int)]
-  };
-}
-
 let GetLogs = {
   $$Error: $$Error,
   query: query
 };
 
 export {
-  queryErrorToMsq,
   GetLogs,
-  queryBlockData,
-  heightRoute,
 }
-/* Time Not a pure module */
+/* Stdlib_JsExn Not a pure module */

package/src/sources/HyperFuel.resi

@@ -18,23 +18,8 @@ type item = {
   block: block,
 }
 
-type blockNumberAndHash = {
-  blockNumber: int,
-  hash: string,
-}
-
 type logsQueryPage = hyperSyncPage<item>
 
-type missingParams = {
-  queryName: string,
-  missingParams: array<string>,
-}
-type queryError = UnexpectedMissingParams(missingParams)
-
-let queryErrorToMsq: queryError => string
-
-type queryResponse<'a> = result<'a, queryError>
-
 module GetLogs: {
   type error =
     | UnexpectedMissingParams({missingParams: array<string>})
@@ -43,17 +28,9 @@ module GetLogs: {
   exception Error(error)
 
   let query: (
-    ~serverUrl: string,
+    ~client: HyperFuelClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~recieptsSelection: array<HyperFuelClient.QueryTypes.receiptSelection>,
   ) => promise<logsQueryPage>
 }
-
-let queryBlockData: (
-  ~serverUrl: string,
-  ~blockNumber: int,
-  ~logger: Pino.t,
-) => promise<option<ReorgDetection.blockDataWithTimestamp>>
-
-let heightRoute: Rest.route<unit, int>