@berachain/berajs 0.1.1 → 0.1.2

package/src/hooks/dex/useAggregatorsQuotes.ts

@@ -0,0 +1,502 @@
+import { useMemo } from "react";
+import useSWR, { type SWRConfiguration } from "swr";
+import { type Address, type PublicClient, parseUnits, zeroAddress } from "viem";
+
+import { defaultChainId } from "@berachain/config/internal";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { BaseAggregator } from "~/actions/dex/aggregators/base";
+import { bex } from "~/actions/dex/aggregators/bex";
+import { bgtRedeem } from "~/actions/dex/aggregators/bgt";
+import { enso } from "~/actions/dex/aggregators/enso";
+import { fly } from "~/actions/dex/aggregators/fly";
+import { haiku } from "~/actions/dex/aggregators/haiku";
+import {
+  HoneyNativeAggregator,
+  honeyNative,
+} from "~/actions/dex/aggregators/honey";
+import { kyberswap } from "~/actions/dex/aggregators/kyberswap";
+import { oogabooga } from "~/actions/dex/aggregators/oogabooga";
+import { openOcean } from "~/actions/dex/aggregators/openOcean";
+import { wberaSwap } from "~/actions/dex/aggregators/wbera";
+import { useBeraFlag } from "~/contexts/BeraFlags/BeraFlags";
+import type {
+  HoneyConfigContextReturn,
+  TokenWithOrder,
+} from "~/contexts/HoneyConfigProvider";
+import { POLLING } from "~/enum";
+import { BeraError } from "~/errors/BeraError";
+import { RequestError } from "~/errors/RequestError";
+import { useAggregatorsRouterFeeBps } from "~/hooks";
+import type {
+  DefaultHookOptions,
+  IRawAggregatorQuote,
+  SwapReferrer,
+} from "~/types";
+import type { Aggregators } from "~/types/dex";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { seconds } from "~/utils/time";
+import { isToken } from "~/utils/tokens";
+import { useBexStatus } from "./useBexStatus";
+
+const AGGREGATORS = [
+  oogabooga,
+  fly,
+  kyberswap,
+  openOcean,
+  haiku,
+  enso,
+  bex,
+  honeyNative,
+];
+
+type IUseAggregatorsQuotesArgs = BeraJS.BaseFunctionArgs & {
+  tokenIn: Address;
+  tokenOut: Address;
+  tokenInDecimals: number;
+  tokenOutDecimals: number;
+  amount: string;
+  slippage: number;
+  referrer?: SwapReferrer;
+  rewardVault?: Address;
+  /**
+   * Useful cause the collaterals are provided byt he honeyContext and this way we can
+   * use the Provider only in the swap page where is needed.
+   *
+   * The collaterals for the honey mint/redeem aggregator.
+   */
+  honeyNativeState?: Pick<
+    HoneyConfigContextReturn,
+    "collateralList" | "protocol"
+  >;
+};
+
+type IQueryKey = readonly [
+  string, // "useAggregatorsQuotes
+  string, // name
+  Address, // tokenIn
+  Address, // tokenOut
+  string, // parsedAmount
+  number, // slippage
+  Address | undefined, // account
+  number | undefined, // feeBps
+  number, // tokenInDecimals
+  number, // tokenOutDecimals
+  SwapReferrer | undefined, // referrer
+  Address | undefined, // rewardVault
+  TokenWithOrder[] | undefined, // collateralList
+];
+
+export const USE_AGGREGATORS_QUOTES_QUERY_KEY = "useAggregatorsQuotes";
+
+function getQueryKey({
+  name,
+  account,
+  args,
+  feeBps,
+  options,
+  activeAggregators,
+  honeyNativeState,
+}: {
+  name: Aggregators;
+  account: Address | undefined;
+  args: IUseAggregatorsQuotesArgs;
+  feeBps: number | undefined;
+  options?: DefaultHookOptions;
+  /**
+   * List of active aggregators fetched from edge config flags.
+   *
+   * If undefined, all aggregators are enabled.
+   */
+  activeAggregators: string[] | undefined;
+  honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+}): IQueryKey | null {
+  if (name !== bgtRedeem.name) {
+    if (
+      isToken(args.tokenIn, "BGT", { chainId: defaultChainId }) ||
+      isToken(args.tokenOut, "BGT", { chainId: defaultChainId })
+    ) {
+      // can't happen, but just in case
+      return null;
+    }
+  }
+
+  const {
+    tokenIn,
+    tokenOut,
+    tokenInDecimals,
+    tokenOutDecimals,
+    amount,
+    slippage,
+    referrer,
+    rewardVault,
+  } = args;
+  const parsedAmount = parseUnits(amount, tokenInDecimals).toString();
+
+  const isEnabledOnConfig =
+    !activeAggregators ||
+    activeAggregators.includes(name.toLowerCase().replaceAll(" ", ""));
+
+  return options?.opts?.isEnabled &&
+    Number(amount) &&
+    feeBps !== undefined &&
+    isEnabledOnConfig
+    ? [
+        USE_AGGREGATORS_QUOTES_QUERY_KEY,
+        name,
+        tokenIn,
+        tokenOut,
+        parsedAmount,
+        slippage,
+        account,
+        feeBps,
+        tokenInDecimals,
+        tokenOutDecimals,
+        referrer,
+        rewardVault,
+        honeyNativeState?.collateralList,
+      ]
+    : null;
+}
+
+function getQueryFn({
+  aggregator,
+  publicClient,
+  proxyAggregatorsThroughVercel,
+}: {
+  aggregator: BaseAggregator;
+  publicClient?: PublicClient;
+  proxyAggregatorsThroughVercel?: boolean;
+}) {
+  return async ([
+    ,
+    ,
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account,
+    aggregatorsFeeBps,
+    tokenInDecimals,
+    tokenOutDecimals,
+    referrer,
+    rewardVault,
+    honeyCollaterals,
+  ]: IQueryKey) =>
+    aggregator.getQuote({
+      tokenIn,
+      tokenOut,
+      amount,
+      slippage,
+      account,
+      aggregatorsFeeBps,
+      tokenInDecimals,
+      tokenOutDecimals,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+      referrer,
+      rewardVault,
+      honeyNativeState: {
+        collateralList: honeyCollaterals ?? [],
+      },
+    });
+}
+
+export const useAggregatorsQuotes = (
+  args: IUseAggregatorsQuotesArgs,
+  options?: DefaultHookOptions,
+) => {
+  const { address: account } = useBeraWallet();
+  const proxyAggregatorsThroughVercel = useBeraFlag(
+    "proxyAggregatorsThroughVercel",
+  );
+  const activeAggregators = useBeraFlag("aggregators");
+  const publicClient = usePublicClient();
+  const { data: feeBps } = useAggregatorsRouterFeeBps();
+
+  const { collateralList: collaterals, protocol: honeyProtocol } =
+    args.honeyNativeState ?? {};
+
+  const isWrapOrUnwrap =
+    (isToken(args.tokenIn, "BERA") || isToken(args.tokenIn, "WBERA")) &&
+    (isToken(args.tokenOut, "BERA") || isToken(args.tokenOut, "WBERA"));
+
+  const isBgtRedeem = isToken(args.tokenIn, "BGT", { chainId: defaultChainId });
+
+  // retrieve the honey collaterals in order to check if the swap is a honey mint or redeem
+  const isHoneyNative = useMemo(
+    () => HoneyNativeAggregator.isHoneyNativeSwap(args),
+    [args.tokenOut, args.tokenIn, collaterals],
+  );
+  /**
+   * Whether it's a native swap (wrap/unwrap) or BGT redeem
+   */
+  const isNativeSwap = isWrapOrUnwrap || isBgtRedeem;
+
+  const { config } = parseBaseArgs(args);
+
+  const isMAEnabled = config.bex.aggregatorsRouter !== zeroAddress;
+
+  const swrOptions: SWRConfiguration = {
+    refreshInterval: POLLING.FAST, // every 10s
+    errorRetryCount: 3,
+    // biome-ignore lint/nursery/useMaxParams: the function is defined in the SWRConfiguration type
+    onErrorRetry(err, key, config, revalidate, revalidateOpts) {
+      if (err instanceof BeraError) {
+        if (err.reason === BaseAggregator.PATH_NOT_FOUND_REASON) {
+          return;
+        }
+      }
+
+      if (err instanceof RequestError && err.statusCode === 403) {
+        console.warn(key[1], "returned error 403, stopping retries");
+        return;
+      }
+
+      if (revalidateOpts.retryCount > (config.errorRetryCount ?? 3)) {
+        return;
+      }
+
+      setTimeout(() => {
+        revalidate();
+      }, config.errorRetryInterval ?? seconds(10));
+    },
+  };
+
+  // we're using independent useSWRs so we can show quotes as they come
+  // instead of waiting for all of them to load
+  const oogaBogaResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: oogabooga.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({ aggregator: oogabooga, proxyAggregatorsThroughVercel }),
+    swrOptions,
+  );
+  const flyResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: fly.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({ aggregator: fly, proxyAggregatorsThroughVercel }),
+    swrOptions,
+  );
+  const kyberswapResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: kyberswap.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({ aggregator: kyberswap, proxyAggregatorsThroughVercel }),
+    swrOptions,
+  );
+  const openOceanResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: openOcean.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({
+      aggregator: openOcean,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+    }),
+    swrOptions,
+  );
+  const haikuResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: haiku.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({
+      aggregator: haiku,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+    }),
+
+    swrOptions,
+  );
+  const ensoResult = useSWR(
+    isNativeSwap || !isMAEnabled
+      ? null
+      : getQueryKey({
+          name: enso.name,
+          account,
+          args,
+          feeBps,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({ aggregator: enso, proxyAggregatorsThroughVercel }),
+    swrOptions,
+  );
+  const { protocol: bexProtocol } = useBexStatus();
+
+  const bexResult = useSWR(
+    isNativeSwap ||
+      // dont use undefined as falsy
+      bexProtocol.isPaused === true ||
+      // BEX is not able to stake in a single transaction
+      args.rewardVault
+      ? null
+      : getQueryKey({
+          name: bex.name,
+          account,
+          args,
+          // Always zero on bex swaps
+          feeBps: 0,
+          options,
+          activeAggregators,
+        }),
+    getQueryFn({ aggregator: bex, publicClient }),
+    swrOptions,
+  );
+  const wberaSwapResult = useSWR(
+    isWrapOrUnwrap
+      ? getQueryKey({
+          name: wberaSwap.name,
+          account,
+          args,
+          // Always 0 for wrap/unwrap
+          feeBps: 0,
+          options,
+          // wbera is always enabled
+          activeAggregators: undefined,
+        })
+      : null,
+    async ([, , tokenIn, tokenOut, amount, , account]: IQueryKey) => {
+      return wberaSwap.getQuote({
+        tokenIn,
+        tokenOut,
+        amount,
+        account,
+      });
+    },
+    swrOptions,
+  );
+  const bgtRedeemResult = useSWR(
+    isBgtRedeem
+      ? getQueryKey({
+          name: bgtRedeem.name,
+          account,
+          args,
+          // Always 0 for native swaps
+          feeBps: 0,
+          options,
+          // BGT redeem is always enabled
+          activeAggregators: undefined,
+        })
+      : null,
+    async ([, , tokenIn, , amount]: IQueryKey) => {
+      return bgtRedeem.getQuote({
+        tokenIn,
+        amount,
+      });
+    },
+    swrOptions,
+  );
+  const honeyResult = useSWR(
+    !isHoneyNative ||
+      isNativeSwap ||
+      honeyProtocol?.isPaused === true ||
+      !collaterals
+      ? null
+      : getQueryKey({
+          name: honeyNative.name,
+          account,
+          args,
+          // Always 0 for honey mint/redeem
+          feeBps: 0,
+          options,
+          // honey mint/redeem is always enabled
+          activeAggregators: undefined,
+          honeyNativeState: {
+            collateralList: collaterals,
+          },
+        }),
+    getQueryFn({
+      aggregator: honeyNative,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+    }),
+    swrOptions,
+  );
+  const results = isWrapOrUnwrap
+    ? [wberaSwapResult]
+    : isBgtRedeem
+      ? [bgtRedeemResult]
+      : [
+          oogaBogaResult,
+          flyResult,
+          kyberswapResult,
+          openOceanResult,
+          haikuResult,
+          ensoResult,
+          honeyResult,
+          bexProtocol.isPaused === false ? bexResult : null,
+        ].filter((i): i is NonNullable<typeof i> => i !== null);
+
+  const data = useMemo(() => {
+    const error = results.reduce<(typeof results)[number]["error"]>(
+      (error, result) => error || result.error,
+      undefined,
+    );
+
+    const loadingAggregatorsNames = results
+      .map((r, i) =>
+        r.isLoading
+          ? isNativeSwap
+            ? wberaSwap.name
+            : AGGREGATORS[i].name
+          : null,
+      )
+      .filter(Boolean);
+
+    const quotes = results
+      .filter(
+        (result) =>
+          result !== undefined &&
+          !result.isLoading &&
+          !result.error &&
+          result.data?.amountOut,
+      )
+      .map(({ data }) => data) as IRawAggregatorQuote[];
+
+    const isLoading = quotes.length === 0 && loadingAggregatorsNames.length > 0;
+    return { quotes, loadingAggregatorsNames, isLoading, error };
+  }, [results]);
+
+  return {
+    ...data,
+    refresh: () => results.map((r) => r.mutate()),
+  };
+};

package/src/hooks/dex/useAggregatorsRouterFeeBps.ts

@@ -0,0 +1,34 @@
+import useSWRImmutable from "swr/immutable";
+import { type PublicClient, zeroAddress } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useAggregatorsRouterFeeBps = () => {
+  const publicClient = usePublicClient() as PublicClient;
+  const { config } = parseBaseArgs({
+    chainId: publicClient.chain?.id,
+  });
+  const swrResponse = useSWRImmutable(
+    publicClient &&
+      config.bex.aggregatorsRouter &&
+      config.bex.aggregatorsRouter !== zeroAddress
+      ? (["useAggregatorsRouterFeeBps", config.bex.aggregatorsRouter] as const)
+      : null,
+    async ([, aggregatorsRouter]) => {
+      const fee = await publicClient.readContract({
+        address: aggregatorsRouter,
+        abi: aggregatorsRouterAbi,
+        functionName: "SWAP_FEE_RATE",
+      });
+      return Number(fee);
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate,
+  };
+};

package/src/hooks/dex/useAllUserPools.ts

@@ -0,0 +1,38 @@
+import useSWR from "swr";
+
+import type { GetPoolsQueryVariables } from "@berachain/graphql/dex/api";
+
+import { getAllPools } from "~/actions/dex/getAllPools";
+import { POLLING } from "~/enum/polling";
+import type { DefaultHookOptions } from "~/types";
+
+export const useAllUserPoolsQueryKey = ({
+  query,
+}: {
+  query?: GetPoolsQueryVariables;
+} = {}) => {
+  return ["useAllUserPools", query];
+};
+
+export const useAllUserPools = (
+  query: GetPoolsQueryVariables,
+  options?: DefaultHookOptions,
+) => {
+  const swrResponse = useSWR(
+    useAllUserPoolsQueryKey({ query }),
+    async ([_, params]: [string, GetPoolsQueryVariables]) => {
+      return getAllPools({ ...params, fetchPolicy: "no-cache" });
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => {
+      swrResponse.mutate();
+    },
+  };
+};

package/src/hooks/dex/useApiPool.ts

@@ -0,0 +1,53 @@
+import useSWR from "swr";
+import { type Address, type Hex, isAddress } from "viem";
+
+import type { MinimalPoolFragment } from "@berachain/graphql/dex/api";
+
+import { getApiPool } from "~/actions/dex/getApiPool";
+import { POLLING } from "~/enum/polling";
+import { InvalidArgumentError } from "~/errors";
+
+export const useApiPoolQueryKey = ({
+  poolId,
+  account,
+}: {
+  poolId: Hex;
+  account?: Address;
+}) => {
+  return poolId ? ([`usePool-api`, poolId, account] as const) : null;
+};
+
+export function useApiPool({
+  poolId,
+  account,
+}: {
+  poolId: Hex;
+  account?: Address;
+}) {
+  const res = useSWR(
+    useApiPoolQueryKey({ poolId, account }),
+    async ([, poolId, account]): Promise<MinimalPoolFragment> => {
+      if (account && !isAddress(account)) {
+        throw new InvalidArgumentError({
+          property: "account",
+          value: account,
+          expected: "Address",
+        });
+      }
+      return getApiPool({
+        poolId,
+        account: account as Address,
+      });
+    },
+    {
+      refreshInterval: POLLING.NORMAL,
+    },
+  );
+
+  return {
+    ...res,
+    refresh: () => {
+      res.mutate();
+    },
+  };
+}

package/src/hooks/dex/useBexStatus.ts

@@ -0,0 +1 @@
+export { useBexStatus } from "~/contexts/BexStatusProvider";