@berachain/berajs 0.1.0 → 0.1.2

package/src/hooks/dex/useLpPosition.ts

@@ -0,0 +1,115 @@
+import BigNumber from "bignumber.js";
+import { type Address, formatEther, isAddressEqual } from "viem";
+
+import type { MinimalPoolFragment } from "@berachain/graphql/dex/api";
+
+import { useRewardVaultBalanceFromStakingToken } from "~/hooks/pol/useRewardVaultBalanceFromStakingToken";
+import { usePollBalance } from "~/hooks/tokens/usePollBalance";
+import type {
+  DefaultHookOptions,
+  DefaultHookReturnType,
+  IUserPosition,
+} from "~/types";
+
+type IUseLpPositionArgs = {
+  pool: MinimalPoolFragment | undefined;
+  vaultAddress?: Address | undefined;
+};
+
+/**
+ * Given a pool and used within an initialized viem context, returns the user's position
+ */
+export const useLpPosition = (
+  { pool, vaultAddress }: IUseLpPositionArgs,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<IUserPosition> => {
+  const { data: userPosition, ...rest } = usePollBalance({
+    address: pool?.address,
+  });
+
+  const { data: userVaultTokenBalance, refresh: refreshVaultDeposit } =
+    useRewardVaultBalanceFromStakingToken(
+      {
+        stakingToken: pool?.address,
+        rewardVaultAddress: vaultAddress ?? pool?.rewardVault?.vaultAddress,
+      },
+      options,
+    );
+
+  const actualPoolShares = pool
+    ? Number.parseFloat(pool?.dynamicData?.totalShares ?? "0")
+    : 0;
+
+  const tvlInUsd = pool?.dynamicData?.totalLiquidity
+    ? Number(pool?.dynamicData?.totalLiquidity ?? 0)
+    : null;
+
+  const lpTokenPrice =
+    actualPoolShares && tvlInUsd ? tvlInUsd / Number(actualPoolShares) : 0;
+
+  const tokenRatioPerLp = pool?.tokens?.map((token) => {
+    return {
+      address: token.address,
+      ratio: actualPoolShares
+        ? Number(token.balance) / Number(actualPoolShares)
+        : 0,
+    };
+  });
+
+  return {
+    data: {
+      lpTokenPrice,
+      lpBalance: userPosition
+        ? {
+            ...userPosition,
+            usdValue: userPosition
+              ? Number(userPosition.formattedBalance) * lpTokenPrice
+              : undefined,
+          }
+        : undefined,
+      tokenBalances: pool?.tokens?.map((token) => {
+        const tokenRatio =
+          tokenRatioPerLp?.find((tr) =>
+            isAddressEqual(tr.address as Address, token.address as Address),
+          )?.ratio ?? 0;
+
+        const userBalance = tokenRatio
+          ? BigNumber(userPosition?.formattedBalance ?? "0").times(tokenRatio)
+          : BigNumber(0);
+        const price = Number(token.balanceUSD) / Number(token.balance);
+
+        return {
+          balance: userBalance?.isGreaterThan(0)
+            ? BigInt(
+                userBalance
+                  .times(10 ** token.decimals!)
+                  .toFixed(0)
+                  .toString(),
+              )
+            : 0n,
+          formattedBalance: userBalance.toString(),
+          address: token.address,
+          usdValue:
+            Number.isNaN(price) || !userBalance
+              ? undefined
+              : Number.parseFloat(userBalance.toString()) * price,
+        };
+      }),
+      stakedBalance: userVaultTokenBalance?.address
+        ? {
+            address: userVaultTokenBalance.address,
+            balance: userVaultTokenBalance.balance,
+            // Pools always use the 18 decimals
+            formattedBalance: formatEther(userVaultTokenBalance.balance),
+            usdValue:
+              Number(formatEther(userVaultTokenBalance.balance)) * lpTokenPrice,
+          }
+        : undefined,
+    },
+    ...rest,
+    refresh: () => {
+      rest.refresh?.();
+      refreshVaultDeposit();
+    },
+  };
+};

package/src/hooks/dex/useMultipleTokenApprovalsWithSlippage.ts

@@ -0,0 +1,92 @@
+"use client";
+
+import { useMemo } from "react";
+import { ZERO_ADDRESS } from "@berachain-foundation/berancer-sdk";
+import BigNumber from "bignumber.js";
+import { type Address, isAddressEqual, parseUnits } from "viem";
+
+import { BeraError } from "~/errors/BeraError";
+import { usePollAllowances } from "~/hooks/tokens/usePollAllowances";
+import type { AllowanceToken, TokenInput } from "~/types";
+
+type NeedsApprovalToken = AllowanceToken & {
+  maxAmountIn: bigint;
+};
+
+function calculateMaxAmountIn({
+  amount,
+  decimals,
+  slippage,
+}: {
+  amount: string;
+  decimals: number;
+  slippage: number | undefined;
+}) {
+  const amountInWei = parseUnits(amount, decimals);
+  const slippageInWei = parseUnits((slippage ?? 0).toString(), decimals);
+  return (
+    amountInWei + (amountInWei * slippageInWei) / BigInt(100 * 10 ** decimals)
+  );
+}
+
+export const useMultipleTokenApprovalsWithSlippage = (
+  tokenInput: TokenInput[],
+  spender: Address | undefined,
+  slippage?: number,
+) => {
+  const tokens = useMemo(
+    () =>
+      tokenInput
+        .filter((token) => token.address !== ZERO_ADDRESS)
+        .filter((token: TokenInput) => token !== undefined)
+        .filter((token) => BigNumber(token.amount).gt(0)),
+    [tokenInput],
+  );
+
+  const {
+    data: allowances,
+    refresh,
+    isLoading,
+  } = usePollAllowances({
+    spender: spender,
+    tokens,
+  });
+
+  const needsApproval = useMemo<NeedsApprovalToken[]>(
+    () =>
+      allowances
+        ?.map<NeedsApprovalToken | undefined>((allowance) => {
+          const token = tokens.find((token: TokenInput) =>
+            isAddressEqual(token.address, allowance.address),
+          );
+
+          if (!token) {
+            // Since we're checking the allowances, the tokens should be present
+            throw new BeraError({
+              message:
+                "Token not found when matching allowance in useMultipleTokenApprovalsWithSlippage",
+              cause: {
+                allowance,
+                tokens,
+              },
+            });
+          }
+
+          const maxAmountIn = calculateMaxAmountIn({ ...token, slippage });
+
+          if (allowance.allowance === 0n || allowance.allowance < maxAmountIn) {
+            return { ...allowance, maxAmountIn };
+          }
+
+          return undefined;
+        })
+        .filter((token) => token !== undefined) ?? [],
+    [allowances, slippage, tokens],
+  );
+
+  return {
+    needsApproval,
+    refresh,
+    isLoading,
+  };
+};

package/src/hooks/dex/useOnChainPoolData.ts

@@ -0,0 +1,126 @@
+import { useMemo } from "react";
+import useSWRImmutable from "swr/immutable";
+import { type Address, formatUnits, isAddress } from "viem";
+
+import type { SubgraphPoolFragment } from "@berachain/graphql/dex/subgraph";
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getOnChainPool } from "~/actions/dex/getOnChainPool";
+import { useMultipleTokenInformation } from "~/hooks/tokens/useMultipleTokenInformation";
+import { useTokenCurrentPrices } from "~/hooks/tokens/useTokenCurrentPrices";
+
+export function useOnChainPoolDataQueryKey(
+  args: { poolId: string } | { address: Address },
+) {
+  const address = "poolId" in args ? args.poolId?.slice(0, 42) : args.address;
+
+  const isAddressValid = isAddress(address);
+
+  const isValid = isAddressValid;
+
+  return isValid && address ? (["useOnChainPoolData", address] as const) : null;
+}
+
+export interface OnChainPoolFragment extends SubgraphPoolFragment {
+  // Reference: https://github.com/balancer/docs-developers/blob/main/references/valuing-balancer-lp-tokens/pools/stablepools.md#getamplificationparameter
+  amplificationParameter:
+    | {
+        currentFormattedValue: number | undefined;
+      }
+    | undefined;
+}
+
+export function useOnChainPoolData(poolId: string) {
+  const publicClient = usePublicClient();
+
+  const address = poolId?.slice(0, 42) as Address;
+
+  const QUERY_KEY = useOnChainPoolDataQueryKey({ poolId });
+  const {
+    data: poolData,
+    error,
+    isLoading,
+    mutate,
+  } = useSWRImmutable(
+    // FIXME: why are we using useSWRImmutable when we fetch tokenSupply and swapFee?
+    publicClient ? QUERY_KEY : null,
+    async ([, poolId]) => {
+      return getOnChainPool({
+        poolId,
+        // @ts-expect-error viem types
+        publicClient,
+      });
+    },
+  );
+
+  const { data: tokenInformation, isLoading: isTokenInformationLoading } =
+    useMultipleTokenInformation({
+      addresses: poolData?.poolTokens[0],
+    });
+
+  const { data: tokenPrices, isLoading: isTokenPricesLoading } =
+    useTokenCurrentPrices({
+      addressIn: poolData?.poolTokens[0],
+    });
+
+  const pool = useMemo(() => {
+    if (!poolData || !tokenInformation) {
+      return undefined;
+    }
+
+    const pool: OnChainPoolFragment = {
+      address: address.toLowerCase() as Address,
+      id: poolId.toLowerCase() as string,
+      type: poolData.type,
+      factory: poolData.factory,
+      totalShares: poolData.totalSupply,
+      totalLiquidity: "0", // overwritten below
+      swapFee: poolData.swapFee,
+      createTime: 0,
+      name: poolData.name,
+      tokens: tokenInformation.map((token, idx) => ({
+        address: token.address.toLowerCase() as Address,
+        name: token.name,
+        decimals: token.decimals,
+        symbol: token.symbol,
+        index: idx,
+        weight: poolData.weights?.[idx] ?? undefined,
+        balance: formatUnits(
+          BigInt(poolData.poolTokens[1][idx]),
+          token.decimals,
+        ),
+        token: {
+          __typename: "Token",
+          token,
+          latestUSDPrice: tokenPrices?.[token.address],
+        },
+      })),
+      amplificationParameter: poolData?.amplificationParameter && {
+        // For example, if value is 300000n and precision is 1000n, the user-set amplification parameter would be 300000n / 1000n = 300n.
+        currentFormattedValue:
+          Number(poolData.amplificationParameter[0]) /
+          Number(poolData.amplificationParameter[2]),
+      },
+    };
+
+    const totalLiquidity = pool.tokens?.reduce((acc, token) => {
+      const tokenUSDPrice = Number(
+        tokenPrices?.[token.address.toLowerCase()]?.price ?? 0,
+      );
+      if (!tokenUSDPrice) return acc;
+      return acc + tokenUSDPrice * Number(token.balance);
+    }, 0);
+
+    pool.totalLiquidity = totalLiquidity?.toString() ?? "";
+
+    return pool;
+  }, [poolData, tokenInformation, tokenPrices, address, poolId]);
+
+  return {
+    data: pool,
+    error,
+    isLoading: isLoading || isTokenInformationLoading || isTokenPricesLoading,
+    mutate,
+    refresh: () => mutate(),
+  };
+}

package/src/hooks/dex/usePollPoolCreationRelayerApproval.ts

@@ -0,0 +1,54 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { balancerVaultAbi } from "~/abi/bex/balancerVault";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Hook for fetching relayer approval status with SWR
+ *
+ * @returns SWR data spread and refresh function
+ */
+export const usePollPoolCreationRelayerApproval = (
+  options?: DefaultHookOptions,
+) => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    account && publicClient
+      ? ([
+          "usePollPoolCreationRelayerApproval",
+          account,
+          publicClient.chain.id,
+        ] as const)
+      : null;
+
+  const swrResponse = useSWR<boolean>(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+
+      const { config } = parseBaseArgs({ chainId: publicClient.chain.id });
+      const approved = await publicClient.readContract({
+        address: config.bex.vault,
+        abi: balancerVaultAbi,
+        functionName: "hasApprovedRelayer",
+        args: [account as Address, config.bex.poolCreationHelper],
+      });
+
+      return approved;
+    },
+    { ...options?.opts },
+  );
+
+  const refreshPoolCreationApproval = () => {
+    swrResponse.mutate();
+  };
+
+  return { ...swrResponse, refreshPoolCreationApproval };
+};

package/src/hooks/dex/usePollVaultIsPaused.ts

@@ -0,0 +1,30 @@
+import useSWR from "swr";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getVaultPausedState } from "~/actions/dex/getVaultPausedState";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types/global";
+
+// Determine if a Vault status is paused or not NOTE: there is no recovery mode for vaults.
+export function usePollVaultIsPaused(options?: DefaultHookOptions) {
+  const publicClient = usePublicClient();
+
+  const swrResponse = useSWR(
+    publicClient ? ["usePollVaultIsPaused"] : null,
+    async () => {
+      assertPublicClient(publicClient);
+
+      return getVaultPausedState({ publicClient });
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
+    },
+  );
+
+  return {
+    ...swrResponse,
+  };
+}

package/src/hooks/dex/usePool.ts

@@ -0,0 +1,59 @@
+import { useMemo } from "react";
+import useSWR from "swr";
+import type { Hex } from "viem";
+
+import { getSubgraphPool } from "~/actions/dex/getSubgraphPool";
+import { POLLING } from "~/enum/polling";
+import { useApiPool } from "./useApiPool";
+import { useOnChainPoolData } from "./useOnChainPoolData";
+
+export function useSubgraphPoolQueryKey({ poolId }: { poolId: string }) {
+  return poolId ? ["usePool-subgraph", poolId] : null;
+}
+
+export const usePool = ({ poolId }: { poolId: Hex }) => {
+  const bexSubgraphPool = useSWR(
+    useSubgraphPoolQueryKey({ poolId }),
+    async ([, poolId]) => getSubgraphPool({ poolId }),
+    {
+      refreshInterval: POLLING.NORMAL,
+    },
+  );
+
+  const balancerApiPool = useApiPool({ poolId });
+
+  const {
+    data: onChainPool,
+    isLoading: isOnChainPoolLoading,
+    refresh: refreshOnChainPool,
+  } = useOnChainPoolData(poolId);
+
+  const pool = useMemo(() => {
+    // Until we load the data from the subgraph we'll push up the on-chain data.
+    if (!bexSubgraphPool.data) return onChainPool;
+
+    const merge = { ...bexSubgraphPool.data };
+
+    if (onChainPool) {
+      merge.swapFee = onChainPool.swapFee;
+      merge.totalShares = onChainPool.totalShares;
+      merge.createTime = onChainPool.createTime ?? merge.createTime;
+    }
+
+    return merge;
+  }, [onChainPool, bexSubgraphPool]);
+
+  return {
+    data: [pool, balancerApiPool.data, onChainPool] as const,
+    isLoading:
+      balancerApiPool.isLoading ||
+      bexSubgraphPool.isLoading ||
+      isOnChainPoolLoading,
+    isError: balancerApiPool.error || bexSubgraphPool.error,
+    refresh: () => {
+      balancerApiPool.refresh();
+      bexSubgraphPool.mutate();
+      refreshOnChainPool();
+    },
+  };
+};

package/src/hooks/dex/usePoolEvents.ts

@@ -0,0 +1,22 @@
+import useSWRImmutable from "swr/immutable";
+
+import type { GqlPoolEventType } from "@berachain/graphql/dex/api";
+
+import { getPoolEvents } from "~/actions/dex/getPoolEvents";
+import { POLLING } from "~/enum";
+
+export const usePoolEvents = ({
+  poolId,
+  typeInArray,
+}: {
+  poolId: string | undefined;
+  typeInArray: GqlPoolEventType[];
+}) => {
+  return useSWRImmutable(
+    poolId ? (["usePoolEvents", poolId, typeInArray] as const) : null,
+    async ([, poolId, typeInArray]) => getPoolEvents({ poolId, typeInArray }),
+    {
+      refreshInterval: POLLING.SLOW,
+    },
+  );
+};

package/src/hooks/dex/usePoolHistoricalData.ts

@@ -0,0 +1,44 @@
+import useSWR from "swr";
+
+import type {
+  GqlChain,
+  PoolHistoricalDataFragment,
+} from "@berachain/graphql/dex/api";
+
+import { getPoolHistoricalData } from "~/actions/dex/getPoolHistoricalData";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+type UsePoolHistoricalDataArgs = {
+  poolId: string | undefined;
+};
+
+export const usePoolHistoricalData = (
+  { poolId, ...baseArgs }: UsePoolHistoricalDataArgs & BeraJS.BaseFunctionArgs,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<PoolHistoricalDataFragment[] | undefined> => {
+  const { config } = parseBaseArgs(baseArgs);
+  const QUERY_KEY = poolId
+    ? (["usePoolHistoricalData", poolId] as const)
+    : null;
+
+  const swrResponse = useSWR<
+    PoolHistoricalDataFragment[] | undefined,
+    any,
+    typeof QUERY_KEY
+  >(
+    QUERY_KEY,
+    async ([, poolId]) => {
+      return await getPoolHistoricalData({
+        poolId,
+        chain: config.bex.chainName as GqlChain,
+      });
+    },
+    options?.opts,
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => void swrResponse.mutate(),
+  };
+};

package/src/hooks/dex/usePools.ts

@@ -0,0 +1,83 @@
+import { useMemo } from "react";
+import useSWR from "swr";
+
+import type { GetPoolsQueryVariables } from "@berachain/graphql/dex/api";
+import { useBeraWallet } from "@berachain/wagmi/hooks";
+
+import { getAllPools } from "~/actions/dex/getAllPools";
+import { POLLING } from "~/enum/polling";
+import type { DefaultHookOptions } from "~/types";
+import { useAllUserPools } from "./useAllUserPools";
+
+export const usePoolsQueryKey = ({
+  query,
+}: {
+  query?: GetPoolsQueryVariables;
+} = {}) => {
+  return ["useAllPools", query];
+};
+/**
+ * Returns all pools from bex api, including user's pools if logged in
+ * @todo add subgraph fallback
+ */
+export const usePools = (
+  query: GetPoolsQueryVariables,
+  options?: DefaultHookOptions,
+) => {
+  const { address: account } = useBeraWallet();
+  const {
+    data: userPools,
+    isLoading: isUserPoolsLoading,
+    mutate: mutateUserPools,
+  } = useAllUserPools({
+    userAddress: account,
+    chain: query.chain,
+  });
+
+  const {
+    data: pools,
+    isLoading: isPoolsLoading,
+    mutate: mutatePools,
+  } = useSWR(
+    usePoolsQueryKey({ query }),
+    async ([_, query]) => {
+      return getAllPools(query as GetPoolsQueryVariables);
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+      ...options?.opts,
+    },
+  );
+
+  const mergedPools = useMemo(() => {
+    if (!pools || !userPools?.pools?.length) return pools?.pools ?? [];
+    const userPoolsById = Object.fromEntries(
+      userPools.pools.map((pool) => [pool.id.toLowerCase(), pool]),
+    );
+    return pools.pools
+      .map((pool) => ({
+        ...pool,
+        ...(userPoolsById[pool.id.toLowerCase()] || {}),
+      }))
+      .filter(Boolean);
+  }, [pools, userPools]);
+
+  const pagination = useMemo(() => {
+    return {
+      page: Math.ceil((query?.skip ?? 0) / (query?.first ?? 10)),
+      pageSize: query?.first,
+      count: Math.ceil((pools?.count ?? 0) / (query?.first ?? 10)),
+    };
+  }, [pools, query.skip, query.first]);
+
+  return {
+    pools: mergedPools ?? [],
+    walletPools: pools?.pools ?? [],
+    isLoading: isPoolsLoading || isUserPoolsLoading,
+    refresh: () => {
+      mutatePools();
+      mutateUserPools();
+    },
+    pagination,
+  };
+};