@berachain/berajs 0.2.12 → 0.3.0

package/src/hooks/dex/useAllUserPools.ts

@@ -5,18 +5,18 @@ import { getAllPools } from "../../actions/dex/getAllPools";
 import { POLLING } from "../../enum/polling";
 import type { DefaultHookOptions } from "../../types/global";
 
-export const useAllUserPoolsQueryKey = ({
+export function useAllUserPoolsQueryKey({
   query,
 }: {
   query?: GetPoolsQueryVariables;
-} = {}) => {
+} = {}) {
   return ["useAllUserPools", query];
-};
+}
 
-export const useAllUserPools = (
+export function useAllUserPools(
   query: GetPoolsQueryVariables,
   options?: DefaultHookOptions,
-) => {
+) {
   return useSWR(
     useAllUserPoolsQueryKey({ query }),
     async ([_, params]) => {
@@ -30,4 +30,4 @@ export const useAllUserPools = (
       ...options,
     },
   );
-};
+}

package/src/hooks/dex/useApiPool.ts

@@ -7,15 +7,15 @@ import { getApiPool } from "../../actions/dex/getApiPool";
 import { POLLING } from "../../enum/polling";
 import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
 
-export const useApiPoolQueryKey = ({
+export function useApiPoolQueryKey({
   poolId,
   account,
 }: {
   poolId: Hex;
   account?: Address;
-}) => {
+}) {
   return poolId ? ([`usePool-api`, poolId, account] as const) : null;
-};
+}
 
 export function useApiPool({
   poolId,

package/src/hooks/dex/useCreatePool.ts

@@ -42,7 +42,7 @@ export interface Oracle {
   cacheDuration: number;
 }
 
-const createStablePoolArgs = ({
+function createStablePoolArgs({
   poolCreationHelper,
   poolCreateTokens,
   initialLiquidityTokens,
@@ -70,7 +70,7 @@ const createStablePoolArgs = ({
   message: string;
   actionType: TransactionActionType;
   gasLimit?: bigint;
-}) => {
+}) {
   // Map and sort pool creation token addresses NOTE: we should never see BERA in this array.
   const sortedPoolCreateAddresses = poolCreateTokens
     .map((token) => token.address.toLowerCase())
@@ -149,9 +149,9 @@ const createStablePoolArgs = ({
     typeof balancerPoolCreationHelperAbi,
     "createAndJoinStablePool"
   >;
-};
+}
 
-const createWeightedPoolArgs = ({
+function createWeightedPoolArgs({
   poolCreationHelper,
   poolCreateTokens,
   initialLiquidityTokens,
@@ -177,7 +177,7 @@ const createWeightedPoolArgs = ({
   message: string;
   actionType: TransactionActionType;
   gasLimit?: bigint;
-}) => {
+}) {
   // When joining weighted pools with BERA, we allow it as a joinPoolToken but never as a createPoolToken.
   const createPoolTokens: string[] = [];
   const joinPoolTokens: string[] = [];
@@ -242,9 +242,9 @@ const createWeightedPoolArgs = ({
     typeof balancerPoolCreationHelperAbi,
     "createAndJoinWeightedPool"
   >;
-};
+}
 
-export const useCreatePool = ({
+export function useCreatePool({
   poolCreateTokens,
   initialLiquidityTokens,
   normalizedWeights,
@@ -256,7 +256,7 @@ export const useCreatePool = ({
   amplification,
   oracles,
   ...baseArgs
-}: UseCreatePoolProps): UseCreatePoolReturn => {
+}: UseCreatePoolProps): UseCreatePoolReturn {
   // Generated names
   const { generatedPoolName, generatedPoolSymbol } = useMemo(() => {
     if (!poolCreateTokens) {
@@ -266,11 +266,11 @@ export const useCreatePool = ({
       };
     }
     const generatedPoolName = generatePoolName(poolCreateTokens);
-    const generatedPoolSymbol = generatePoolSymbol(
-      poolCreateTokens,
-      normalizedWeights,
+    const generatedPoolSymbol = generatePoolSymbol({
+      tokens: poolCreateTokens,
+      weights: normalizedWeights,
       poolType,
-    );
+    });
 
     return {
       generatedPoolName,
@@ -349,4 +349,4 @@ export const useCreatePool = ({
     generatedPoolSymbol,
     createPoolArgs,
   };
-};
+}

package/src/hooks/dex/useCrossChainNativeFee.ts

@@ -0,0 +1,83 @@
+"use client";
+
+import { formatEther, zeroAddress } from "viem";
+
+import { usePollBalance } from "../tokens/usePollBalance";
+
+/**
+ * Whether the source-chain native balance fails to cover the tx value.
+ *
+ * Same-chain zaps never qualify: their tx `value` is the native amount being
+ * swapped (e.g. BERA → HONEY), not a bridge fee, so treating it as a fee would
+ * always flag the balance short. Extracted (and exported) so the branch is
+ * unit-testable without a React renderer.
+ */
+export function isNativeFeeInsufficient({
+  isCrossChain,
+  value,
+  nativeBalance,
+  isLoading,
+}: {
+  isCrossChain: boolean;
+  value: bigint;
+  nativeBalance: bigint;
+  isLoading: boolean;
+}): boolean {
+  if (!isCrossChain) return false;
+  return value > 0n && !isLoading && value > nativeBalance;
+}
+
+/**
+ * Cross-chain zaps pay the LayerZero bridge fee out of the source-chain native
+ * balance (it's baked into the tx `value`). This polls that native balance and
+ * reports whether it covers the fee, so the shared warning/gas-reserve UI stops
+ * being copy-pasted per call site. Only polls when a cross-chain route exists —
+ * `srcChainId` is passed undefined otherwise.
+ */
+export function useCrossChainNativeFee({
+  srcChainId,
+  value,
+}: {
+  /** Source chain the tx (and bridge fee) lives on. Undefined ⇒ not cross-chain, no poll. */
+  srcChainId: number | undefined;
+  /** The tx value in wei, including the bridge fee. */
+  value: bigint;
+}): {
+  nativeFee?: string;
+  hasInsufficientNativeBalance: boolean;
+  isNativeBalanceLoading: boolean;
+} {
+  const isCrossChain = srcChainId !== undefined;
+
+  const { data: nativeBalanceData, isLoading: isNativeBalanceLoading } =
+    usePollBalance(
+      {
+        address: zeroAddress,
+        chainId: isCrossChain ? srcChainId : undefined,
+      },
+      { isEnabled: isCrossChain },
+    );
+
+  // For a same-chain zap the tx `value` is the native amount being swapped, not
+  // a bridge fee — so there's no fee to display or check.
+  if (!isCrossChain) {
+    return {
+      nativeFee: undefined,
+      hasInsufficientNativeBalance: false,
+      isNativeBalanceLoading: false,
+    };
+  }
+
+  const nativeBalance = BigInt(nativeBalanceData?.balance.raw ?? 0n);
+
+  return {
+    nativeFee: value > 0n ? formatEther(value) : undefined,
+    hasInsufficientNativeBalance: isNativeFeeInsufficient({
+      isCrossChain,
+      value,
+      nativeBalance,
+      isLoading: isNativeBalanceLoading,
+    }),
+    isNativeBalanceLoading,
+  };
+}

package/src/hooks/dex/useCrossChainNativeFee.unit.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "vitest";
+
+import { isNativeFeeInsufficient } from "./useCrossChainNativeFee";
+
+describe("isNativeFeeInsufficient", () => {
+  // Regression (PR #1965 review): a same-chain native-in zap (e.g. BERA → HONEY)
+  // has a non-zero tx value that is the swap amount, not a bridge fee. It must
+  // never be flagged as insufficient native balance.
+  test("same-chain zap is never insufficient, even with a large value", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: false,
+        value: 10n ** 18n,
+        nativeBalance: 0n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: insufficient when value exceeds native balance", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 2n,
+        nativeBalance: 1n,
+        isLoading: false,
+      }),
+    ).toBe(true);
+  });
+
+  test("cross-chain: sufficient when balance covers the fee", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 1n,
+        nativeBalance: 5n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: not flagged while the balance is still loading", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 2n,
+        nativeBalance: 0n,
+        isLoading: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: zero value is never insufficient", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 0n,
+        nativeBalance: 0n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+});

package/src/hooks/dex/useGlobalLiquidityAndSwapVolume.ts

@@ -2,7 +2,7 @@ import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { getGlobalLiquidityAndSwapVolume } from "../../actions/dex/getGlobalLiquidityAndSwapVolume";
 
-export const useGlobalLiquidityAndSwapVolume = () => {
+export function useGlobalLiquidityAndSwapVolume() {
   const response = useSWR("useGlobalLiquidityAndSwapVolume", async () =>
     getGlobalLiquidityAndSwapVolume(),
   );
@@ -18,4 +18,4 @@ export const useGlobalLiquidityAndSwapVolume = () => {
       ),
     },
   };
-};
+}

package/src/hooks/dex/useLiquidityMismatch.ts

@@ -39,7 +39,7 @@ interface UseLiquidityMismatchParams {
  * @param {number} liquidityMismatchTolerancePercent - The tolerance for liquidity mismatches in percent.
  * @returns {Object} The liquidity mismatch info.
  */
-export const useLiquidityMismatch = ({
+export function useLiquidityMismatch({
   currentStep,
   tokenPrices,
   isLoadingTokenPrices,
@@ -49,7 +49,7 @@ export const useLiquidityMismatch = ({
   poolType,
   liquidityMismatchTolerancePercent = DEFAULT_LIQUIDITY_MISMATCH_TOLERANCE_PERCENT,
   oracles,
-}: UseLiquidityMismatchParams): LiquidityMismatchInfo => {
+}: UseLiquidityMismatchParams): LiquidityMismatchInfo {
   // NOTE: would be nice to use Maps/Records more in here, as the zipping/unzipping is cumbersome.
   // NOTE: if we pull in string literal for currentStep things would also be a bit clearer in here.
   const [liquidityMismatchInfo, setLiquidityMismatchInfo] =
@@ -189,4 +189,4 @@ export const useLiquidityMismatch = ({
     oracles,
   ]);
   return liquidityMismatchInfo;
-};
+}

package/src/hooks/dex/useLpPosition.ts

@@ -19,10 +19,10 @@ type IUseLpPositionArgs = {
 /**
  * Given a pool and used within an initialized viem context, returns the user's position
  */
-export const useLpPosition = (
+export function useLpPosition(
   { pool, vaultAddress }: IUseLpPositionArgs,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<IUserPosition> => {
+): DefaultHookReturnType<IUserPosition> {
   const { data: userPosition, ...rest } = usePollBalance({
     address: pool?.address,
   });
@@ -116,4 +116,4 @@ export const useLpPosition = (
       refreshVaultDeposit();
     },
   };
-};
+}

package/src/hooks/dex/useOnChainPoolData.ts

@@ -93,17 +93,16 @@ export function useOnChainPoolData(poolId: string) {
       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) => ({
+    const infoByAddress = new Map(
+      tokenInformation.map(
+        (token) => [token.address.toLowerCase(), token] as const,
+      ),
+    );
+
+    const tokens = poolData.poolTokens[0].map((rawAddress, idx) => {
+      const token = infoByAddress.get(rawAddress.toLowerCase());
+      if (!token) return null;
+      return {
         address: token.address.toLowerCase() as Address,
         name: token.name,
         decimals: token.decimals,
@@ -115,11 +114,29 @@ export function useOnChainPoolData(poolId: string) {
           token.decimals,
         ),
         token: {
-          __typename: "Token",
+          __typename: "Token" as const,
           token,
           latestUSDPrice: tokenPrices?.[token.address],
         },
-      })),
+      };
+    });
+
+    // A pool token whose metadata couldn't be resolved leaves the pool incomplete;
+    if (tokens.some((token) => token === null)) {
+      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: tokens as NonNullable<(typeof tokens)[number]>[],
       amplificationParameter: poolData?.amplificationParameter && {
         // For example, if value is 300000n and precision is 1000n, the user-set amplification parameter would be 300000n / 1000n = 300n.
         currentFormattedValue:

package/src/hooks/dex/usePollPoolCreationRelayerApproval.ts

@@ -14,9 +14,9 @@ import { parseBaseArgs } from "../../utils/parseBaseArgs";
  *
  * @returns SWR data spread and refresh function
  */
-export const usePollPoolCreationRelayerApproval = (
+export function usePollPoolCreationRelayerApproval(
   options?: DefaultHookOptions,
-) => {
+) {
   const { address: account } = useBeraWallet();
   const publicClient = usePublicClient();
 
@@ -46,4 +46,4 @@ export const usePollPoolCreationRelayerApproval = (
     },
     { ...options },
   );
-};
+}

package/src/hooks/dex/usePoolEvents.ts

@@ -4,13 +4,13 @@ import { useSWRImmutable } from "@berachain/utils/pkg/swr";
 import { getPoolEvents } from "../../actions/dex/getPoolEvents";
 import { POLLING } from "../../enum/polling";
 
-export const usePoolEvents = ({
+export function usePoolEvents({
   poolId,
   typeInArray,
 }: {
   poolId: string | undefined;
   typeInArray: GqlPoolEventType[];
-}) => {
+}) {
   return useSWRImmutable(
     poolId ? (["usePoolEvents", poolId, typeInArray] as const) : null,
     async ([, poolId, typeInArray]) => getPoolEvents({ poolId, typeInArray }),
@@ -18,4 +18,4 @@ export const usePoolEvents = ({
       refreshInterval: POLLING.SLOW,
     },
   );
-};
+}

package/src/hooks/dex/usePoolHistoricalData.ts

@@ -15,10 +15,10 @@ type UsePoolHistoricalDataArgs = {
   poolId: string | undefined;
 };
 
-export const usePoolHistoricalData = (
+export function usePoolHistoricalData(
   { poolId, ...baseArgs }: UsePoolHistoricalDataArgs & BeraJS.BaseFunctionArgs,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<PoolHistoricalDataFragment[] | undefined> => {
+): DefaultHookReturnType<PoolHistoricalDataFragment[] | undefined> {
   const { config } = parseBaseArgs(baseArgs);
   const QUERY_KEY = poolId
     ? (["usePoolHistoricalData", poolId] as const)
@@ -38,4 +38,4 @@ export const usePoolHistoricalData = (
     },
     options,
   );
-};
+}

package/src/hooks/dex/usePools.ts

@@ -9,21 +9,21 @@ import { POLLING } from "../../enum/polling";
 import type { DefaultHookOptions } from "../../types/global";
 import { useAllUserPools } from "./useAllUserPools";
 
-export const usePoolsQueryKey = ({
+export function 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 = (
+export function usePools(
   query: GetPoolsQueryVariables,
   options?: DefaultHookOptions,
-) => {
+) {
   const { address: account } = useBeraWallet();
   const {
     data: userPools,
@@ -82,4 +82,4 @@ export const usePools = (
     },
     pagination,
   };
-};
+}

package/src/hooks/dex/usePriceImpact.ts

@@ -26,12 +26,12 @@ export function usePriceImpact({
       return undefined;
 
     if (tokenInPrice == null || tokenOutPrice == null) return null;
-    return computePriceImpact(
-      tokenInPrice.toString(),
-      tokenOutPrice.toString(),
-      formattedAmountIn,
-      formattedAmountOut,
-    );
+    return computePriceImpact({
+      tokenInPrice: tokenInPrice.toString(),
+      tokenOutPrice: tokenOutPrice.toString(),
+      inAmount: formattedAmountIn,
+      outAmount: formattedAmountOut,
+    });
   }, [
     tokenIn,
     tokenOut,

package/src/hooks/dex/useSingleAggregatorQuote.ts

@@ -86,13 +86,15 @@ function getQueryKey({
   if (!Number(args.amount)) {
     return null;
   }
+
   if (
-    !aggregator.checkChainSupport({
+    aggregator.getUnsupportedReason({
       tokenIn: args.tokenIn,
       tokenOut: args.tokenOut,
       underlyingToken: args.underlyingToken,
       honeyNativeState: args.honeyNativeState,
-    })
+      rewardVault: args.rewardVault,
+    }) !== null
   ) {
     return null;
   }

package/src/hooks/enso/useBendZapSupply.ts

@@ -1,8 +1,6 @@
 "use client";
 
-import { type Address, formatEther, parseUnits, zeroAddress } from "viem";
-
-import { defaultChainId as berachainChainId } from "@berachain/config/internal";
+import { type Address, parseUnits, zeroAddress } from "viem";
 
 import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
@@ -19,9 +17,8 @@ import type { BalanceToken, MinimalERC20 } from "../../types/dex";
 import type { DefaultHookOptions } from "../../types/global";
 import { isToken } from "../../utils/tokens";
 import { useGetConvertToAssets } from "../bend/useGetConvertToAssets";
+import { useCrossChainNativeFee } from "../dex/useCrossChainNativeFee";
 import { usePriceImpact } from "../dex/usePriceImpact";
-import { usePollBalance } from "../tokens/usePollBalance";
-import { useTokenPrices } from "../tokens/useTokenPrices";
 
 type UseBendZapSupplyArgs = {
   /*
@@ -69,10 +66,6 @@ export function useBendZapSupply(
   }: UseBendZapSupplyArgs,
   options?: DefaultHookOptions,
 ) {
-  const { getTokenPrice } = useTokenPrices({
-    tokens: tokenIn && loanToken ? [tokenIn, loanToken] : undefined,
-  });
-
   const swrResponse = useBendZapSupplyHelper(
     {
       tokenIn,
@@ -106,39 +99,17 @@ export function useBendZapSupply(
     },
   );
 
-  const isCrossChain = tokenIn?.chainId && tokenIn.chainId !== berachainChainId;
+  const isCrossChain = swrResponse.data?.isCrossChain;
 
-  // fetch native token balance for source chain (needed for bridge fee check)
-  const { data: nativeBalanceData, isLoading: isNativeBalanceLoading } =
-    usePollBalance(
-      {
-        address: zeroAddress,
-        chainId: isCrossChain ? tokenIn?.chainId : undefined,
-      },
-      { isEnabled: !!isCrossChain },
-    );
-
-  // for cross-chain zaps, check if transaction value exceeds native token balance
-  // (tx.value includes bridge fees that must be paid in native token)
+  // for cross-chain zaps, tx.value includes the bridge fee (paid in native
+  // token on the source chain); check the source-chain native balance covers it.
   const transactionValue =
     swrResponse.data?.getCalldata?.({ account: zeroAddress })?.value ?? 0n;
 
-  // check if user has enough native token for bridge fees
-  const nativeBalance = nativeBalanceData?.balance ?? {
-    raw: "0",
-    formatted: "0",
-  };
-  const hasInsufficientNativeBalance =
-    isCrossChain &&
-    transactionValue > 0n &&
-    !isNativeBalanceLoading &&
-    transactionValue > BigInt(nativeBalance.raw);
-
-  // formatted native fee for gas reserve display
-  const nativeFee =
-    isCrossChain && transactionValue > 0n
-      ? formatEther(transactionValue)
-      : undefined;
+  const { hasInsufficientNativeBalance, nativeFee } = useCrossChainNativeFee({
+    srcChainId: isCrossChain ? swrResponse.data?.srcChainId : undefined,
+    value: transactionValue,
+  });
 
   return {
     ...swrResponse,

package/src/hooks/enso/useEnsoUserTokensWithBalances.ts

@@ -1,3 +1,5 @@
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
 import { useBeraWallet, useConfig } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
@@ -17,10 +19,9 @@ export function useEnsoUserTokensWithBalances(
   const proxyAggregatorsThroughVercel = useBeraFlag(
     "proxyAggregatorsThroughVercel",
   );
-  const isEnabled = !!fromAddress;
 
   const QUERY_KEY =
-    isEnabled && wagmiConfig
+    fromAddress && wagmiConfig
       ? ([
           "useEnsoUserTokensWithBalances",
           fromAddress,
@@ -43,6 +44,13 @@ export function useEnsoUserTokensWithBalances(
     {
       refreshInterval: POLLING.NORMAL,
       ...options,
+      // Enso only supports mainnet — on a Bepolia deployment `getBalances`
+      // returns a non-array, which the action reports as a warning (HUB-A1J).
+      // Don't query at all when the app isn't on an Enso-supported chain.
+      isEnabled:
+        chainId !== ChainId.BEPOLIA &&
+        defaultChainId !== ChainId.BEPOLIA &&
+        (options?.isEnabled ?? true),
     },
   );
 }

package/src/hooks/enso/useZapStakeBera.ts

@@ -104,7 +104,7 @@ export function useZapStakeBera(
     data: {
       ...swrResponse.data,
       priceImpactPercentage,
-      isCrossChain: inputToken && tokenOut.chainId !== inputToken?.chainId,
+      isCrossChain: swrResponse.data?.isCrossChain,
     },
   };
 }