@berachain/berajs 0.1.1 → 0.2.0

package/src/hooks/dex/useAggregatorsQuotes.ts

@@ -0,0 +1,263 @@
+import { useMemo } from "react";
+import { type Address, zeroAddress } from "viem";
+
+import { defaultChainId } from "@berachain/config/internal";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { bex } from "~/actions/dex/aggregators/bex";
+import { bgtRedeem } from "~/actions/dex/aggregators/bgt";
+import { enso } from "~/actions/dex/aggregators/enso/enso";
+import { erc4626Deposit } from "~/actions/dex/aggregators/erc4626";
+import { fly } from "~/actions/dex/aggregators/fly";
+import { haiku } from "~/actions/dex/aggregators/haiku";
+import { 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 } from "~/contexts/HoneyConfigProvider";
+import type { SwapReferrer } from "~/enum/dex";
+import { useAggregatorsRouterFeeBps } from "~/hooks/dex/useAggregatorsRouterFeeBps";
+import type { IRawAggregatorQuote, MinimalERC20 } from "~/types/dex";
+import type { DefaultHookOptions } from "~/types/global";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { isToken } from "~/utils/tokens";
+import { useUnderlyingAsset } from "../tokens/useUnderlyingAsset";
+import { useBexStatus } from "./useBexStatus";
+import {
+  getAggregatorsSWROptions,
+  raw_useSingleAggregatorQuote,
+} from "./useSingleAggregatorQuote";
+
+const AGGREGATORS = [
+  oogabooga,
+  fly,
+  kyberswap,
+  openOcean,
+  haiku,
+  enso,
+  bex,
+  honeyNative,
+  erc4626Deposit,
+];
+
+type IUseAggregatorsQuotesArgs = BeraJS.BaseFunctionArgs & {
+  tokenIn: MinimalERC20;
+  tokenOut: MinimalERC20;
+  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"
+  >;
+};
+
+export function 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 isWrapOrUnwrap =
+    (isToken(args.tokenIn.address, "BERA") ||
+      isToken(args.tokenIn.address, "WBERA")) &&
+    (isToken(args.tokenOut.address, "BERA") ||
+      isToken(args.tokenOut.address, "WBERA"));
+
+  const isBgtRedeem = isToken(args.tokenIn.address, "BGT", {
+    chainId: defaultChainId,
+  });
+
+  const { data: underlyingToken } = useUnderlyingAsset({
+    token: args.tokenOut,
+  });
+
+  /**
+   * 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 = getAggregatorsSWROptions(options);
+
+  const sharedArgs = {
+    activeAggregators,
+    isMAEnabled,
+    underlyingToken,
+    isNativeSwap,
+    account,
+    publicClient,
+    proxyAggregatorsThroughVercel,
+    feeBps,
+  } as const;
+
+  // we're using independent useSWRs so we can show quotes as they come
+  // instead of waiting for all of them to load
+  const oogaBogaResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: oogabooga,
+    },
+    { opts: swrOptions },
+  );
+
+  const flyResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: fly,
+    },
+    { opts: swrOptions },
+  );
+
+  const erc4626Result = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: erc4626Deposit,
+    },
+    { opts: swrOptions },
+  );
+
+  const kyberswapResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: kyberswap,
+    },
+    { opts: swrOptions },
+  );
+
+  const openOceanResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: openOcean,
+    },
+    { opts: swrOptions },
+  );
+
+  const haikuResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: haiku,
+    },
+    { opts: swrOptions },
+  );
+
+  const ensoResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: enso,
+    },
+    { opts: swrOptions },
+  );
+
+  const { protocol: bexProtocol } = useBexStatus();
+
+  const bexResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: bex,
+    },
+    { opts: { ...swrOptions, isEnabled: bexProtocol.isPaused === false } },
+  );
+
+  const wberaSwapResult = raw_useSingleAggregatorQuote({
+    ...sharedArgs,
+    ...args,
+    aggregator: wberaSwap,
+  });
+
+  const bgtRedeemResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: bgtRedeem,
+    },
+    { opts: swrOptions },
+  );
+
+  const honeyResult = raw_useSingleAggregatorQuote(
+    {
+      ...sharedArgs,
+      ...args,
+      aggregator: honeyNative,
+    },
+    { opts: swrOptions },
+  );
+
+  const results = isWrapOrUnwrap
+    ? [wberaSwapResult]
+    : isBgtRedeem
+      ? [bgtRedeemResult]
+      : [
+          oogaBogaResult,
+          erc4626Result,
+          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/global";
+
+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/InvalidArgumentError";
+
+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";