envio 3.3.2 → 3.5.0-alpha.0

package/src/sources/HyperFuelSource.res

@@ -1,502 +0,0 @@
-open Source
-
-exception EventRoutingFailed
-
-let isUnauthorizedError = (message: string) => message->String.includes("401 Unauthorized")
-
-let mintEventTag = "mint"
-let burnEventTag = "burn"
-let transferEventTag = "transfer"
-let callEventTag = "call"
-
-type selectionConfig = {
-  getRecieptsSelection: (
-    ~addressesByContractName: dict<array<Address.t>>,
-  ) => array<HyperFuelClient.QueryTypes.receiptSelection>,
-  eventRouter: EventRouter.t<Internal.fuelOnEventRegistration>,
-}
-
-let logDataReceiptTypeSelection: array<FuelSDK.receiptType> = [LogData]
-
-// only transactions with status 1 (success)
-let txStatusSelection = [1]
-
-let makeGetNormalRecieptsSelection = (
-  ~nonWildcardLogDataRbsByContract,
-  ~nonLogDataReceiptTypesByContract,
-  ~contractNames,
-) => {
-  (~addressesByContractName) => {
-    let selection: array<HyperFuelClient.QueryTypes.receiptSelection> = []
-
-    //Instantiate each time to add new registered contract addresses
-    contractNames->Utils.Set.forEach(contractName => {
-      switch addressesByContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
-      | None
-      | Some([]) => ()
-      | Some(addresses) => {
-          switch nonLogDataReceiptTypesByContract->Utils.Dict.dangerouslyGetNonOption(
-            contractName,
-          ) {
-          | Some(receiptTypes) =>
-            selection
-            ->Array.push({
-              rootContractId: addresses,
-              receiptType: receiptTypes,
-              txStatus: txStatusSelection,
-            })
-            ->ignore
-          | None => ()
-          }
-          switch nonWildcardLogDataRbsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-          | None
-          | Some([]) => ()
-          | Some(nonWildcardLogDataRbs) =>
-            selection
-            ->Array.push({
-              rootContractId: addresses,
-              receiptType: logDataReceiptTypeSelection,
-              txStatus: txStatusSelection,
-              rb: nonWildcardLogDataRbs,
-            })
-            ->ignore
-          }
-        }
-      }
-    })
-
-    selection
-  }
-}
-
-let makeWildcardRecieptsSelection = (~wildcardLogDataRbs, ~nonLogDataWildcardReceiptTypes) => {
-  let selection: array<HyperFuelClient.QueryTypes.receiptSelection> = []
-
-  switch nonLogDataWildcardReceiptTypes {
-  | [] => ()
-  | nonLogDataWildcardReceiptTypes =>
-    selection
-    ->Array.push(
-      (
-        {
-          receiptType: nonLogDataWildcardReceiptTypes,
-          txStatus: txStatusSelection,
-        }: HyperFuelClient.QueryTypes.receiptSelection
-      ),
-    )
-    ->ignore
-  }
-
-  switch wildcardLogDataRbs {
-  | [] => ()
-  | wildcardLogDataRbs =>
-    selection
-    ->Array.push(
-      (
-        {
-          receiptType: logDataReceiptTypeSelection,
-          txStatus: txStatusSelection,
-          rb: wildcardLogDataRbs,
-        }: HyperFuelClient.QueryTypes.receiptSelection
-      ),
-    )
-    ->ignore
-  }
-
-  selection
-}
-
-let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
-  let eventRouter = EventRouter.empty()
-  let nonWildcardLogDataRbsByContract = Dict.make()
-  let wildcardLogDataRbs = []
-
-  // This is for non-LogData events, since they don't have rb filter and can be grouped
-  let nonLogDataReceiptTypesByContract = Dict.make()
-  let nonLogDataWildcardReceiptTypes = []
-
-  let addNonLogDataWildcardReceiptTypes = (receiptType: FuelSDK.receiptType) => {
-    nonLogDataWildcardReceiptTypes->Array.push(receiptType)->ignore
-  }
-  let addNonLogDataReceiptType = (contractName, receiptType: FuelSDK.receiptType) => {
-    switch nonLogDataReceiptTypesByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-    | None => nonLogDataReceiptTypesByContract->Dict.set(contractName, [receiptType])
-    | Some(receiptTypes) => receiptTypes->Array.push(receiptType)->ignore // Duplication prevented by EventRouter
-    }
-  }
-
-  let contractNames = Utils.Set.make()
-
-  selection.onEventRegistrations->Array.forEach(reg => {
-    let eventConfig =
-      reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig)
-    let contractName = eventConfig.contractName
-    let isWildcard = reg.isWildcard
-    if !isWildcard {
-      let _ = contractNames->Utils.Set.add(contractName)
-    }
-    eventRouter->EventRouter.addOrThrow(
-      eventConfig.id,
-      reg,
-      ~contractName,
-      ~eventName=eventConfig.name,
-      ~chain,
-      ~isWildcard,
-    )
-
-    switch (eventConfig.kind, isWildcard) {
-    | (Mint, true) => addNonLogDataWildcardReceiptTypes(Mint)
-    | (Mint, false) => addNonLogDataReceiptType(contractName, Mint)
-    | (Burn, true) => addNonLogDataWildcardReceiptTypes(Burn)
-    | (Burn, false) => addNonLogDataReceiptType(contractName, Burn)
-    | (Transfer, true) => {
-        addNonLogDataWildcardReceiptTypes(Transfer)
-        addNonLogDataWildcardReceiptTypes(TransferOut)
-      }
-    | (Transfer, false) => {
-        addNonLogDataReceiptType(contractName, Transfer)
-        addNonLogDataReceiptType(contractName, TransferOut)
-      }
-    | (Call, true) => addNonLogDataWildcardReceiptTypes(Call)
-    | (Call, false) =>
-      JsError.throwWithMessage("Call receipt indexing currently supported only in wildcard mode")
-    | (LogData({logId}), _) => {
-        let rb = logId->BigInt.fromStringOrThrow
-        if isWildcard {
-          wildcardLogDataRbs->Array.push(rb)->ignore
-        } else {
-          switch nonWildcardLogDataRbsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-          | Some(arr) => arr->Array.push(rb)
-          | None => nonWildcardLogDataRbsByContract->Dict.set(contractName, [rb])
-          }
-        }
-      }
-    }
-  })
-
-  {
-    getRecieptsSelection: switch selection.dependsOnAddresses {
-    | false => {
-        let recieptsSelection = makeWildcardRecieptsSelection(
-          ~wildcardLogDataRbs,
-          ~nonLogDataWildcardReceiptTypes,
-        )
-        (~addressesByContractName as _) => recieptsSelection
-      }
-    | true =>
-      makeGetNormalRecieptsSelection(
-        ~nonWildcardLogDataRbsByContract,
-        ~nonLogDataReceiptTypesByContract,
-        ~contractNames,
-      )
-    },
-    eventRouter,
-  }
-}
-
-let memoGetSelectionConfig = (~chain) => {
-  let cache = Utils.WeakMap.make()
-  selection =>
-    switch cache->Utils.WeakMap.get(selection) {
-    | Some(c) => c
-    | None => {
-        let c = selection->getSelectionConfig(~chain)
-        let _ = cache->Utils.WeakMap.set(selection, c)
-        c
-      }
-    }
-}
-
-type options = {
-  chain: ChainMap.Chain.t,
-  endpointUrl: string,
-  apiToken: option<string>,
-}
-
-let make = ({chain, endpointUrl, apiToken}: options): t => {
-  let name = "HyperFuel"
-
-  let apiToken = switch apiToken {
-  | Some(token) => token
-  | None =>
-    JsError.throwWithMessage(`An Envio API token is required for using HyperFuel as a data-source.
-Set the ENVIO_API_TOKEN environment variable in your .env file.
-Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
-  }
-
-  let client = switch HyperFuelClient.make({url: endpointUrl, apiToken}) {
-  | client => client
-  | exception exn =>
-    exn->ErrorHandling.mkLogAndRaise(~msg="Failed to instantiate the HyperFuel client")
-  }
-
-  let getSelectionConfig = memoGetSelectionConfig(~chain)
-
-  let getItemsOrThrow = async (
-    ~fromBlock,
-    ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress,
-    ~knownHeight,
-    ~partitionId as _,
-    ~selection: FetchState.selection,
-    ~itemsTarget as _,
-    ~retry,
-    ~logger,
-  ) => {
-    let totalTimeRef = Performance.now()
-
-    let selectionConfig = getSelectionConfig(selection)
-    let recieptsSelection = selectionConfig.getRecieptsSelection(~addressesByContractName)
-
-    let startFetchingBatchTimeRef = Performance.now()
-
-    //fetch batch
-    let pageUnsafe = try await HyperFuel.GetLogs.query(
-      ~client,
-      ~fromBlock,
-      ~toBlock,
-      ~recieptsSelection,
-    ) catch {
-    | HyperFuel.GetLogs.Error(error) =>
-      throw(
-        Source.GetItemsError(
-          Source.FailedGettingItems({
-            exn: %raw(`null`),
-            attemptedToBlock: toBlock->Option.getOr(knownHeight),
-            retry: switch error {
-            | WrongInstance =>
-              let backoffMillis = switch retry {
-              | 0 => 100
-              | _ => 500 * retry
-              }
-              WithBackoff({
-                message: `Block #${fromBlock->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 ${backoffMillis->Int.toString}ms.`,
-                backoffMillis,
-              })
-            | UnexpectedMissingParams({missingParams}) =>
-              ImpossibleForTheQuery({
-                message: `Source returned invalid data with missing required fields: ${missingParams->Array.joinUnsafe(
-                    ", ",
-                  )}`,
-              })
-            },
-          }),
-        ),
-      )
-    | exn =>
-      throw(
-        Source.GetItemsError(
-          Source.FailedGettingItems({
-            exn,
-            attemptedToBlock: toBlock->Option.getOr(knownHeight),
-            retry: WithBackoff({
-              message: `Unexpected issue while fetching events from HyperFuel client. Attempt a retry.`,
-              backoffMillis: switch retry {
-              | 0 => 500
-              | _ => 1000 * retry
-              },
-            }),
-          }),
-        ),
-      )
-    }
-
-    let pageFetchTime = startFetchingBatchTimeRef->Performance.secondsSince
-    let requestStats = [{Source.method: "getLogs", seconds: pageFetchTime}]
-
-    //set height and next from block
-    let knownHeight = pageUnsafe.archiveHeight
-
-    //The heighest (biggest) blocknumber that was accounted for in
-    //Our query. Not necessarily the blocknumber of the last log returned
-    //In the query
-    let heighestBlockQueried = pageUnsafe.nextBlock - 1
-
-    let parsingTimeRef = Performance.now()
-
-    let parsedQueueItems = pageUnsafe.items->Array.map(item => {
-      let {contractId: contractAddress, receipt, block, receiptIndex} = item
-
-      let chainId = chain->ChainMap.Chain.toChainId
-      let eventId = switch receipt {
-      | LogData({rb}) => BigInt.toString(rb)
-      | Mint(_) => mintEventTag
-      | Burn(_) => burnEventTag
-      | Transfer(_)
-      | TransferOut(_) => transferEventTag
-      | Call(_) => callEventTag
-      }
-
-      let onEventRegistration = switch selectionConfig.eventRouter->EventRouter.get(
-        ~tag=eventId,
-        ~contractNameByAddress,
-        ~contractAddress,
-      ) {
-      | None => {
-          let logger = Logging.createChildFrom(
-            ~logger,
-            ~params={
-              "chainId": chainId,
-              "blockNumber": block.height,
-              "logIndex": receiptIndex,
-              "contractAddress": contractAddress,
-              "eventId": eventId,
-            },
-          )
-          EventRoutingFailed->ErrorHandling.mkLogAndRaise(
-            ~msg="Failed to route registered event",
-            ~logger,
-          )
-        }
-      | Some(onEventRegistration) => onEventRegistration
-      }
-
-      let eventConfig =
-        onEventRegistration.eventConfig->(
-          Utils.magic: Internal.eventConfig => Internal.fuelEventConfig
-        )
-
-      let params = switch (eventConfig, receipt) {
-      | ({kind: LogData({decode})}, LogData({data})) =>
-        try decode(data) catch {
-        | exn => {
-            let params = {
-              "chainId": chainId,
-              "blockNumber": block.height,
-              "logIndex": receiptIndex,
-            }
-            let logger = Logging.createChildFrom(~logger, ~params)
-            exn->ErrorHandling.mkLogAndRaise(
-              ~msg="Failed to decode Fuel LogData receipt, please double check your ABI.",
-              ~logger,
-            )
-          }
-        }
-      | (_, Mint({val, subId}))
-      | (_, Burn({val, subId})) =>
-        (
-          {
-            subId,
-            amount: val,
-          }: Internal.fuelSupplyParams
-        )->Obj.magic
-      | (_, Transfer({amount, assetId, to})) =>
-        (
-          {
-            to: to->Address.unsafeFromString,
-            assetId,
-            amount,
-          }: Internal.fuelTransferParams
-        )->Obj.magic
-      | (_, TransferOut({amount, assetId, toAddress})) =>
-        (
-          {
-            to: toAddress->Address.unsafeFromString,
-            assetId,
-            amount,
-          }: Internal.fuelTransferParams
-        )->Obj.magic
-      | (_, Call({amount, assetId, to})) =>
-        (
-          {
-            to: to->Address.unsafeFromString,
-            assetId,
-            amount,
-          }: Internal.fuelTransferParams
-        )->Obj.magic
-      // This should never happen unless there's a bug in the routing logic
-      | _ => JsError.throwWithMessage("Unexpected bug in the event routing logic")
-      }
-
-      Internal.Event({
-        onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
-        chain,
-        blockNumber: block.height,
-        logIndex: receiptIndex,
-        // Fuel carries the transaction inline on the payload; the store key is
-        // unused (Fuel identifies transactions by hash, kept on the payload).
-        transactionIndex: 0,
-        payload: {
-          contractName: eventConfig.contractName,
-          eventName: eventConfig.name,
-          chainId,
-          params,
-          transaction: {
-            "id": item.transactionId,
-          }->Obj.magic, // TODO: Obj.magic needed until the field selection types are not configurable for Fuel and Evm separately
-          block: block->Obj.magic,
-          srcAddress: contractAddress,
-          logIndex: receiptIndex,
-        }->Fuel.fromPayload,
-      })
-    })
-
-    let parsingTimeElapsed = parsingTimeRef->Performance.secondsSince
-
-    // Fuel never rolls back on reorg, so block hashes here are purely informational
-    // for detect-only logging via ReorgDetection.
-    let blockHashes = pageUnsafe.items->Array.map(({block}) => {
-      ReorgDetection.blockNumber: block.height,
-      blockHash: block.id,
-    })
-
-    let latestFetchedBlockTimestamp = switch pageUnsafe.items->Array.get(
-      pageUnsafe.items->Array.length - 1,
-    ) {
-    | Some({block}) if block.height == heighestBlockQueried => block.time
-    | _ => 0
-    }
-
-    let totalTimeElapsed = totalTimeRef->Performance.secondsSince
-
-    let stats = {
-      totalTimeElapsed,
-      parsingTimeElapsed,
-      pageFetchTime,
-    }
-
-    {
-      latestFetchedBlockTimestamp,
-      parsedQueueItems,
-      // Fuel keeps transaction and block on the payload; no store pages.
-      transactionStore: None,
-      blockStore: None,
-      latestFetchedBlockNumber: heighestBlockQueried,
-      stats,
-      knownHeight,
-      blockHashes,
-      fromBlockQueried: fromBlock,
-      requestStats,
-    }
-  }
-
-  let getBlockHashes = (~blockNumbers as _, ~logger as _) =>
-    JsError.throwWithMessage("HyperFuel does not support getting block hashes")
-
-  {
-    name,
-    sourceFor: Sync,
-    chain,
-    getBlockHashes,
-    pollingInterval: 100,
-    poweredByHyperSync: true,
-    getHeightOrThrow: async () => {
-      let timerRef = Performance.now()
-      let height = try await client->HyperFuelClient.getHeight catch {
-      | JsExn(e) =>
-        switch e->JsExn.message {
-        | Some(message) if message->isUnauthorizedError =>
-          Logging.error(`Your ENVIO_API_TOKEN was rejected by HyperFuel (401 Unauthorized). The indexer will not be able to fetch events. Update the token and try again using 'envio start' or 'envio dev'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens`)
-          // Retrying an unauthorized request can never succeed, so block forever
-          let _ = await Promise.make((_, _) => ())
-          0
-        | _ => throw(JsExn(e))
-        }
-      }
-      let seconds = timerRef->Performance.secondsSince
-      {height, requestStats: [{method: "getHeight", seconds}]}
-    },
-    getItemsOrThrow,
-  }
-}