envio 2.17.0 → 2.17.1

package/src/Utils.res

@@ -22,6 +22,11 @@ module Object = {
   external defineProperty: ('obj, string, propertyDescriptor<'a>) => 'obj = "defineProperty"
 }
 
+module Error = {
+  @new
+  external make: string => exn = "Error"
+}
+
 module Option = {
   let mapNone = (opt: option<'a>, val: 'b): option<'b> => {
     switch opt {
@@ -123,6 +128,9 @@ module Math = {
 }
 
 module Array = {
+  @send
+  external forEachAsync: (array<'a>, 'a => promise<unit>) => unit = "forEach"
+
   @val external jsArrayCreate: int => array<'a> = "Array"
 
   /* Given a comaprator and two sorted lists, combine them into a single sorted list */
@@ -452,3 +460,10 @@ module Map = {
   @send external set: (t<'k, 'v>, 'k, 'v) => t<'k, 'v> = "set"
   @send external delete: (t<'k, 'v>, 'k) => bool = "delete"
 }
+
+module Proxy = {
+  type traps<'a> = {get?: (~target: 'a, ~prop: unknown) => unknown}
+
+  @new
+  external make: ('a, traps<'a>) => 'a = "Proxy"
+}

package/src/db/EntityHistory.res

@@ -186,7 +186,7 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let currentHistoryFields =
     currentChangeFieldNames->Belt.Array.map(fieldName =>
-      mkField(fieldName, Integer, ~isPrimaryKey=true)
+      mkField(fieldName, Integer, ~fieldSchema=S.never, ~isPrimaryKey=true)
     )
 
   let previousChangeFieldNames =
@@ -194,7 +194,7 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let previousHistoryFields =
     previousChangeFieldNames->Belt.Array.map(fieldName =>
-      mkField(fieldName, Integer, ~isNullable=true)
+      mkField(fieldName, Integer, ~fieldSchema=S.never, ~isNullable=true)
     )
 
   let id = "id"
@@ -224,9 +224,9 @@ let fromTable = (table: table, ~schema: S.t<'entity>): t<'entity> => {
 
   let actionFieldName = "action"
 
-  let actionField = mkField(actionFieldName, Custom(RowAction.enum.name))
+  let actionField = mkField(actionFieldName, Custom(RowAction.enum.name), ~fieldSchema=S.never)
 
-  let serialField = mkField("serial", Serial, ~isNullable=true, ~isIndex=true)
+  let serialField = mkField("serial", Serial, ~fieldSchema=S.never, ~isNullable=true, ~isIndex=true)
 
   let dataFieldNames = dataFields->Belt.Array.map(field => field->getFieldName)
 

package/src/db/Table.res

@@ -19,6 +19,7 @@ type fieldType =
 type field = {
   fieldName: string,
   fieldType: fieldType,
+  fieldSchema: S.t<unknown>,
   isArray: bool,
   isNullable: bool,
   isPrimaryKey: bool,
@@ -36,18 +37,20 @@ type derivedFromField = {
 type fieldOrDerived = Field(field) | DerivedFrom(derivedFromField)
 
 let mkField = (
+  fieldName,
+  fieldType,
+  ~fieldSchema,
   ~default=?,
   ~isArray=false,
   ~isNullable=false,
   ~isPrimaryKey=false,
   ~isIndex=false,
   ~linkedEntity=?,
-  fieldName,
-  fieldType,
 ) =>
   {
     fieldName,
     fieldType,
+    fieldSchema: fieldSchema->S.toUnknown,
     isArray,
     isNullable,
     isPrimaryKey,

package/src/sources/Fuel.res

@@ -0,0 +1,37 @@
+type receiptType =
+  | @as(0) Call
+  | @as(1) Return
+  | @as(2) ReturnData
+  | @as(3) Panic
+  | @as(4) Revert
+  | @as(5) Log
+  | @as(6) LogData
+  // Transfer is to another contract, TransferOut is to wallet address
+  | @as(7) Transfer
+  | @as(8) TransferOut
+  | @as(9) ScriptResult
+  | @as(10) MessageOut
+  | @as(11) Mint
+  | @as(12) Burn
+
+@module("./vendored-fuel-abi-coder.js")
+external transpileAbi: Js.Json.t => Ethers.abi = "transpileAbi"
+
+@module("./vendored-fuel-abi-coder.js") @scope("AbiCoder")
+external getLogDecoder: (~abi: Ethers.abi, ~logId: string) => string => unknown = "getLogDecoder"
+
+module Receipt = {
+  @tag("receiptType")
+  type t =
+    | @as(0) Call({assetId: string, amount: bigint, to: string})
+    | @as(6) LogData({data: string, rb: bigint})
+    | @as(7) Transfer({amount: bigint, assetId: string, to: string})
+    | @as(8) TransferOut({amount: bigint, assetId: string, toAddress: string})
+    | @as(11) Mint({val: bigint, subId: string})
+    | @as(12) Burn({val: bigint, subId: string})
+
+  let getLogDataDecoder = (~abi: Ethers.abi, ~logId: string) => {
+    let decode = getLogDecoder(~abi, ~logId)
+    data => data->decode->Utils.magic
+  }
+}

package/src/sources/HyperFuel.res

@@ -0,0 +1,260 @@
+open Belt
+
+//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: Js.Dict.t<HyperFuelClient.t> = Js.Dict.empty()
+
+  let getClient = url => {
+    switch cache->Utils.Dict.dangerouslyGetNonOption(url) {
+    | Some(client) => client
+    | None =>
+      let newClient = HyperFuelClient.make({url: url})
+      cache->Js.Dict.set(url, newClient)
+      newClient
+    }
+  }
+}
+
+type hyperSyncPage<'item> = {
+  items: array<'item>,
+  nextBlock: int,
+  archiveHeight: int,
+}
+
+type block = {
+  id: string,
+  time: int,
+  height: int,
+}
+
+type item = {
+  transactionId: string,
+  contractId: Address.t,
+  receipt: Fuel.Receipt.t,
+  receiptIndex: int,
+  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->Js.Array2.joinWith(", ")}`
+  }
+}
+
+type queryResponse<'a> = result<'a, queryError>
+
+module GetLogs = {
+  type error =
+    | UnexpectedMissingParams({missingParams: array<string>})
+    | WrongInstance
+
+  exception Error(error)
+
+  let makeRequestBody = (
+    ~fromBlock,
+    ~toBlockInclusive,
+    ~recieptsSelection,
+  ): HyperFuelClient.QueryTypes.query => {
+    {
+      fromBlock,
+      toBlockExclusive: ?switch toBlockInclusive {
+      | Some(toBlockInclusive) => Some(toBlockInclusive + 1)
+      | None => None
+      },
+      receipts: recieptsSelection,
+      fieldSelection: {
+        receipt: [
+          TxId,
+          BlockHeight,
+          RootContractId,
+          Data,
+          ReceiptIndex,
+          ReceiptType,
+          Rb,
+          // TODO: Include them only when there's a mint/burn/transferOut receipt selection
+          SubId,
+          Val,
+          Amount,
+          ToAddress,
+          AssetId,
+          To,
+        ],
+        block: [Id, Height, Time],
+      },
+    }
+  }
+
+  let getParam = (param, name) => {
+    switch param {
+    | Some(v) => v
+    | None =>
+      raise(
+        Error(
+          UnexpectedMissingParams({
+            missingParams: [name],
+          }),
+        ),
+      )
+    }
+  }
+
+  //Note this function can throw an error
+  let decodeLogQueryPageItems = (response_data: HyperFuelClient.queryResponseDataTyped): array<
+    item,
+  > => {
+    let {receipts, blocks} = response_data
+
+    let blocksDict = Js.Dict.empty()
+    blocks
+    ->(Utils.magic: option<'a> => 'a)
+    ->Array.forEach(block => {
+      blocksDict->Js.Dict.set(block.height->(Utils.magic: int => string), block)
+    })
+
+    let items = []
+
+    receipts->Array.forEach(receipt => {
+      switch receipt.rootContractId {
+      | None => ()
+      | Some(contractId) => {
+          let block =
+            blocksDict
+            ->Utils.Dict.dangerouslyGetNonOption(receipt.blockHeight->(Utils.magic: int => string))
+            ->getParam("Failed to find block associated to receipt")
+          items
+          ->Array.push({
+            transactionId: receipt.txId,
+            block: {
+              height: block.height,
+              id: block.id,
+              time: block.time,
+            },
+            contractId,
+            receipt: receipt->(Utils.magic: HyperFuelClient.FuelTypes.receipt => Fuel.Receipt.t),
+            receiptIndex: receipt.receiptIndex,
+          })
+          ->ignore
+        }
+      }
+    })
+    items
+  }
+
+  let convertResponse = (res: HyperFuelClient.queryResponseTyped): logsQueryPage => {
+    let {nextBlock, ?archiveHeight} = res
+    let page: logsQueryPage = {
+      items: res.data->decodeLogQueryPageItems,
+      nextBlock,
+      archiveHeight: archiveHeight->Option.getWithDefault(0), // TODO: FIXME: Shouldn't have a default here
+    }
+    page
+  }
+
+  let query = async (~serverUrl, ~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)
+    if res.nextBlock <= fromBlock {
+      // Might happen when /height response was from another instance of HyperSync
+      raise(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.resi

@@ -0,0 +1,59 @@
+type hyperSyncPage<'item> = {
+  items: array<'item>,
+  nextBlock: int,
+  archiveHeight: int,
+}
+
+type block = {
+  id: string,
+  time: int,
+  height: int,
+}
+
+type item = {
+  transactionId: string,
+  contractId: Address.t,
+  receipt: Fuel.Receipt.t,
+  receiptIndex: int,
+  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>})
+    | WrongInstance
+
+  exception Error(error)
+
+  let query: (
+    ~serverUrl: string,
+    ~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>