@berachain/berajs 0.1.2 → 0.2.0

package/src/hooks/tokens/useMultipleTokenInformation.ts

@@ -1,11 +1,14 @@
 import useSWRImmutable from "swr/immutable";
 import { isAddress } from "viem";
 
+import { defaultChainId } from "@berachain/config/internal";
+
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getTokenInformation } from "~/actions/tokens/getTokenInformation";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType, Token } from "~/types";
+import type { Token } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export type UseMultipleTokenInformationResponse = DefaultHookReturnType<
   Token[]
@@ -13,21 +16,26 @@ export type UseMultipleTokenInformationResponse = DefaultHookReturnType<
 
 export type useMultipleTokenInformationArgs = {
   addresses: string[] | readonly string[] | undefined;
+  chainId?: number;
 };
-export const useMultipleTokenInformation = (
+export function useMultipleTokenInformation(
   args: useMultipleTokenInformationArgs,
   options?: DefaultHookOptions,
-): UseMultipleTokenInformationResponse => {
+): UseMultipleTokenInformationResponse {
   const publicClient = usePublicClient();
 
   const QUERY_KEY =
     publicClient && args.addresses
-      ? (["useMultipleTokenInformation", args.addresses] as const)
+      ? ([
+          "useMultipleTokenInformation",
+          args.addresses,
+          args.chainId ?? defaultChainId,
+        ] as const)
       : null;
 
   const swrResponse = useSWRImmutable<Token[], unknown, typeof QUERY_KEY>(
     QUERY_KEY,
-    async ([, addresses]) => {
+    async ([, addresses, chainId]) => {
       // 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
@@ -42,6 +50,7 @@ export const useMultipleTokenInformation = (
           const tk = await getTokenInformation({
             address: address,
             publicClient,
+            chainId,
           });
 
           if (!tk) {
@@ -59,4 +68,4 @@ export const useMultipleTokenInformation = (
     ...swrResponse,
     refresh: () => swrResponse?.mutate?.(),
   };
-};
+}

package/src/hooks/tokens/usePollAllowances.ts

@@ -1,19 +1,14 @@
 import useSWR from "swr";
 
-import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+import { useBeraWallet, useConfig } 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";
+import type { AllowanceQueryItem, AllowanceToken } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export type UsePollAllowancesArgs = {
-  spender: string | undefined;
-  tokens: Token[];
+  items: AllowanceQueryItem[];
 };
 export interface UsePollAllowancesResponse
   extends DefaultHookReturnType<AllowanceToken[] | undefined> {}
@@ -24,26 +19,27 @@ export interface UsePollAllowancesResponse
  *
  * @param contract the address of the ERC20 token contract
  * @param tokens   the list of tokens to poll allowances for
+ * @param chainId  the chain ID to check allowances on
  */
-export const usePollAllowances = (
+export function usePollAllowances(
   args: UsePollAllowancesArgs,
   options?: DefaultHookOptions,
-): UsePollAllowancesResponse => {
-  const publicClient = usePublicClient();
+): UsePollAllowancesResponse {
+  const config = useConfig();
+
   const { address: account } = useBeraWallet();
   const QUERY_KEY =
-    publicClient && account && args?.tokens && args?.spender
-      ? (["usePollAllowances", account, args?.tokens, args?.spender] as const)
+    config && account && args?.items
+      ? (["usePollAllowances", account, args?.items] as const)
       : null;
 
   const swrResponse = useSWR(
     QUERY_KEY,
-    async ([, account, tokens, spender]) => {
+    async ([, account, items]) => {
       return getAllowances({
-        tokens,
+        items,
         account,
-        spender,
-        publicClient,
+        config,
       });
     },
     {
@@ -57,4 +53,4 @@ export const usePollAllowances = (
 
     refresh: () => swrResponse?.mutate?.(),
   };
-};
+}

package/src/hooks/tokens/usePollBalance.ts

@@ -14,9 +14,8 @@ import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 
 import { POLLING } from "~/enum/polling";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookReturnType } from "~/types";
 import type { BalanceToken } from "~/types/dex";
-import type { DefaultHookOptions } from "~/types/global";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 import { beraToken, isToken } from "~/utils/tokens";
 import { useTokenInformation } from "./useTokenInformation";
 
@@ -91,8 +90,13 @@ export function usePollBalance(
       : undefined;
 
   const tokenBalance = {
-    balance: data ?? 0n,
-    formattedBalance: formattedBalance ?? "0",
+    chainId,
+    balance: data
+      ? {
+          raw: data.toString(),
+          formatted: formattedBalance ?? "0",
+        }
+      : { raw: "0", formatted: "0" },
     address: address as `0x${string}`,
     decimals: isNativeToken
       ? beraToken.decimals

package/src/hooks/tokens/usePollWalletBalances.ts

@@ -2,17 +2,17 @@ import { useMemo } from "react";
 import useSWR from "swr";
 import type { Address } from "viem";
 
-import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+import {
+  useBeraWallet,
+  useConfig,
+  usePublicClient,
+} from "@berachain/wagmi/hooks";
 
 import { getWalletBalances } from "~/actions/tokens/getWalletBalances";
 import { POLLING } from "~/enum/polling";
 import { useTokens } from "~/hooks/tokens/useTokens";
-import type {
-  BalanceToken,
-  DefaultHookOptions,
-  DefaultHookReturnType,
-  Token,
-} from "~/types";
+import type { BalanceToken, Token } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 export type UsePollWalletBalancesArgs = {
   /**
@@ -29,10 +29,10 @@ export function usePollWalletBalances(
   options?: DefaultHookOptions,
 ): UsePollBalancesResponse {
   const publicClient = usePublicClient();
-
+  const wagmiConfig = useConfig();
   const { address: connectedAccount } = useBeraWallet();
 
-  const { tokenList } = useTokens();
+  const { tokenList, refresh } = useTokens();
 
   const wallet = args?.walletAddress ?? connectedAccount;
 
@@ -59,7 +59,7 @@ export function usePollWalletBalances(
       return getWalletBalances({
         account: wallet,
         tokenList,
-        publicClient,
+        wagmiConfig,
       });
     },
     {
@@ -70,6 +70,9 @@ export function usePollWalletBalances(
 
   return {
     ...swrResponse,
-    refresh: () => swrResponse?.mutate?.(),
+    refresh: () => {
+      swrResponse?.mutate?.();
+      refresh();
+    },
   };
 }

package/src/hooks/tokens/useStakingTokenInformation.ts

@@ -4,7 +4,8 @@ import { isAddress, zeroAddress } from "viem";
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getStakingTokenInformation } from "~/actions/pol/getStakingTokenInformation";
-import type { DefaultHookOptions, DefaultHookReturnType, Token } from "~/types";
+import type { Token } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 import { beraToken, isToken } from "~/utils/tokens";
 
 export type UseStakingTokenInformationResponse = DefaultHookReturnType<

package/src/hooks/tokens/useTokenCurrentPrice.ts

@@ -1,11 +1,13 @@
-import type { DefaultHookReturnType, TokenPriceInfo } from "~/types";
 import type { DefaultHookOptions } from "~/types/global";
 import { useTokenCurrentPrices } from "./useTokenCurrentPrices";
 
+/**
+ * @deprecated use useTokenPrice instead
+ */
 export function useTokenCurrentPrice(
   { address }: { address: `0x${string}` | undefined },
   options?: DefaultHookOptions,
-): DefaultHookReturnType<TokenPriceInfo> {
+) {
   const swrResponse = useTokenCurrentPrices(
     {
       addressIn: address ? [address] : undefined,

package/src/hooks/tokens/useTokenCurrentPrices.ts

@@ -1,13 +1,19 @@
+import { useMemo } from "react";
 import useSWR from "swr";
-import type { Address } from "viem";
+import { type Address, isAddress, zeroAddress } from "viem";
+
+import { defaultChainId } from "@berachain/config/internal";
 
 import { getTokenCurrentPrices } from "~/actions/prices/getTokenCurrentPrices";
 import { POLLING } from "~/enum/polling";
 import { useTokens } from "~/hooks/tokens/useTokens";
-import type { TokenCurrentPriceMap } from "~/types";
-import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
+import type { TokenCurrentPriceMap, TokenWithPrice } from "~/types/dex";
+import type { DefaultHookOptions } from "~/types/global";
 import { isToken } from "~/utils/tokens";
 
+/**
+ * @deprecated use useTokenPrices instead that supports multichain tokens
+ */
 export function useTokenCurrentPrices(
   {
     addressIn,
@@ -20,19 +26,44 @@ export function useTokenCurrentPrices(
       revalidateOnFocus: true,
     },
   },
-): DefaultHookReturnType<TokenCurrentPriceMap> {
-  const { tokenList } = useTokens();
+) {
+  const { tokenList, ensoTokens } = useTokens();
+
+  /**
+   * Berachain or Bepolia Tokens. All tokens from other chains are excluded since API doesn't price them.
+   */
+  const beraAddresses = useMemo<Address[]>(() => {
+    const addresses: Address[] = [];
+
+    if (addressIn) {
+      addresses.push(
+        ...(addressIn.filter((a): a is Address => isAddress(a)) as Address[]),
+      );
+    }
+    return addresses.map((a) => a.toLowerCase() as Address);
+  }, [tokenList]);
+
+  const hasAddressesNotInTokenList = useMemo(() => {
+    const tokenSet = new Set(
+      tokenList?.map((token) => token.address.toLowerCase() as Address),
+    );
+    // Native BERA (zero address) is priced via WBERA in getTokenCurrentPrices.
+    // Treat zero address as "known" whenever WBERA exists in token list.
+    if (tokenList.some((token) => isToken(token, "WBERA"))) {
+      tokenSet.add(zeroAddress);
+    }
+
+    return beraAddresses?.some((a) => !tokenSet.has(a));
+  }, [beraAddresses, tokenList]);
 
   /**
    * If no addressIn is provided, use default token list
    * If all addressIn are in the token list, use default token list
    * If some addressIn are not in the token list, use addressIn
    */
-  const addresses = addressIn?.some(
-    (a) => tokenList?.findIndex((tk) => isToken(tk, a as Address)) === -1,
-  )
-    ? addressIn
-    : tokenList?.map((token) => token.address);
+  const addresses = hasAddressesNotInTokenList
+    ? beraAddresses
+    : tokenList.map((token) => token.address);
 
   const QUERY_KEY =
     addresses && (options.opts?.isEnabled ?? true)
@@ -42,16 +73,64 @@ export function useTokenCurrentPrices(
         ] as const)
       : null;
 
-  const swrResponse = useSWR(
+  const apiResponse = useSWR(
     QUERY_KEY,
     async ([, addresses]) => {
+      // this only works for Berachain tokens
       return getTokenCurrentPrices({ addressIn: addresses });
     },
     options.opts,
   );
 
+  const ensoMatchingPrices = useMemo<TokenCurrentPriceMap>(() => {
+    if (!ensoTokens) return {};
+
+    const ensoPricesMap = new Map<number, Map<Address, TokenWithPrice>>([
+      [defaultChainId, new Map()],
+    ]);
+
+    for (const token of ensoTokens) {
+      if (token.price === undefined || token.chainId !== defaultChainId)
+        continue;
+
+      ensoPricesMap
+        .get(defaultChainId)
+        ?.set(token.address.toLowerCase() as Address, {
+          ...token,
+          price: token.price,
+          chainId: defaultChainId,
+        });
+    }
+
+    return Object.fromEntries(
+      addresses.map((address) => {
+        const price = ensoPricesMap.get(defaultChainId)?.get(address)?.price;
+
+        if (!price) return [null, null];
+
+        return [
+          address.toLowerCase() as Address,
+          {
+            price,
+            chainId: defaultChainId,
+            updatedAt: Date.now(),
+          },
+        ];
+      }),
+    );
+  }, [ensoTokens]);
+
+  const data = useMemo(
+    () => ({
+      ...ensoMatchingPrices,
+      // in this deprecated hook, we let api override enso prices, since there's no multichain support
+      ...apiResponse.data,
+    }),
+    [ensoMatchingPrices, apiResponse.data],
+  );
+
   return {
-    ...swrResponse,
-    refresh: () => void swrResponse.mutate(),
+    ...apiResponse,
+    data,
   };
 }

package/src/hooks/tokens/useTokenInformation.ts

@@ -1,11 +1,14 @@
 import useSWRImmutable from "swr/immutable";
 import { isAddress, zeroAddress } from "viem";
 
+import { defaultChainId } from "@berachain/config/internal";
+
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getTokenInformation } from "~/actions/tokens/getTokenInformation";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions, DefaultHookReturnType, Token } from "~/types";
+import type { Token } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 import { beraToken, isToken } from "~/utils/tokens";
 
 export type UseTokenInformationResponse = DefaultHookReturnType<
@@ -14,12 +17,12 @@ export type UseTokenInformationResponse = DefaultHookReturnType<
 
 export type UseTokenInformationArgs = {
   address: string | undefined;
-  chainId?: number;
+  chainId: number;
 };
-export const useTokenInformation = (
+export function useTokenInformation(
   args: UseTokenInformationArgs,
   options?: DefaultHookOptions,
-): UseTokenInformationResponse => {
+): UseTokenInformationResponse {
   const publicClient = usePublicClient({
     chainId: args.chainId,
   });
@@ -29,13 +32,14 @@ export const useTokenInformation = (
       : null;
   const swrResponse = useSWRImmutable<Token | undefined, any, typeof QUERY_KEY>(
     QUERY_KEY,
-    async ([_, address]) => {
+    async ([_, address, chainId = defaultChainId]) => {
       if (isToken(address, "BERA")) {
         return {
           address: zeroAddress,
           decimals: beraToken.decimals,
           name: beraToken.name,
           symbol: beraToken.symbol,
+          chainId,
         } satisfies Token;
       }
 
@@ -47,6 +51,7 @@ export const useTokenInformation = (
       return await getTokenInformation({
         address,
         publicClient,
+        chainId,
       });
     },
     { ...options?.opts },
@@ -56,4 +61,4 @@ export const useTokenInformation = (
     ...swrResponse,
     refresh: () => swrResponse?.mutate?.(),
   };
-};
+}

package/src/hooks/tokens/useTokenPrice.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+
+import type { DefaultHookOptions } from "~/types/global";
+import { type TokenPriceInput, useTokenPrices } from "./useTokenPrices";
+
+export function useTokenPrice(
+  { token }: { token: TokenPriceInput | undefined },
+  options?: DefaultHookOptions,
+) {
+  const { isLoading, priceMap } = useTokenPrices(
+    { tokens: token ? [token] : undefined },
+    options,
+  );
+
+  return {
+    data: token
+      ? priceMap[token.chainId]?.[token.address.toLowerCase() as Address]
+      : undefined,
+    isLoading,
+  };
+}

package/src/hooks/tokens/useTokenPrices.ts

@@ -0,0 +1,133 @@
+import { useCallback, useMemo } from "react";
+import type { Address } from "viem";
+
+import { defaultChainId } from "@berachain/config/internal";
+
+import { POLLING } from "~/enum/polling";
+import { useTokens } from "~/hooks/tokens/useTokens";
+import type { Token } from "~/types/dex";
+import type { DefaultHookOptions } from "~/types/global";
+import { useTokenCurrentPrices } from "./useTokenCurrentPrices";
+
+export type TokenPriceInput = Pick<Token, "address" | "chainId">;
+
+export type TokenPriceOutput = TokenPriceInput & {
+  price: number;
+};
+export type TokenPriceMap = Record<number, Record<Address, number>>;
+
+export function useTokenPrices(
+  {
+    tokens,
+  }: {
+    tokens?: TokenPriceInput[];
+  } = {},
+  options: DefaultHookOptions = {
+    opts: {
+      refreshInterval: POLLING.NORMAL,
+      revalidateOnFocus: true,
+    },
+  },
+) {
+  const { ensoTokens } = useTokens();
+
+  const apiResponse = useTokenCurrentPrices(
+    {
+      addressIn: tokens
+        ?.filter((token) => token.chainId === defaultChainId)
+        .map((token) => token.address),
+    },
+    options,
+  );
+
+  const data = useMemo(() => {
+    const prices: TokenPriceOutput[] = [];
+
+    if (!tokens) {
+      return [];
+    }
+
+    const tokenMap = new Map<number, Map<Address, TokenPriceInput>>();
+
+    for (const token of tokens) {
+      const chainId = token.chainId ?? defaultChainId;
+      if (!tokenMap.has(chainId)) {
+        tokenMap.set(chainId, new Map<Address, TokenPriceInput>());
+      }
+      tokenMap.get(chainId)?.set(token.address.toLowerCase() as Address, token);
+    }
+
+    if (apiResponse.data) {
+      for (const [address, price] of Object.entries(apiResponse.data)) {
+        if (
+          price &&
+          tokenMap
+            .get(price.chainId ?? defaultChainId)
+            ?.get(address.toLowerCase() as Address) &&
+          price.price !== undefined
+        ) {
+          const token = tokenMap
+            .get(price.chainId ?? defaultChainId)
+            ?.get(address.toLowerCase() as Address);
+
+          if (!token) {
+            continue;
+          }
+
+          prices.push({
+            ...token,
+            chainId: price.chainId,
+            price: price.price,
+          });
+        }
+      }
+    }
+
+    if (ensoTokens) {
+      for (const tk of ensoTokens) {
+        if (tk.price !== undefined && tk.chainId !== undefined) {
+          prices.push({
+            ...tk,
+            chainId: tk.chainId,
+            price: tk.price,
+          });
+        }
+      }
+    }
+
+    return prices;
+  }, [apiResponse.data, ensoTokens, tokens]);
+
+  const priceMap = useMemo<TokenPriceMap>(() => {
+    const map: TokenPriceMap = {};
+    for (const item of data) {
+      const chainId = item.chainId ?? defaultChainId;
+      if (!map[chainId]) {
+        map[chainId] = {} as Record<Address, number>;
+      }
+      map[chainId][item.address.toLowerCase() as Address] = item.price;
+    }
+
+    return map;
+  }, [data]);
+
+  const getTokenPrice = useCallback(
+    (token?: TokenPriceInput) => {
+      if (!token) return undefined;
+      const price =
+        priceMap[token.chainId ?? defaultChainId]?.[
+          token.address?.toLowerCase() as Address
+        ] ?? undefined;
+
+      return price;
+    },
+    [priceMap],
+  );
+
+  return {
+    isLoading: apiResponse.isLoading,
+    data,
+    priceMap,
+    getTokenPrice,
+  };
+}

package/src/hooks/tokens/useTokens.ts

@@ -6,6 +6,7 @@ import type { FormatTokenListReturnType } from "~/utils/formatTokenList";
 
 export function useTokens() {
   const context = useContext(TokenContext);
+
   if (!context) {
     throw new BeraError({
       message: "useTokens must be used within a TokensProvider",

package/src/hooks/tokens/useUnderlyingAsset.ts

@@ -0,0 +1,23 @@
+import useSWRImmutable from "swr/immutable";
+
+import { useConfig } from "@berachain/wagmi/hooks";
+
+import { getUnderlyingToken } from "~/actions/tokens/getUnderlyingToken";
+import type { MinimalERC20 } from "~/types/dex";
+import { isToken } from "~/utils/tokens";
+
+/**
+ * SWR hook that resolves the underlying asset of an ERC4626 vault token.
+ * Returns `null` for non-vault tokens. Results are cached immutably since
+ * a vault's underlying asset doesn't change.
+ */
+export function useUnderlyingAsset({ token }: { token: MinimalERC20 }) {
+  const wagmiConfig = useConfig();
+
+  return useSWRImmutable(
+    token && wagmiConfig && !isToken(token, "BERA")
+      ? ["useUnderlyingAsset", token]
+      : null,
+    async ([, token]) => getUnderlyingToken({ token, wagmiConfig }),
+  );
+}