@berachain/berajs 0.1.1 → 0.1.2

package/src/hooks/pol/useRewardVaultBalanceFromStakingToken.ts

@@ -0,0 +1,82 @@
+import useSWR from "swr";
+import { type Address, isAddress, zeroAddress } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types/global";
+import { useRewardVaultFromToken } from "./useRewardVaultFromToken";
+
+// NOTE: this is entirely on-chain
+export const useRewardVaultBalanceFromStakingToken = (
+  {
+    stakingToken,
+    rewardVaultAddress: _rewardVaultAddress,
+  }: {
+    stakingToken: Address | undefined;
+    rewardVaultAddress?: Address;
+  },
+  options?: DefaultHookOptions,
+) => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+
+  const isEnabled = options?.opts?.isEnabled ?? true;
+  const {
+    data: rewardVaultAddress = _rewardVaultAddress,
+    error,
+    mutate: mutateRewardVaultAddress,
+    isLoading: isLoadingRewardVaultAddress,
+  } = useRewardVaultFromToken(
+    {
+      tokenAddress: stakingToken,
+    },
+    {
+      isEnabled: !_rewardVaultAddress && isEnabled,
+    },
+  );
+
+  const swrResponse = useSWR(
+    rewardVaultAddress &&
+      account &&
+      publicClient &&
+      isAddress(rewardVaultAddress) &&
+      isAddress(account) &&
+      isEnabled
+      ? ["useVaultBalanceFromStakingToken", rewardVaultAddress, account]
+      : null,
+
+    async ([, rewardVaultAddress, account]) => {
+      assertPublicClient(publicClient);
+
+      if (rewardVaultAddress === zeroAddress) {
+        return {
+          address: rewardVaultAddress,
+          balance: 0n,
+        };
+      }
+
+      const balance = await publicClient.readContract({
+        address: rewardVaultAddress,
+        abi: rewardVaultAbi,
+        functionName: "balanceOf",
+        args: [account],
+      });
+
+      return {
+        address: rewardVaultAddress,
+        balance: balance,
+      };
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => {
+      mutateRewardVaultAddress();
+      swrResponse.mutate();
+    },
+    isLoading: swrResponse.isLoading || isLoadingRewardVaultAddress,
+  };
+};

package/src/hooks/pol/useRewardVaultFromToken.ts

@@ -0,0 +1,58 @@
+import useSWRImmutable from "swr/immutable";
+import { type Address, isAddress, zeroAddress } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { rewardVaultFactoryAbi } from "~/abi/pol/rewardVaultFactory";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useRewardVaultFromToken = (
+  {
+    tokenAddress,
+  }: {
+    tokenAddress: Address | string | undefined;
+  },
+  {
+    isEnabled = true,
+  }: {
+    isEnabled?: boolean;
+  } = {},
+) => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY: readonly [string, Address] | null =
+    publicClient && tokenAddress && isAddress(tokenAddress) && isEnabled
+      ? ["useRewardVaultFromToken", tokenAddress]
+      : null;
+
+  const swrResponse = useSWRImmutable<
+    Address | undefined,
+    any,
+    typeof QUERY_KEY
+  >(QUERY_KEY, async ([, tokenAddress]) => {
+    if (!tokenAddress) {
+      throw new Error("useRewardVaultFromToken needs a valid token address");
+    }
+
+    assertPublicClient(publicClient);
+
+    const { config } = parseBaseArgs({
+      chainId: publicClient.chain.id,
+    });
+
+    const res = await publicClient.readContract({
+      address: config.pol.factory,
+      abi: rewardVaultFactoryAbi,
+      functionName: "getVault",
+      args: [tokenAddress],
+    });
+
+    return res === zeroAddress ? undefined : res;
+  });
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useRewardVaultIncentives.ts

@@ -0,0 +1,37 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getRewardVaultIncentives } from "~/actions/pol/getRewardVaultIncentives";
+import { assertPublicClient } from "~/errors/assert";
+
+export function useRewardVaultIncentives({
+  address,
+  stakingToken,
+}: {
+  address: Address | undefined;
+  stakingToken: Address | undefined;
+}) {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    publicClient && address && stakingToken
+      ? (["useRewardVaultIncentives", address, stakingToken] as const)
+      : null;
+
+  const swrResponse = useSWR(QUERY_KEY, async ([, address, stakingToken]) => {
+    assertPublicClient(publicClient);
+
+    return await getRewardVaultIncentives({
+      address,
+      stakingToken,
+      publicClient,
+    });
+  });
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+}

package/src/hooks/pol/useRewardVaultRewards.ts

@@ -0,0 +1,37 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getRewardVaultRewards } from "~/actions/pol/getRewardVaultRewards";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types/global";
+
+export const useRewardVaultRewards = (
+  address: Address,
+  options?: DefaultHookOptions,
+) => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    publicClient && address
+      ? (["useRewardVaultRewards", address] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, address]) => {
+      assertPublicClient(publicClient);
+
+      return await getRewardVaultRewards(address, publicClient);
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/pol/useRewardVaults.ts

@@ -0,0 +1,45 @@
+import useSWR from "swr";
+
+import type { GetVaultsQueryVariables } from "@berachain/graphql/pol/api";
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getRewardVaults } from "~/actions/pol/getRewardVaults";
+import type { DefaultHookOptions } from "~/types";
+
+export const useRewardVaultsQueryKey = (
+  filter?: GetVaultsQueryVariables,
+  onChainIncentives = false,
+) => {
+  return ["useRewardVaults", filter, onChainIncentives] as const;
+};
+
+export const useRewardVaults = (
+  args: {
+    filter?: GetVaultsQueryVariables;
+    onChainIncentives?: boolean;
+  },
+  options?: DefaultHookOptions,
+) => {
+  const QUERY_KEY = useRewardVaultsQueryKey(
+    args.filter,
+    args.onChainIncentives,
+  );
+  const publicClient = usePublicClient();
+  const swrResponse = useSWR(
+    (options?.opts?.isEnabled ?? true) ? QUERY_KEY : null,
+    async ([, filter, onChainIncentives]) => {
+      return await getRewardVaults({
+        filter: filter,
+        publicClient: onChainIncentives ? publicClient : undefined,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: swrResponse.mutate,
+  };
+};

package/src/hooks/pol/useStakedBeraSnapshots.ts

@@ -0,0 +1,27 @@
+import useSWR from "swr";
+
+import type { GetSWberaVaultSnapshotsQuery } from "@berachain/graphql/pol/api";
+
+import {
+  type GetStakedBeraSnapshotsArgs,
+  getStakedBeraSnapshots,
+} from "~/actions/pol/getStakedBeraSnapshots";
+import type { DefaultHookReturnType } from "~/types/global";
+
+export const useStakedBeraSnapshots = ({
+  range,
+}: GetStakedBeraSnapshotsArgs): DefaultHookReturnType<
+  GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]
+> => {
+  const QUERY_KEY = range ? (["useStakedBeraSnapshots", range] as const) : null;
+  const swrResponse = useSWR(QUERY_KEY, ([, range]) =>
+    getStakedBeraSnapshots({
+      range,
+    }),
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useUserVaultInfo.ts

@@ -0,0 +1,46 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getUserVaultInfo } from "~/actions/";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
+import type { UserVaultInfo } from "~/types/pol";
+
+export const useUserVaultInfo = (
+  args: {
+    vaultAddress: Address | undefined;
+  },
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<UserVaultInfo> => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    account && publicClient && args.vaultAddress
+      ? (["useUserVaultInfo", account, args.vaultAddress] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, account, vaultAddress]) => {
+      assertPublicClient(publicClient);
+
+      return getUserVaultInfo({
+        account,
+        vaultAddress,
+        publicClient,
+      });
+    },
+    {
+      ...options,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useUserVaults.ts

@@ -0,0 +1,40 @@
+import useSWR from "swr";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import {
+  type GetUserVaultsResponse,
+  getUserVaults,
+} from "~/actions/pol/getUserVaults";
+import { POLLING } from "~/enum/polling";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
+
+export const useUserVaults = (
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<GetUserVaultsResponse> => {
+  const { address: account } = useBeraWallet();
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    account && publicClient ? (["useUserVaults", account] as const) : null;
+  const swrResponse = useSWR<GetUserVaultsResponse, unknown, typeof QUERY_KEY>(
+    QUERY_KEY,
+    async ([, account]) => {
+      assertPublicClient(publicClient);
+
+      return await getUserVaults({
+        account,
+        publicClient,
+      });
+    },
+    {
+      ...options,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
+      keepPreviousData: true,
+    },
+  );
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/pol/useVaultAddress.ts

@@ -0,0 +1,31 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getRewardVaultStakingToken } from "~/actions/pol/getRewardVaultStakingToken";
+import { assertPublicClient } from "~/errors/assert";
+
+export interface RewardVault {
+  stakeToken: Address;
+  address: Address;
+}
+export const useVaultAddress = (vaultAddress: Address) => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    vaultAddress && publicClient
+      ? (["useVaultAddress", vaultAddress] as const)
+      : null;
+
+  return useSWR(QUERY_KEY, async ([, vaultAddress]) => {
+    assertPublicClient(publicClient);
+
+    const [stakeToken] = await Promise.all([
+      getRewardVaultStakingToken({
+        address: vaultAddress,
+        publicClient: publicClient,
+      }),
+    ]);
+    return { stakeToken, address: vaultAddress };
+  });
+};

package/src/hooks/pol/useVaultHistory.ts

@@ -0,0 +1,29 @@
+import useSWR from "swr";
+
+import type { GetVaultHistoryQuery } from "@berachain/graphql/pol/api";
+
+import {
+  type GetVaultHistoryArgs,
+  getVaultHistory,
+} from "~/actions/pol/getVaultHistory";
+import type { DefaultHookReturnType } from "~/types/global";
+
+export const useVaultHistory = ({
+  vault,
+  range,
+  resolution,
+}: GetVaultHistoryArgs): DefaultHookReturnType<
+  GetVaultHistoryQuery["polGetRewardVaultSnapshots"]
+> => {
+  const QUERY_KEY = vault
+    ? (["useVaultHistory", vault, range, resolution] as const)
+    : null;
+  const swrResponse = useSWR(QUERY_KEY, ([, vault, range, resolution]) =>
+    getVaultHistory({ vault, range, resolution }),
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/pol/useVaultValidators.ts

@@ -0,0 +1,33 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import type { ApiValidatorFragment } from "@berachain/graphql/pol/api";
+
+import { getVaultValidators } from "~/actions/pol/getVaultValidators";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export interface UsePollValidatorInfoResponse
+  extends DefaultHookReturnType<ApiValidatorFragment[] | undefined> {}
+
+export const useVaultValidators = (
+  id: Address,
+  options?: DefaultHookOptions,
+): UsePollValidatorInfoResponse => {
+  const QUERY_KEY = id ? (["useVaultValidators", id] as const) : null;
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, address]) => {
+      return await getVaultValidators({
+        address,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/tokens/useBeraCurrentPrice.ts

@@ -0,0 +1,12 @@
+import { zeroAddress } from "viem";
+
+import type { DefaultHookOptions } from "~/types/global";
+import { useTokenCurrentPrice } from "./useTokenCurrentPrice";
+
+/**
+ * Shorthand for `useTokenCurrentPrice` with the Bera token address.
+ * @returns
+ */
+export function useBeraCurrentPrice(opts?: DefaultHookOptions) {
+  return useTokenCurrentPrice({ address: zeroAddress }, opts);
+}

package/src/hooks/tokens/useMultipleTokenInformation.ts

@@ -0,0 +1,62 @@
+import useSWRImmutable from "swr/immutable";
+import { isAddress } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getTokenInformation } from "~/actions/tokens/getTokenInformation";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType, Token } from "~/types";
+
+export type UseMultipleTokenInformationResponse = DefaultHookReturnType<
+  Token[]
+>;
+
+export type useMultipleTokenInformationArgs = {
+  addresses: string[] | readonly string[] | undefined;
+};
+export const useMultipleTokenInformation = (
+  args: useMultipleTokenInformationArgs,
+  options?: DefaultHookOptions,
+): UseMultipleTokenInformationResponse => {
+  const publicClient = usePublicClient();
+
+  const QUERY_KEY =
+    publicClient && args.addresses
+      ? (["useMultipleTokenInformation", args.addresses] as const)
+      : null;
+
+  const swrResponse = useSWRImmutable<Token[], unknown, typeof QUERY_KEY>(
+    QUERY_KEY,
+    async ([, addresses]) => {
+      // We already checked for publicClient in the QUERY_KEY
+      // so we can safely assume that publicClient is defined
+      // but we need this for correct type inference
+      assertPublicClient(publicClient);
+
+      return Promise.all(
+        addresses.map(async (address) => {
+          if (!address || !isAddress(address, { strict: false })) {
+            throw new Error("Invalid address");
+          }
+
+          const tk = await getTokenInformation({
+            address: address,
+            publicClient,
+          });
+
+          if (!tk) {
+            throw new Error(`Token ${address} not found`);
+          }
+
+          return tk;
+        }),
+      );
+    },
+    { ...options?.opts },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};

package/src/hooks/tokens/usePollAllowances.ts

@@ -0,0 +1,60 @@
+import useSWR from "swr";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getAllowances } from "~/actions/tokens/getAllowances";
+import { POLLING } from "~/enum/polling";
+import type { Token } from "~/types";
+import type {
+  AllowanceToken,
+  DefaultHookOptions,
+  DefaultHookReturnType,
+} from "~/types/global";
+
+export type UsePollAllowancesArgs = {
+  spender: string | undefined;
+  tokens: Token[];
+};
+export interface UsePollAllowancesResponse
+  extends DefaultHookReturnType<AllowanceToken[] | undefined> {}
+
+/**
+ *
+ * @brief Allows the user to poll the allowances of a given token array.
+ *
+ * @param contract the address of the ERC20 token contract
+ * @param tokens   the list of tokens to poll allowances for
+ */
+export const usePollAllowances = (
+  args: UsePollAllowancesArgs,
+  options?: DefaultHookOptions,
+): UsePollAllowancesResponse => {
+  const publicClient = usePublicClient();
+  const { address: account } = useBeraWallet();
+  const QUERY_KEY =
+    publicClient && account && args?.tokens && args?.spender
+      ? (["usePollAllowances", account, args?.tokens, args?.spender] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, account, tokens, spender]) => {
+      return getAllowances({
+        tokens,
+        account,
+        spender,
+        publicClient,
+      });
+    },
+    {
+      ...options?.opts,
+      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
+    },
+  );
+
+  return {
+    ...swrResponse,
+
+    refresh: () => swrResponse?.mutate?.(),
+  };
+};