@berachain/berajs 0.1.2 → 0.2.1

package/src/hooks/dex/useLpPosition.ts

@@ -1,15 +1,12 @@
-import BigNumber from "bignumber.js";
 import { type Address, formatEther, isAddressEqual } from "viem";
 
 import type { MinimalPoolFragment } from "@berachain/graphql/dex/api";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 import { useRewardVaultBalanceFromStakingToken } from "~/hooks/pol/useRewardVaultBalanceFromStakingToken";
 import { usePollBalance } from "~/hooks/tokens/usePollBalance";
-import type {
-  DefaultHookOptions,
-  DefaultHookReturnType,
-  IUserPosition,
-} from "~/types";
+import type { IUserPosition } from "~/types/dex";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types/global";
 
 type IUseLpPositionArgs = {
   pool: MinimalPoolFragment | undefined;
@@ -63,7 +60,7 @@ export const useLpPosition = (
         ? {
             ...userPosition,
             usdValue: userPosition
-              ? Number(userPosition.formattedBalance) * lpTokenPrice
+              ? Number(userPosition.balance.formatted) * lpTokenPrice
               : undefined,
           }
         : undefined,
@@ -74,21 +71,23 @@ export const useLpPosition = (
           )?.ratio ?? 0;
 
         const userBalance = tokenRatio
-          ? BigNumber(userPosition?.formattedBalance ?? "0").times(tokenRatio)
+          ? BigNumber(userPosition?.balance.formatted ?? "0").times(tokenRatio)
           : BigNumber(0);
         const price = Number(token.balanceUSD) / Number(token.balance);
 
         return {
-          balance: userBalance?.isGreaterThan(0)
-            ? BigInt(
-                userBalance
+          ...token,
+
+          balance: {
+            raw: userBalance?.isGreaterThan(0)
+              ? userBalance
                   .times(10 ** token.decimals!)
                   .toFixed(0)
-                  .toString(),
-              )
-            : 0n,
-          formattedBalance: userBalance.toString(),
-          address: token.address,
+                  .toString()
+              : "0",
+            formatted: userBalance.toString(),
+          },
+          price,
           usdValue:
             Number.isNaN(price) || !userBalance
               ? undefined
@@ -97,10 +96,12 @@ export const useLpPosition = (
       }),
       stakedBalance: userVaultTokenBalance?.address
         ? {
-            address: userVaultTokenBalance.address,
-            balance: userVaultTokenBalance.balance,
-            // Pools always use the 18 decimals
-            formattedBalance: formatEther(userVaultTokenBalance.balance),
+            ...userVaultTokenBalance,
+            balance: {
+              raw: userVaultTokenBalance.balance.toString(),
+              // Pools always use the 18 decimals
+              formatted: formatEther(userVaultTokenBalance.balance),
+            },
             usdValue:
               Number(formatEther(userVaultTokenBalance.balance)) * lpTokenPrice,
           }

package/src/hooks/dex/useMultipleTokenApprovalsWithSlippage.ts

@@ -1,13 +1,14 @@
 "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 { parseUnits, zeroAddress } from "viem";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 import { BeraError } from "~/errors/BeraError";
 import { usePollAllowances } from "~/hooks/tokens/usePollAllowances";
-import type { AllowanceToken, TokenInput } from "~/types";
+import type { AllowanceQueryItem, AllowanceToken } from "~/types/dex";
+import { isToken } from "~/utils/tokens";
 
 type NeedsApprovalToken = AllowanceToken & {
   maxAmountIn: bigint;
@@ -18,28 +19,27 @@ function calculateMaxAmountIn({
   decimals,
   slippage,
 }: {
-  amount: string;
+  amount: bigint;
   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)
-  );
+  return amount + (amount * slippageInWei) / BigInt(100 * 10 ** decimals);
 }
 
-export const useMultipleTokenApprovalsWithSlippage = (
-  tokenInput: TokenInput[],
-  spender: Address | undefined,
-  slippage?: number,
-) => {
-  const tokens = useMemo(
+export function useMultipleTokenApprovalsWithSlippage(
+  tokenInput: AllowanceQueryItem[],
+  options?: {
+    slippage?: number;
+  },
+) {
+  const { slippage } = options ?? {};
+
+  const items = useMemo(
     () =>
       tokenInput
-        .filter((token) => token.address !== ZERO_ADDRESS)
-        .filter((token: TokenInput) => token !== undefined)
-        .filter((token) => BigNumber(token.amount).gt(0)),
+        .filter((token) => token.token.address !== zeroAddress)
+        .filter((token) => BigNumber(token.amount.formatted).gt(0)),
     [tokenInput],
   );
 
@@ -48,40 +48,51 @@ export const useMultipleTokenApprovalsWithSlippage = (
     refresh,
     isLoading,
   } = usePollAllowances({
-    spender: spender,
-    tokens,
+    items,
   });
 
   const needsApproval = useMemo<NeedsApprovalToken[]>(
     () =>
       allowances
         ?.map<NeedsApprovalToken | undefined>((allowance) => {
-          const token = tokens.find((token: TokenInput) =>
-            isAddressEqual(token.address, allowance.address),
+          const item = items.find((item) =>
+            isToken(item.token.address, allowance.token),
           );
 
-          if (!token) {
+          if (!item) {
             // 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,
+                items,
               },
             });
           }
 
-          const maxAmountIn = calculateMaxAmountIn({ ...token, slippage });
+          const maxAmountIn = calculateMaxAmountIn({
+            decimals: item.token.decimals,
+            amount: BigInt(item.amount.raw),
+            slippage,
+          });
 
-          if (allowance.allowance === 0n || allowance.allowance < maxAmountIn) {
-            return { ...allowance, maxAmountIn };
+          if (BigNumber(allowance.allowance.raw).lt(maxAmountIn)) {
+            return {
+              ...item,
+              needsApproval: true,
+              maxAmountIn,
+              allowance: {
+                raw: allowance.allowance.raw,
+                formatted: allowance.allowance.formatted,
+              },
+            };
           }
 
           return undefined;
         })
         .filter((token) => token !== undefined) ?? [],
-    [allowances, slippage, tokens],
+    [allowances, slippage, items],
   );
 
   return {
@@ -89,4 +100,4 @@ export const useMultipleTokenApprovalsWithSlippage = (
     refresh,
     isLoading,
   };
-};
+}

package/src/hooks/dex/usePollPoolCreationRelayerApproval.ts

@@ -5,7 +5,7 @@ import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 
 import { balancerVaultAbi } from "~/abi/bex/balancerVault";
 import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions } from "~/types";
+import type { DefaultHookOptions } from "~/types/global";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 /**

package/src/hooks/dex/usePoolEvents.ts

@@ -3,7 +3,7 @@ import useSWRImmutable from "swr/immutable";
 import type { GqlPoolEventType } from "@berachain/graphql/dex/api";
 
 import { getPoolEvents } from "~/actions/dex/getPoolEvents";
-import { POLLING } from "~/enum";
+import { POLLING } from "~/enum/polling";
 
 export const usePoolEvents = ({
   poolId,

package/src/hooks/dex/usePools.ts

@@ -6,7 +6,7 @@ import { useBeraWallet } from "@berachain/wagmi/hooks";
 
 import { getAllPools } from "~/actions/dex/getAllPools";
 import { POLLING } from "~/enum/polling";
-import type { DefaultHookOptions } from "~/types";
+import type { DefaultHookOptions } from "~/types/global";
 import { useAllUserPools } from "./useAllUserPools";
 
 export const usePoolsQueryKey = ({

package/src/hooks/dex/usePriceImpact.ts

@@ -0,0 +1,40 @@
+import { useMemo } from "react";
+
+import type { Token } from "~/types/dex";
+import { computePriceImpact } from "~/utils/math";
+import { useTokenPrices } from "../tokens/useTokenPrices";
+
+export function usePriceImpact({
+  tokenIn,
+  tokenOut,
+  formattedAmountIn,
+  formattedAmountOut,
+}: {
+  tokenIn: Token | undefined;
+  tokenOut: Token | undefined;
+  formattedAmountIn: string | undefined;
+  formattedAmountOut: string | undefined;
+}) {
+  const { getTokenPrice, isLoading } = useTokenPrices({
+    tokens: tokenIn && tokenOut ? [tokenIn, tokenOut] : undefined,
+  });
+  const priceImpact = useMemo(() => {
+    if (!tokenIn || !tokenOut || !formattedAmountIn || !formattedAmountOut)
+      return undefined;
+
+    const tokenInPrice = getTokenPrice(tokenIn);
+    const tokenOutPrice = getTokenPrice(tokenOut);
+
+    if (!tokenInPrice || !tokenOutPrice) return null;
+    return computePriceImpact(
+      tokenInPrice.toString(),
+      tokenOutPrice.toString(),
+      formattedAmountIn,
+      formattedAmountOut,
+    );
+  }, [tokenIn, tokenOut, formattedAmountIn, formattedAmountOut]);
+  return {
+    data: priceImpact,
+    isLoading,
+  };
+}

package/src/hooks/dex/useSingleAggregatorQuote.ts

@@ -0,0 +1,350 @@
+import useSWR, { type SWRConfiguration } from "swr";
+import { type Address, type PublicClient, parseUnits, zeroAddress } from "viem";
+
+import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
+
+import { BaseAggregator } from "~/actions/dex/aggregators/base";
+import { useBeraFlag } from "~/contexts/BeraFlags/BeraFlags";
+import type {
+  HoneyConfigContextReturn,
+  TokenWithOrder,
+} from "~/contexts/HoneyConfigProvider";
+import { Aggregators, type SwapReferrer } from "~/enum/dex";
+import { POLLING } from "~/enum/polling";
+import { BeraError } from "~/errors/BeraError";
+import { RequestError } from "~/errors/RequestError";
+import { useAggregatorsRouterFeeBps } from "~/hooks/dex/useAggregatorsRouterFeeBps";
+import type { MinimalERC20 } from "~/types/dex";
+import type { DefaultHookOptions } from "~/types/global";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { seconds } from "~/utils/time";
+import { isToken } from "~/utils/tokens";
+
+export type IUseAggregatorsQuotesArgs = BeraJS.BaseFunctionArgs & {
+  tokenIn: MinimalERC20;
+  tokenOut: MinimalERC20;
+  amount: string;
+  slippage: number;
+  referrer?: SwapReferrer;
+  rewardVault?: Address;
+  /**
+   * Useful cause the collaterals are provided byt he honeyContext and this way we can
+   * use the Provider only in the swap page where is needed.
+   *
+   * The collaterals for the honey mint/redeem aggregator.
+   */
+  honeyNativeState?: Pick<
+    HoneyConfigContextReturn,
+    "collateralList" | "protocol"
+  >;
+  underlyingToken?: MinimalERC20 | null;
+};
+
+type IQueryKey = readonly [
+  string, // "useAggregatorsQuotes
+  string, // name
+  MinimalERC20, // tokenIn
+  MinimalERC20, // tokenOut
+  string, // parsedAmount
+  number, // slippage
+  Address | undefined, // account
+  number | undefined, // feeBps
+  SwapReferrer | undefined, // referrer
+  Address | undefined, // rewardVault
+  MinimalERC20 | null | undefined, // underlyingToken
+  TokenWithOrder[] | undefined, // collateralList
+];
+
+export const USE_AGGREGATORS_QUOTES_QUERY_KEY = "useAggregatorsQuotes";
+
+/**
+ * Builds the SWR cache key for a single aggregator quote request.
+ * Returns `null` (disabling the query) when the aggregator is unsupported,
+ * disabled via config flags, or missing required dependencies like feeBps.
+ */
+function getQueryKey({
+  aggregator,
+  account,
+  args,
+  feeBps,
+  options,
+  activeAggregators,
+  isMAEnabled,
+}: {
+  aggregator: BaseAggregator;
+  account: Address | undefined;
+  args: IUseAggregatorsQuotesArgs;
+  feeBps: number | undefined;
+  options?: DefaultHookOptions;
+  /**
+   * List of active aggregators fetched from edge config flags.
+   *
+   * If undefined, all aggregators are enabled.
+   */
+  activeAggregators: string[] | undefined;
+  isMAEnabled: boolean;
+}): IQueryKey | null {
+  if (options?.opts?.isEnabled !== undefined && !options?.opts?.isEnabled) {
+    return null;
+  }
+
+  if (!Number(args.amount)) {
+    return null;
+  }
+  if (
+    !aggregator.checkChainSupport({
+      tokenIn: args.tokenIn,
+      tokenOut: args.tokenOut,
+      underlyingToken: args.underlyingToken,
+      honeyNativeState: args.honeyNativeState,
+    })
+  ) {
+    return null;
+  }
+
+  const name = aggregator.name;
+
+  const usesMAContract = ![
+    Aggregators.HubPools,
+    Aggregators.Honey,
+    Aggregators.Wrap,
+    Aggregators.Unwrap,
+    Aggregators.ERC4626,
+  ].includes(name);
+
+  if (!isMAEnabled && usesMAContract) {
+    return null;
+  }
+  const { tokenIn, tokenOut, amount, slippage, referrer, rewardVault } = args;
+
+  const parsedAmount = parseUnits(amount, tokenIn.decimals).toString();
+
+  const isEnabledOnConfig =
+    // always enable wrap and unwrap
+    aggregator.name === Aggregators.Wrap ||
+    aggregator.name === Aggregators.RedeemBgt ||
+    aggregator.name === Aggregators.Honey ||
+    !activeAggregators ||
+    activeAggregators.includes(name.toLowerCase().replaceAll(" ", ""));
+
+  if (!isEnabledOnConfig) {
+    return null;
+  }
+  if (
+    aggregator.name === Aggregators.Honey &&
+    args.honeyNativeState?.protocol.isPaused
+  ) {
+    // if the honey protocol is paused, don't query any quotes
+    return null;
+  }
+
+  const needsUnderlyingToken =
+    aggregator.name === Aggregators.ERC4626 ||
+    aggregator.name === Aggregators.EnsoErc4626;
+
+  if (usesMAContract && feeBps === undefined) {
+    return null;
+  }
+
+  return [
+    USE_AGGREGATORS_QUOTES_QUERY_KEY,
+    name,
+    tokenIn,
+    tokenOut,
+    parsedAmount,
+    slippage,
+    aggregator.needsAccountForQuote ? account : undefined,
+    usesMAContract ? feeBps : 0,
+    referrer,
+    rewardVault,
+    needsUnderlyingToken ? args.underlyingToken : undefined,
+    aggregator.name === Aggregators.Honey
+      ? args.honeyNativeState?.collateralList
+      : undefined,
+  ];
+}
+
+/**
+ * Creates the SWR fetcher that calls `aggregator.getQuote()` with
+ * the parameters extracted from the query key tuple.
+ */
+function getQueryFn({
+  aggregator,
+  publicClient,
+  proxyAggregatorsThroughVercel,
+}: {
+  aggregator: BaseAggregator;
+  publicClient?: PublicClient;
+  proxyAggregatorsThroughVercel?: boolean;
+}) {
+  return async ([
+    ,
+    ,
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account,
+    aggregatorsFeeBps,
+    referrer,
+    rewardVault,
+    underlyingToken,
+    honeyCollaterals,
+  ]: IQueryKey) =>
+    aggregator.getQuote({
+      tokenIn,
+      tokenOut,
+      amount,
+      slippage,
+      account,
+      aggregatorsFeeBps,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+      referrer,
+      rewardVault,
+      underlyingToken,
+      honeyNativeState: {
+        collateralList: honeyCollaterals ?? [],
+      },
+    });
+}
+
+/**
+ * this hook is used internally to avoid caling the same hook and checks
+ * on every useSingleAggregatorQuote call, when called inside useAggregatorsQuotes.
+ *
+ * @internal
+ */
+export function raw_useSingleAggregatorQuote(
+  {
+    feeBps,
+    publicClient,
+    account,
+    proxyAggregatorsThroughVercel,
+    activeAggregators,
+    isMAEnabled,
+    ...args
+  }: IUseAggregatorsQuotesArgs & {
+    account: Address | undefined;
+    aggregator: BaseAggregator;
+    feeBps: number | undefined;
+    activeAggregators: string[] | undefined;
+    isMAEnabled: boolean;
+    publicClient: PublicClient | undefined;
+    proxyAggregatorsThroughVercel: boolean | undefined;
+  },
+  options?: DefaultHookOptions,
+) {
+  // we're using independent useSWRs so we can show quotes as they come
+  // instead of waiting for all of them to load
+  return useSWR(
+    getQueryKey({
+      aggregator: args.aggregator,
+      account,
+      args,
+      feeBps,
+      options,
+      activeAggregators,
+      isMAEnabled,
+    }),
+    getQueryFn({
+      aggregator: args.aggregator,
+      proxyAggregatorsThroughVercel,
+      publicClient,
+    }),
+    options?.opts,
+  );
+}
+
+/**
+ * Returns shared SWR options for aggregator quote polling, including
+ * custom error retry logic that stops retrying on "path not found" and 403 errors.
+ */
+export function getAggregatorsSWROptions(
+  options?: DefaultHookOptions,
+): SWRConfiguration {
+  return {
+    refreshInterval: POLLING.FAST, // every 10s
+    errorRetryCount: 3,
+    ...options?.opts,
+    // biome-ignore lint/nursery/useMaxParams: the function is defined in the SWRConfiguration type
+    onErrorRetry(err, key, config, revalidate, revalidateOpts) {
+      options?.opts?.onErrorRetry?.(
+        err,
+        key,
+        config,
+        revalidate,
+        revalidateOpts,
+      );
+      if (err instanceof BeraError) {
+        if (err.reason === BaseAggregator.PATH_NOT_FOUND_REASON) {
+          return;
+        }
+      }
+
+      if (err instanceof RequestError && err.statusCode === 403) {
+        console.warn(key[1], "returned error 403, stopping retries");
+        return;
+      }
+
+      if (revalidateOpts.retryCount > (config.errorRetryCount ?? 3)) {
+        return;
+      }
+
+      setTimeout(() => {
+        revalidate();
+      }, config.errorRetryInterval ?? seconds(10));
+    },
+  };
+}
+
+/**
+ * Standalone hook for fetching a quote from a single aggregator.
+ * Resolves wallet, fee, and feature flag context internally — use this
+ * when you need a quote outside of the `useAggregatorsQuotes` multi-quote flow.
+ */
+export function useSingleAggregatorQuote(
+  args: IUseAggregatorsQuotesArgs & { aggregator: BaseAggregator },
+  options?: DefaultHookOptions,
+) {
+  const { address: account } = useBeraWallet();
+  const proxyAggregatorsThroughVercel = useBeraFlag(
+    "proxyAggregatorsThroughVercel",
+  );
+  const activeAggregators = useBeraFlag("aggregators");
+  const publicClient = usePublicClient();
+
+  const { data: feeBps } = useAggregatorsRouterFeeBps();
+
+  if (args.aggregator.name !== Aggregators.Wrap) {
+    const isWrapOrUnwrap =
+      (isToken(args.tokenIn.address, "BERA") ||
+        isToken(args.tokenIn.address, "WBERA")) &&
+      (isToken(args.tokenOut.address, "BERA") ||
+        isToken(args.tokenOut.address, "WBERA"));
+
+    if (!isWrapOrUnwrap) {
+      return null;
+    }
+  }
+
+  const { config } = parseBaseArgs(args);
+
+  const isMAEnabled = config.bex.aggregatorsRouter !== zeroAddress;
+
+  // we're using independent useSWRs so we can show quotes as they come
+  // instead of waiting for all of them to load
+  return raw_useSingleAggregatorQuote(
+    {
+      ...args,
+      aggregator: args.aggregator,
+      feeBps,
+      activeAggregators,
+      account,
+      isMAEnabled,
+      publicClient,
+      proxyAggregatorsThroughVercel,
+    },
+    { ...options, opts: getAggregatorsSWROptions(options) },
+  );
+}