@berachain/berajs 0.1.1 → 0.2.0

package/src/hooks/dex/useCreatePool.ts

@@ -0,0 +1,438 @@
+import { useMemo } from "react";
+import { PoolType } from "@berachain-foundation/berancer-sdk";
+import useSWRImmutable from "swr/immutable";
+import {
+  type Address,
+  formatUnits,
+  keccak256,
+  parseUnits,
+  zeroAddress,
+} from "viem";
+
+import {
+  GetDedupedSubgraphPools,
+  type GetDedupedSubgraphPoolsQuery,
+  type SubgraphPoolFragment,
+} from "@berachain/graphql/dex/subgraph";
+
+import { balancerPoolCreationHelperAbi } from "~/abi/bex/balancerPoolCreationHelper";
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { TransactionActionType } from "~/enum/txnEnum";
+import type { Token, TokenWithAmount } from "~/types/dex";
+import type { IContractWrite } from "~/types/global";
+import { DEFAULT_METAMASK_GAS_LIMIT } from "~/utils/constants";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { generatePoolName, generatePoolSymbol } from "~/utils/poolNamings";
+import { isToken } from "~/utils/tokens";
+import { wrapNativeTokens } from "~/utils/tokenWrapping";
+
+const DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD = 0.005;
+interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
+  poolCreateTokens: Token[];
+  initialLiquidityTokens: TokenWithAmount[];
+  normalizedWeights: bigint[]; // NOTE: if you pass weights that have off-by-1 errors pool create will fail (ex: 0.3 repeating)
+  poolType: PoolType;
+  swapFee: number;
+  owner: string;
+  poolSymbol: string;
+  poolName: string;
+  amplification: number;
+  weightsDuplicationThreshold?: number;
+  oracles: Oracle[]; // NOTE: the default state for oracles should be 0x0 address for each token with cache duration of ~100
+}
+interface UseCreatePoolReturn {
+  generatedPoolName: string;
+  generatedPoolSymbol: string;
+  isDupePool: boolean;
+  dupePool?: SubgraphPoolFragment | null;
+  createPoolArgs: any;
+  isLoadingPools: boolean;
+  errorLoadingPools: boolean;
+}
+
+export enum OracleMode {
+  None = "None",
+  Custom = "Custom",
+}
+
+export interface Oracle {
+  mode: OracleMode;
+  address: string;
+  tokenAddress: string;
+  cacheDuration: number;
+}
+
+const createStablePoolArgs = ({
+  poolCreationHelper,
+  poolCreateTokens,
+  initialLiquidityTokens,
+  swapFeePercentage,
+  salt,
+  poolName,
+  poolSymbol,
+  owner,
+  amplification,
+  oracles,
+  message,
+  actionType,
+  gasLimit = DEFAULT_METAMASK_GAS_LIMIT,
+}: {
+  poolCreationHelper: Address;
+  poolCreateTokens: Token[];
+  initialLiquidityTokens: TokenWithAmount[];
+  swapFeePercentage: bigint;
+  salt: string;
+  poolName: string;
+  poolSymbol: string;
+  owner: string;
+  amplification: number;
+  oracles: Oracle[];
+  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())
+    .sort((a, b) => (a < b ? -1 : 1));
+
+  const combinedData = sortedPoolCreateAddresses.map((address) => {
+    // Match with initial liquidity tokens
+    const liquidityToken = initialLiquidityTokens.find(
+      (token) =>
+        token.address.toLowerCase() === address ||
+        (isToken(address, "WBERA") && isToken(token.address, "BERA")),
+    );
+
+    const amountIn = liquidityToken
+      ? parseUnits(liquidityToken.amount, liquidityToken.decimals)
+      : 0n; // FIXME we need to throw errors from here if zipping fails.
+
+    // Match with oracles
+    const oracle = oracles.find(
+      (oracle) => oracle.tokenAddress.toLowerCase() === address.toLowerCase(),
+    );
+    const rateProvider = oracle ? oracle.address : zeroAddress;
+    const cacheDuration = oracle ? BigInt(oracle.cacheDuration) : BigInt(100);
+
+    return { amountIn, rateProvider, cacheDuration };
+  });
+
+  // Extract results into separate arrays
+  const sortedAmountsIn = combinedData.map((data) => data.amountIn);
+  const sortedRateProviders = combinedData.map((data) => data.rateProvider);
+  const sortedCacheDurations = combinedData.map((data) => data.cacheDuration);
+
+  // Determine if native token (BERA) is included, and if so calculate its value, that is the value of this tx
+  const nativeTokenIndex = initialLiquidityTokens.findIndex((token) =>
+    isToken(token.address, "BERA"),
+  );
+  const value =
+    nativeTokenIndex !== -1
+      ? parseUnits(
+          initialLiquidityTokens[nativeTokenIndex].amount,
+          initialLiquidityTokens[nativeTokenIndex].decimals,
+        )
+      : 0n;
+  const joinWBERAPoolWithBERA = value > 0n;
+
+  return {
+    address: poolCreationHelper,
+    abi: balancerPoolCreationHelperAbi,
+    functionName: "createAndJoinStablePool",
+    params: [
+      poolName,
+      poolSymbol,
+      sortedPoolCreateAddresses,
+      BigInt(amplification),
+      sortedRateProviders,
+      sortedCacheDurations,
+      false, // Exempt from yield protocol fee NOTE: this should be false for stable pools if rate providers are 0x0
+      swapFeePercentage,
+      sortedAmountsIn,
+      owner as `0x${string}`,
+      salt,
+      joinWBERAPoolWithBERA,
+    ],
+    message,
+    actionType,
+    value,
+    gasLimit,
+    track: {
+      eventName: "hub_pool_create",
+      eventData: {
+        poolName: poolName,
+        poolSymbol: poolSymbol,
+      },
+    },
+  } as IContractWrite<
+    typeof balancerPoolCreationHelperAbi,
+    "createAndJoinStablePool"
+  >;
+};
+
+const createWeightedPoolArgs = ({
+  poolCreationHelper,
+  poolCreateTokens,
+  initialLiquidityTokens,
+  normalizedWeights,
+  swapFeePercentage,
+  salt,
+  poolName,
+  poolSymbol,
+  owner,
+  message,
+  actionType,
+  gasLimit = DEFAULT_METAMASK_GAS_LIMIT,
+}: {
+  poolCreationHelper: Address;
+  poolCreateTokens: Token[];
+  initialLiquidityTokens: TokenWithAmount[];
+  normalizedWeights: bigint[];
+  swapFeePercentage: bigint;
+  salt: string;
+  poolName: string;
+  poolSymbol: string;
+  owner: string;
+  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[] = [];
+  const sortedWeights: bigint[] = [];
+  const sortedAmountsIn: bigint[] = [];
+
+  poolCreateTokens
+    .map((token, index) => {
+      return {
+        createToken: token.address,
+        joinToken: initialLiquidityTokens[index].address, // NOTE: this will allow native token as a join token
+        weight: normalizedWeights[index],
+        amountIn: parseUnits(
+          initialLiquidityTokens[index].amount,
+          initialLiquidityTokens[index].decimals,
+        ),
+      };
+    })
+    .sort((a, b) =>
+      a.createToken.toLowerCase() < b.createToken.toLowerCase() ? -1 : 1,
+    )
+    .forEach((item) => {
+      createPoolTokens.push(item.createToken);
+      joinPoolTokens.push(item.joinToken);
+      sortedWeights.push(item.weight);
+      sortedAmountsIn.push(item.amountIn);
+    });
+
+  // Determine if native token (BERA) is involved and calculate its value, that is the value of this tx
+  const nativeTokenIndex = joinPoolTokens.indexOf(zeroAddress);
+  const value =
+    nativeTokenIndex !== -1 ? sortedAmountsIn[nativeTokenIndex] : 0n;
+
+  return {
+    address: poolCreationHelper,
+    abi: balancerPoolCreationHelperAbi,
+    functionName: "createAndJoinWeightedPool",
+    params: [
+      poolName,
+      poolSymbol,
+      createPoolTokens,
+      joinPoolTokens,
+      sortedWeights,
+      Array(createPoolTokens.length).fill(zeroAddress),
+      swapFeePercentage,
+      sortedAmountsIn,
+      owner as `0x${string}`,
+      salt,
+    ],
+    message,
+    actionType,
+    value,
+    gasLimit,
+    track: {
+      eventName: "hub_pool_create",
+      eventData: {
+        poolName: poolName,
+        poolSymbol: poolSymbol,
+      },
+    },
+  } as IContractWrite<
+    typeof balancerPoolCreationHelperAbi,
+    "createAndJoinWeightedPool"
+  >;
+};
+
+export const useCreatePool = ({
+  poolCreateTokens,
+  initialLiquidityTokens,
+  normalizedWeights,
+  poolType,
+  poolName,
+  poolSymbol,
+  swapFee,
+  owner,
+  amplification,
+  oracles,
+  weightsDuplicationThreshold = DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD,
+  ...baseArgs
+}: UseCreatePoolProps): UseCreatePoolReturn => {
+  // 1. identify if the pool is a duplicate
+  const {
+    data: dupePool,
+    error: errorLoadingPools,
+    isLoading: isLoadingPools,
+  } = useSWRImmutable<SubgraphPoolFragment | null>(
+    [
+      "useCreatePool__deduped_pool",
+      poolCreateTokens,
+      poolType,
+      normalizedWeights,
+    ],
+    async () => {
+      if (poolCreateTokens.length === 0 || !poolType) {
+        return null;
+      }
+      const bexSubgraphClient = getApolloClient("bex.subgraph", {});
+      try {
+        // NOTE: it should not be possible for native token to be in poolCreateTokens
+        const tokensSorted = wrapNativeTokens(poolCreateTokens)
+          .map((token) => token.address.toLowerCase())
+          .sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : 1));
+
+        // fetch pools of the same type as the one we are creating
+        const res = await bexSubgraphClient.query<GetDedupedSubgraphPoolsQuery>(
+          {
+            query: GetDedupedSubgraphPools,
+            variables: {
+              tokens: tokensSorted,
+              type: poolType,
+            },
+          },
+        );
+
+        const matchingPools = res.data.pools.filter((pool) => {
+          return pool.tokens?.every((token) =>
+            poolType === PoolType.Weighted
+              ? // in weighted pools, a dupe is if tokens and weights match within tolerance FIXME: we aren't getting weighted pools returned here
+                tokensSorted.includes(token.address) &&
+                Math.abs(
+                  Number(token.weight) -
+                    Number(
+                      formatUnits(
+                        normalizedWeights[tokensSorted.indexOf(token.address)],
+                        18,
+                      ),
+                    ),
+                ) < weightsDuplicationThreshold
+              : // in composable pools a dupe is if the tokens match, handling that the LP token is in the tokens list
+                tokensSorted.includes(token.address) ||
+                token.address === pool.address,
+          );
+        });
+
+        return matchingPools?.at(0) ?? null;
+      } catch {
+        return null;
+      }
+    },
+  );
+
+  // Generated names
+  const { generatedPoolName, generatedPoolSymbol } = useMemo(() => {
+    if (!poolCreateTokens) {
+      return {
+        generatedPoolName: "",
+        generatedPoolSymbol: "",
+      };
+    }
+    const generatedPoolName = generatePoolName(poolCreateTokens);
+    const generatedPoolSymbol = generatePoolSymbol(
+      poolCreateTokens,
+      normalizedWeights,
+      poolType,
+    );
+
+    return {
+      generatedPoolName,
+      generatedPoolSymbol,
+    };
+  }, [poolCreateTokens, normalizedWeights, poolType]);
+
+  // Pool create tx
+  const createPoolArgs = useMemo(() => {
+    if (
+      !owner ||
+      poolName === "" ||
+      poolSymbol === "" ||
+      poolCreateTokens.length !== initialLiquidityTokens.length ||
+      poolCreateTokens.length === 0
+    ) {
+      return null;
+    }
+
+    const swapFeePercentage = parseUnits(swapFee.toString(), 16);
+    const salt = keccak256(Buffer.from(`${poolName}-${owner}`));
+    const { config: chainConfig } = parseBaseArgs(baseArgs);
+
+    if (poolType === PoolType.Weighted) {
+      return createWeightedPoolArgs({
+        poolCreationHelper: chainConfig.bex.poolCreationHelper,
+        poolCreateTokens,
+        initialLiquidityTokens,
+        normalizedWeights,
+        swapFeePercentage,
+        salt,
+        poolName,
+        poolSymbol,
+        owner,
+        message: `Create pool ${poolName}`,
+        actionType: TransactionActionType.CREATE_POOL,
+      });
+    }
+
+    if (
+      poolType === PoolType.ComposableStable ||
+      poolType === PoolType.MetaStable
+    ) {
+      return createStablePoolArgs({
+        poolCreationHelper: chainConfig.bex.poolCreationHelper,
+        poolCreateTokens,
+        initialLiquidityTokens,
+        swapFeePercentage,
+        salt,
+        poolName,
+        poolSymbol,
+        owner,
+        amplification,
+        oracles,
+        message: `Create pool ${poolName}`,
+        actionType: TransactionActionType.CREATE_POOL,
+      });
+    }
+
+    return null;
+  }, [
+    poolCreateTokens,
+    initialLiquidityTokens,
+    normalizedWeights,
+    poolType,
+    swapFee,
+    poolName,
+    poolSymbol,
+    owner,
+    amplification,
+    oracles,
+  ]);
+
+  return {
+    generatedPoolName,
+    generatedPoolSymbol,
+    isDupePool: !!dupePool,
+    dupePool,
+    createPoolArgs,
+    isLoadingPools,
+    errorLoadingPools,
+  };
+};

package/src/hooks/dex/useExploitedTokens.ts

@@ -0,0 +1,57 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getIsTokenExploited } from "~/actions/dex/getIsTokenExploited";
+import { assertPublicClient } from "~/errors/assert";
+import type { Token } from "~/types/dex";
+
+export const useExploitedTokensQueryKey = (tokens: Token[] | undefined) => {
+  const filteredTokens = tokens?.filter((token) => token.address);
+  if (!filteredTokens || filteredTokens.length === 0) {
+    return null;
+  }
+  return ["useExploitedTokens", filteredTokens] as const;
+};
+/**
+ * This hook checks if any of provided tokens might have been exploited by frontrunning its deployment.
+ *
+ * @see {@link getIsTokenExploited} for more details
+ * @returns a record of tokens and whether they might have been exploited
+ */
+export const useExploitedTokens = ({
+  tokens,
+}: {
+  tokens: Token[] | undefined;
+}) => {
+  const QUERY_KEY = useExploitedTokensQueryKey(tokens);
+  const publicClient = usePublicClient();
+  const swrResponse = useSWR(
+    publicClient ? QUERY_KEY : null,
+    async ([, tokens]) => {
+      assertPublicClient(publicClient);
+
+      const exploitedTokens = await Promise.all(
+        tokens.map((token) =>
+          getIsTokenExploited({
+            token,
+            publicClient,
+          }),
+        ),
+      );
+
+      return exploitedTokens.reduce<Record<Address, boolean>>(
+        (acc, curr, idx) => {
+          if (curr !== undefined) {
+            acc[tokens[idx].address] = curr;
+          }
+          return acc;
+        },
+        {},
+      );
+    },
+  );
+
+  return { ...swrResponse, refresh: () => swrResponse.mutate() };
+};

package/src/hooks/dex/useGlobalLiquidityAndSwapVolume.ts

@@ -0,0 +1,22 @@
+import useSWR from "swr";
+
+import { getGlobalLiquidityAndSwapVolume } from "~/actions/dex/getGlobalLiquidityAndSwapVolume";
+
+export const useGlobalLiquidityAndSwapVolume = () => {
+  const response = useSWR("useGlobalLiquidityAndSwapVolume", async () =>
+    getGlobalLiquidityAndSwapVolume(),
+  );
+
+  return {
+    ...response,
+    data: {
+      totalLiquidity: Number(
+        response.data?.protocolMetricsAggregated.totalLiquidity,
+      ),
+      swapVolume24h: Number(
+        response.data?.protocolMetricsAggregated.swapVolume24h,
+      ),
+    },
+    refresh: () => response.mutate(),
+  };
+};

package/src/hooks/dex/useLiquidityMismatch.ts

@@ -0,0 +1,192 @@
+import { useEffect, useState } from "react";
+import { PoolType } from "@berachain-foundation/berancer-sdk";
+
+import { PoolCreationStep } from "~/enum/dex";
+import type { TokenCurrentPriceMap, TokenWithAmount } from "~/types/dex";
+import { wrapNativeTokens } from "~/utils/tokenWrapping";
+import { type Oracle, OracleMode } from "./useCreatePool";
+
+const DEFAULT_LIQUIDITY_MISMATCH_TOLERANCE_PERCENT = 0.05; // 5%
+
+export type LiquidityMismatchInfo = {
+  title: string | null;
+  message: string | null;
+  suggestWeighted?: boolean;
+};
+
+interface UseLiquidityMismatchParams {
+  currentStep: PoolCreationStep;
+  tokenPrices?: TokenCurrentPriceMap;
+  isLoadingTokenPrices: boolean;
+  tokens: TokenWithAmount[] | null;
+  weights: bigint[] | null;
+  weightsError: string | null;
+  poolType: PoolType;
+  liquidityMismatchTolerancePercent?: number;
+  oracles: Oracle[];
+}
+
+/**
+ * Hook for detecting liquidity mismatches.
+ *
+ * @param {PoolCreationStep} currentStep - The current step of the pool creation process.
+ * @param {Record<string, number>} tokenPrices - The current token prices.
+ * @param {boolean} isLoadingTokenPrices - Whether the token prices are still loading.
+ * @param {Array<{ address: string, amount: number }>} tokens - The tokens in the pool, including their addresses and amounts.
+ * @param {Record<string, number>} weights - The per-token weights in the pool we are creating.
+ * @param {string | null} weightsError - An error message for the weights indicating that the weights are invalid.
+ * @param {string} poolType - The type of pool being created.
+ * @param {number} liquidityMismatchTolerancePercent - The tolerance for liquidity mismatches in percent.
+ * @returns {Object} The liquidity mismatch info.
+ */
+export const useLiquidityMismatch = ({
+  currentStep,
+  tokenPrices,
+  isLoadingTokenPrices,
+  tokens,
+  weights,
+  weightsError,
+  poolType,
+  liquidityMismatchTolerancePercent = DEFAULT_LIQUIDITY_MISMATCH_TOLERANCE_PERCENT,
+  oracles,
+}: 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] =
+    useState<LiquidityMismatchInfo>({ title: null, message: null });
+
+  useEffect(() => {
+    // If we are either using custom rate-providing oracles or have incorrect/loading token prices, we cant do validation.
+    if (
+      !tokenPrices ||
+      isLoadingTokenPrices ||
+      !tokens ||
+      !weights ||
+      weightsError ||
+      tokens.some((token) => !token.address) ||
+      oracles.some((oracle) => oracle.mode === OracleMode.Custom) // Oracles give prices on their own, we dont support that here yet.
+    ) {
+      setLiquidityMismatchInfo({ title: null, message: null });
+      return;
+    }
+
+    // Calculate some basic metrics we'll use to determine per-token contributions and model potential losses from arbitrage.
+    let totalLiquidityUSD = 0;
+    const tokenUSDAmounts: number[] = [];
+    const numTokens = tokens.length;
+    const wrappedTokens = wrapNativeTokens(tokens);
+    const tokenUSDPrices = wrappedTokens.map((token) => {
+      const tokenPriceUSD =
+        tokenPrices[token.address.toLowerCase()]?.price ?? 0;
+      if (!tokenPriceUSD || tokenPriceUSD === 0) {
+        tokenUSDAmounts.push(0);
+        return null;
+      }
+      const tokenAmountUSD = tokenPriceUSD * Number.parseFloat(token.amount);
+      tokenUSDAmounts.push(tokenAmountUSD);
+      totalLiquidityUSD += tokenAmountUSD;
+      return tokenPriceUSD;
+    });
+
+    // Doesn't matter what step it is, if we have missing token prices for tokens we have selected, we cant issue a real warning.
+    if (
+      tokenUSDPrices.some((price) => price === null) ||
+      tokenUSDPrices.length !== numTokens
+    ) {
+      setLiquidityMismatchInfo({
+        title: "Missing token price data",
+        message: `One or more token(s) do not have valid market price data. Please verify that token market prices align with the pool
+                  weightings and your initial liquidity amounts.`,
+      });
+      return;
+    }
+
+    // Step 1 - During token selection we check for a deviation in the quote prices of the tokens selected (for stable pools).
+    if (
+      currentStep === PoolCreationStep.SELECT_TOKENS &&
+      poolType === PoolType.ComposableStable
+    ) {
+      const normalizedUSDPrices = tokenUSDPrices.map(
+        (priceUSD) => priceUSD! / tokenUSDPrices[0]!, // always normalize on the first token's price
+      );
+      const maxDifference =
+        Math.max(...normalizedUSDPrices) - Math.min(...normalizedUSDPrices);
+
+      if (maxDifference > liquidityMismatchTolerancePercent) {
+        setLiquidityMismatchInfo({
+          title: "Selected tokens have a significant price deviation",
+          message: "Did you mean to create a Weighted pool instead?",
+          suggestWeighted: true,
+        });
+      } else {
+        setLiquidityMismatchInfo({ title: null, message: null });
+      }
+
+      return;
+    }
+
+    // Validation During Liquidity Input and onwards.
+    if (
+      totalLiquidityUSD === 0 ||
+      tokenUSDAmounts.some((value) => value === 0)
+    ) {
+      // User has not yet entered fully their liquidity values, so return early.
+      setLiquidityMismatchInfo({ title: null, message: null });
+      return;
+    }
+
+    // Simulate arbitrage for the pool to determine potential losses from arbitrageurs.
+    // NOTE: we assume shortfalls and excesses are losses, but in reality the actual losses would be more complex to realise.
+    // Balancer does this similarily https://github.com/balancer/frontend-v2/blob/8563b8d33b6bff266148bd48d7ebc89f921374f4/src/components/cards/CreatePool/InitialLiquidity.vue#L75
+    let totalLossUSD = 0;
+    if (poolType === PoolType.ComposableStable) {
+      const expectedPerTokenLiquidityUSD = totalLiquidityUSD / numTokens;
+      tokenUSDAmounts.forEach((value) => {
+        totalLossUSD += Math.abs(expectedPerTokenLiquidityUSD - value);
+      });
+    } else if (poolType === PoolType.Weighted) {
+      tokenUSDAmounts.forEach((value, index) => {
+        const weightProportion = Number(weights[index]) / 1e18;
+        const expectedValueUSD = totalLiquidityUSD * weightProportion;
+        totalLossUSD += Math.abs(expectedValueUSD - value);
+      });
+    }
+
+    // We'll show a total loss if it's 90% or more
+    const isTotalLoss = totalLossUSD >= totalLiquidityUSD * 0.9;
+    totalLossUSD = Math.min(totalLossUSD, totalLiquidityUSD);
+    const totalLossPercentage = totalLossUSD / totalLiquidityUSD;
+
+    if (totalLossPercentage > liquidityMismatchTolerancePercent) {
+      setLiquidityMismatchInfo({
+        // If it's a total loss we dont display a percentage
+        title: isTotalLoss
+          ? "You could lose all of your initial liquidity"
+          : `You could lose $${totalLossUSD.toFixed(2)} (~${(
+              totalLossPercentage * 100
+            ).toFixed(2)}%)`,
+        message: `Based on the market token prices, the value of tokens does not align with the specified pool weights. 
+          This discrepancy could expose you to potential losses from arbitrageurs. ${
+            poolType === PoolType.ComposableStable
+              ? "Did you mean to create a Weighted pool instead?"
+              : ""
+          }`,
+        suggestWeighted: poolType === PoolType.ComposableStable,
+      });
+    } else {
+      // All good bb bb
+      setLiquidityMismatchInfo({ title: null, message: null });
+    }
+  }, [
+    currentStep,
+    tokenPrices,
+    isLoadingTokenPrices,
+    tokens,
+    weights,
+    weightsError,
+    poolType,
+    liquidityMismatchTolerancePercent,
+    oracles,
+  ]);
+  return liquidityMismatchInfo;
+};