@berachain/berajs 0.1.0 → 0.1.2

package/src/hooks/perps/usePythUpdateFee.ts

@@ -0,0 +1,43 @@
+import useSWRImmutable from "swr/immutable";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getPythUpdateFee } from "~/actions/pyth/getUpdateFee";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types/global";
+import { getPythDefaultUpdateFee } from "~/utils/pythHoneyUtils";
+
+export const usePythUpdateFee = (
+  {
+    pythPriceFeedCalldata,
+    tokenListLength,
+  }: {
+    pythPriceFeedCalldata: Address[] | undefined;
+    tokenListLength: number;
+  },
+  options?: DefaultHookOptions,
+) => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    (options?.opts?.isEnabled ?? true) &&
+    pythPriceFeedCalldata &&
+    pythPriceFeedCalldata.length > 0
+      ? (["usePythUpdateFee", pythPriceFeedCalldata] as const)
+      : null;
+  const { data = getPythDefaultUpdateFee(tokenListLength), isLoading } =
+    useSWRImmutable(QUERY_KEY, async ([_, pythPriceFeedCalldata]) => {
+      assertPublicClient(publicClient);
+
+      return await getPythUpdateFee({
+        client: publicClient,
+        priceFeedId: pythPriceFeedCalldata,
+      });
+    });
+
+  return {
+    QUERY_KEY,
+    data,
+    isLoading,
+  };
+};

package/src/hooks/pol/useBgtAprSimulation.ts

@@ -0,0 +1,22 @@
+import { useMemo } from "react";
+
+import {
+  type GetBgtAprSimulationArgs,
+  type GetBgtAprSimulationResult,
+  getBgtAprSimulation,
+} from "~/actions/pol/getBgtAprSimulation";
+
+export function useBgtAprSimulation(args: GetBgtAprSimulationArgs | undefined):
+  | GetBgtAprSimulationResult
+  /**
+   * Returns undefined if still loading
+   */
+  | undefined {
+  return useMemo(() => {
+    if (!args) {
+      return undefined;
+    }
+
+    return getBgtAprSimulation(args);
+  }, [args]);
+}

package/src/hooks/pol/useBgtUnstakedBalance.ts

@@ -0,0 +1,50 @@
+import useSWR from "swr";
+import { formatEther } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { bgtAbi } from "~/abi/pol/bgt";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+// TODO: REFACTOR ON REDEPLOY
+export const useBgtUnstakedBalance = (
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<string | undefined> => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    account && publicClient
+      ? (["useBgtUnstakedBalance", account] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+
+      const { config } = parseBaseArgs({
+        chainId: publicClient.chain.id,
+      });
+
+      const bgtBalance = await publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "unboostedBalanceOf",
+        args: [account],
+      });
+      return formatEther(bgtBalance);
+    },
+    {
+      ...options,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useClaimableFees.ts

@@ -0,0 +1,38 @@
+import useSWR from "swr";
+import { formatUnits } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getUserVaultsReward } from "~/actions/pol/getUserVaultsReward";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useClaimableFees = () => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    account && publicClient ? (["useClaimableFees", account] as const) : null;
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+      const { config } = parseBaseArgs({
+        chainId: publicClient.chain.id,
+      });
+      const vaultReward = await getUserVaultsReward({
+        account,
+        vaultAddress: config.pol.staker,
+        publicClient,
+      });
+      return formatUnits(vaultReward, 18);
+    },
+    {
+      refreshInterval: POLLING.SLOW * 2,
+    },
+  );
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/pol/useEarnedStakedBeraVault.ts

@@ -0,0 +1,59 @@
+import useSWR from "swr";
+
+import {
+  GetStakeBeraVaultEarningsByOwner,
+  type GetStakeBeraVaultEarningsByOwnerQuery,
+  type GetStakeBeraVaultEarningsByOwnerQueryVariables,
+} from "@berachain/graphql/pol/api";
+import { useBeraWallet } from "@berachain/wagmi/hooks";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { POLLING } from "~/enum/polling";
+import type {
+  DefaultHookOptions,
+  DefaultHookReturnType,
+  TokenWithMetadata,
+} from "~/types";
+
+type UseEarnedStakedBeraVaultArgs = {
+  /**
+   * The token that the user has staked
+   */
+  receiptToken: TokenWithMetadata;
+};
+export function useEarnedStakedBeraVault(
+  { receiptToken }: UseEarnedStakedBeraVaultArgs,
+  opt?: DefaultHookOptions,
+): DefaultHookReturnType<string> {
+  const { address: account } = useBeraWallet();
+
+  const QUERY_KEY =
+    receiptToken.address && account
+      ? (["useEarnedStakedBeraVault", receiptToken.address, account] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([_, , account]) => {
+      const bexApiGraphqlClient = getApolloClient("api", {});
+      const response = await bexApiGraphqlClient.query<
+        GetStakeBeraVaultEarningsByOwnerQuery,
+        GetStakeBeraVaultEarningsByOwnerQueryVariables
+      >({
+        query: GetStakeBeraVaultEarningsByOwner,
+        variables: {
+          owner: account,
+        },
+      });
+      return response.data?.polGetStakeBeraVaultEarningsByOwner?.earnings;
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+      ...opt?.opts,
+    },
+  );
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate,
+  };
+}

package/src/hooks/pol/useHighestVaultsAPR.ts

@@ -0,0 +1,57 @@
+import type { GqlRewardVaultDynamicData } from "@berachain/graphql/dex/api";
+import {
+  type GqlRewardVaultFilter,
+  GqlRewardVaultOrderBy,
+  GqlRewardVaultOrderDirection,
+} from "@berachain/graphql/pol/api";
+
+import { useRewardVaults } from "./useRewardVaults";
+
+/**
+ * Hook that fetches and returns the highest APR (Annual Percentage Rate) from reward vaults.
+ *
+ * @param {`0x${string}`[]} [params.filteringVaults=[]] - Optional array of vault addresses to filter by
+ *
+ * @returns {Object} An object containing:
+ *   - highestApr: The highest APR value from the reward vaults
+ *   - refresh: Function to manually refresh the data
+ *   - ...swrResponse: All properties from the underlying SWR response
+ *
+ * @example
+ * const { highestApr } = useHighestVaultsAPR({
+ *   filteringVaults: ['0x123...', '0x456...']
+ * });
+ */
+export const useHighestVaultsAPR = (
+  where: GqlRewardVaultFilter = {},
+  { isEnabled = true }: { isEnabled?: boolean } = {},
+): {
+  highestApr: GqlRewardVaultDynamicData["apr"] | undefined;
+  isLoading: boolean;
+  refresh: () => void;
+} => {
+  const swrResponse = useRewardVaults(
+    {
+      filter: {
+        orderBy: GqlRewardVaultOrderBy.Apr,
+        orderDirection: GqlRewardVaultOrderDirection.Desc,
+        pageSize: 1,
+        where,
+      },
+    },
+    {
+      opts: {
+        refreshInterval: 0,
+        revalidateOnFocus: false,
+        refreshWhenOffline: false,
+        isEnabled,
+      },
+    },
+  );
+
+  return {
+    isLoading: swrResponse.isLoading,
+    highestApr: swrResponse.data?.gaugeList[0].dynamicData?.apr,
+    refresh: swrResponse.mutate,
+  };
+};

package/src/hooks/pol/useOnChainRewardVault.ts

@@ -0,0 +1,114 @@
+import useSWR from "swr";
+import { type Address, erc20Abi, formatUnits, isAddress } from "viem";
+
+import type { ApiVaultFragment } from "@berachain/graphql/pol/api";
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { getRewardVaultIncentives } from "~/actions/pol/getRewardVaultIncentives";
+import { getRewardVaultStakingToken } from "~/actions/pol/getRewardVaultStakingToken";
+import { getStakingTokenInformation } from "~/actions/pol/getStakingTokenInformation";
+import { getTokenInformation } from "~/actions/tokens/getTokenInformation";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useOnChainRewardVaultQueryKey = (address: Address | undefined) =>
+  address && isAddress(address)
+    ? (["onChainRewardVault", address.toLowerCase() as Address] as const)
+    : null;
+
+export const useOnChainRewardVault = (
+  {
+    address,
+  }: {
+    address: Address | undefined;
+  },
+  opt: DefaultHookOptions,
+) => {
+  const publicClient = usePublicClient();
+  const isEnabled = opt.opts?.isEnabled ?? true;
+
+  const QUERY_KEY = useOnChainRewardVaultQueryKey(address);
+
+  return useSWR<
+    ApiVaultFragment,
+    unknown,
+    ReturnType<typeof useOnChainRewardVaultQueryKey>
+  >(isEnabled && publicClient ? QUERY_KEY : null, async ([, address]) => {
+    assertPublicClient(publicClient);
+    const { config } = parseBaseArgs({
+      chainId: publicClient.chain.id,
+    });
+
+    const stakingTokenAddress = await getRewardVaultStakingToken({
+      address,
+      publicClient: publicClient,
+    });
+
+    const [incentives, isWhitelisted, stakingTokenAmount] = await Promise.all([
+      getRewardVaultIncentives({
+        address,
+        stakingToken: stakingTokenAddress,
+        publicClient,
+      }),
+      publicClient.readContract({
+        address: config.pol.beraChef,
+        abi: beraChefAbi,
+        functionName: "isWhitelistedVault",
+        args: [address],
+      }),
+      publicClient.readContract({
+        address: stakingTokenAddress,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+      }),
+    ]);
+
+    const [stakingToken, incentiveTokens] = await Promise.all([
+      getStakingTokenInformation({
+        address: stakingTokenAddress,
+        publicClient: publicClient,
+      }),
+      Promise.all(
+        incentives.map((add) =>
+          getTokenInformation({
+            address: add.token,
+            publicClient: publicClient,
+          }),
+        ),
+      ),
+    ]);
+
+    if (!stakingToken) {
+      throw new Error("Staking token not found");
+    }
+
+    return {
+      id: address,
+      address,
+      vaultAddress: address,
+      stakingToken: {
+        address: stakingTokenAddress,
+        name: stakingToken.name ?? "",
+        symbol: stakingToken.symbol ?? "",
+        decimals: stakingToken.decimals ?? 0,
+      },
+      stakingTokenAmount: formatUnits(
+        stakingTokenAmount,
+        stakingToken.decimals ?? 18,
+      ),
+      isVaultWhitelisted: isWhitelisted,
+      activeIncentives: incentives.map((incentive, idx) => ({
+        active: !!incentive.remainingAmount,
+        remainingAmount: incentive.remainingAmount,
+        remainingAmountUsd: "0",
+        incentiveRate: incentive.incentiveRate,
+        incentiveRateUsd: "0",
+        tokenAddress: incentive.token,
+        token: incentiveTokens[idx]!,
+      })),
+    } satisfies ApiVaultFragment;
+  });
+};

package/src/hooks/pol/usePollGlobalData.ts

@@ -0,0 +1,31 @@
+import useSWR from "swr";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { type GlobalData, getGlobalData } from "~/actions/pol/getGlobalData";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export const usePollGlobalData = (
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<GlobalData> => {
+  const publicClient = usePublicClient();
+
+  const swrResponse = useSWR<GlobalData>(
+    publicClient ? "usePollGlobalData" : null,
+    async () => {
+      assertPublicClient(publicClient);
+
+      return getGlobalData(publicClient);
+    },
+    {
+      revalidateOnFocus: false,
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate,
+  };
+};

package/src/hooks/pol/usePollMarkets.ts

@@ -0,0 +1,32 @@
+import useSWRImmutable from "swr/immutable";
+
+import { type GetMarkets, getMarkets } from "~/actions/pol/getMarkets";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export interface UsePollMarketsResponse
+  extends DefaultHookReturnType<GetMarkets> {}
+
+export const usePollMarketsQueryKey = () => {
+  return "usePollMarkets";
+};
+
+export const usePollMarkets = (
+  options?: DefaultHookOptions,
+): UsePollMarketsResponse => {
+  const QUERY_KEY = usePollMarketsQueryKey();
+  const swrResponse = useSWRImmutable<GetMarkets, any, typeof QUERY_KEY>(
+    QUERY_KEY,
+    async () => {
+      const res = await getMarkets();
+      return res;
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useQueuedBeraUnlock.ts

@@ -0,0 +1,70 @@
+import useSWRImmutable from "swr/immutable";
+import { type Address, isAddress } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import {
+  getSWBeraWithdrawal,
+  type StakedBeraWithdrawal,
+} from "~/actions/pol/getSWBeraWithdrawal";
+import { POLLING } from "~/enum";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types";
+
+export function useQueuedBeraUnlock(
+  {
+    receiptTokenAddress,
+    account,
+    version,
+  }: {
+    receiptTokenAddress?: Address | string;
+    account?: Address | string;
+    version: "V1" | "V2";
+  },
+  options?: DefaultHookOptions,
+) {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    receiptTokenAddress &&
+    isAddress(receiptTokenAddress) &&
+    account &&
+    publicClient &&
+    isAddress(account) &&
+    version
+      ? ([
+          "useQueuedBeraUnlock",
+          receiptTokenAddress,
+          account,
+          version,
+        ] as const)
+      : null;
+
+  const swrResponse = useSWRImmutable<
+    StakedBeraWithdrawal[],
+    any,
+    typeof QUERY_KEY
+  >(
+    QUERY_KEY,
+    async ([, receiptTokenAddress, account, version]) => {
+      assertPublicClient(publicClient);
+
+      const unlock = await getSWBeraWithdrawal(
+        receiptTokenAddress,
+        account,
+        publicClient,
+        version,
+      );
+      return unlock;
+    },
+    {
+      refreshInterval: POLLING.FAST,
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+}

package/src/hooks/pol/useRewardTokenToBeraRate.ts

@@ -0,0 +1,45 @@
+import useSWR from "swr";
+import { type Address, isAddress } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getRewardTokenToBeraRate } from "~/actions/pol/getRewardTokenToBeraRate";
+import { assertPublicClient, InvalidArgumentError } from "~/errors";
+import type { DefaultHookOptions } from "~/types";
+
+export const useRewardTokenToBeraRate = (
+  {
+    address,
+  }: {
+    address: Address | undefined;
+  },
+  opt?: DefaultHookOptions,
+) => {
+  const QUERY_KEY = address
+    ? (["useRewardTokenToBeraRate", address] as const)
+    : null;
+  const publicClient = usePublicClient();
+
+  return useSWR(
+    QUERY_KEY,
+    async ([_, address]) => {
+      if (!address || !isAddress(address)) {
+        throw new InvalidArgumentError({
+          property: "address",
+          value: address,
+          expected: "Address",
+        });
+      }
+
+      assertPublicClient(publicClient);
+
+      return getRewardTokenToBeraRate({
+        address: address as `0x${string}`,
+        publicClient,
+      });
+    },
+    {
+      ...opt?.opts,
+    },
+  );
+};

package/src/hooks/pol/useRewardVault.ts

@@ -0,0 +1,51 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import type { ApiVaultFragment } from "@berachain/graphql/pol/api";
+
+import { getRewardVault } from "~/actions/pol/getRewardVault";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import { useOnChainRewardVault } from "./useOnChainRewardVault";
+
+export interface UseRewardVaultResponse
+  extends DefaultHookReturnType<ApiVaultFragment> {}
+
+export const useRewardVaultQueryKey = (address: Address | undefined) =>
+  address
+    ? (["useRewardVault", address.toLowerCase() as Address] as const)
+    : null;
+
+export const useRewardVault = (
+  id: Address | undefined,
+  options?: DefaultHookOptions,
+): UseRewardVaultResponse => {
+  const QUERY_KEY = useRewardVaultQueryKey(id);
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([_, id]) => getRewardVault({ address: id }),
+    {
+      ...options?.opts,
+    },
+  );
+
+  const isOnChainEnabled =
+    options?.opts?.isEnabled ??
+    ((!!swrResponse.error || !swrResponse.isLoading) && !swrResponse.data);
+
+  const onChainRewardVault = useOnChainRewardVault(
+    { address: id },
+    { opts: { ...options?.opts, isEnabled: isOnChainEnabled } },
+  );
+
+  return {
+    data: onChainRewardVault.data ?? swrResponse.data,
+    error: onChainRewardVault.error ?? swrResponse.error,
+    isLoading: onChainRewardVault.isLoading || swrResponse.isLoading,
+    isValidating: onChainRewardVault.isValidating ?? swrResponse.isValidating,
+    refresh: () => {
+      swrResponse.mutate();
+      onChainRewardVault.mutate();
+    },
+  };
+};