@berachain/berajs 0.1.1 → 0.1.2

package/src/actions/dex/aggregators/openOcean.ts

@@ -0,0 +1,142 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { assertPublicClient, InvalidArgumentError } from "~/errors";
+import { RequestError } from "~/errors/RequestError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { BaseAggregator } from "./base";
+
+class OpenOceanAggregator extends BaseAggregator {
+  name = Aggregators.OpenOcean;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+  readonly url = "https://open-api.openocean.finance/v4/bera/swap";
+
+  notFoundMessages = ["No avail liquidity for the pair"];
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    aggregatorsFeeBps,
+    tokenInDecimals,
+    publicClient,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    assertPublicClient(publicClient);
+
+    if (!tokenInDecimals) {
+      throw new InvalidArgumentError({
+        property: "tokenInDecimals",
+        value: tokenInDecimals,
+        expected: "number",
+        chainId: this.chainId,
+      });
+    }
+
+    this.checkChainSupport();
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn, tokenOut);
+
+    const gasPrice = (await publicClient.getGasPrice()).toString();
+
+    const quoteParams = new URLSearchParams({
+      chain: ChainId.MAINNET.toString(),
+      inTokenAddress: tokenInAddress,
+      outTokenAddress: tokenOutAddress,
+      amountDecimals: inputAmountAfterFees,
+      // OpenOcean requires slippage to be at least 0.01%
+      slippage: slippage < 0.01 ? "0.01" : slippage.toString(),
+      account: this.config.bex.aggregatorsRouterExecutor,
+      referrer: this.config.bex.aggregatorsRouter,
+      gasPrice,
+    });
+
+    const quoteResponse = await this.fetch(
+      `${this.url}?${quoteParams.toString()}`,
+    );
+
+    const quoteData = await quoteResponse.json();
+
+    // validate successful quote response
+    if (quoteData.code !== 200 || !quoteData.data) {
+      const isNotFound = this.notFoundMessages.some((message) =>
+        quoteData.error.includes(message),
+      );
+
+      throw new RequestError({
+        response: quoteResponse,
+        endpoint: { url: this.url, name: this.name, type: this.type },
+        cause: quoteData,
+        reason: isNotFound
+          ? BaseAggregator.PATH_NOT_FOUND_REASON
+          : quoteData.error,
+      });
+    }
+
+    const formattedQuote = {
+      amountOut: quoteData.data.outAmount,
+      amountIn: amount,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+    };
+
+    const inputData = this.getInputData({
+      tokenIn: tokenInAddress,
+      amountIn: amount,
+      isNative: isTokenInNative,
+    });
+
+    const outputData = {
+      tokenOut: tokenOutAddress,
+      receiver: account,
+      minAmountOut: this.getMinAmountOut(formattedQuote.amountOut, slippage),
+      isNative: isTokenOutNative,
+    };
+
+    const aggregatorData = {
+      aggregator: quoteData.data.to,
+      data: quoteData.data.data,
+    };
+
+    return {
+      ...formattedQuote,
+      calldata: {
+        params: [
+          inputData,
+          outputData,
+          aggregatorData,
+          {
+            rewardVault: rewardVault ?? zeroAddress,
+            isSwapAndStake: !!rewardVault,
+          },
+        ],
+        functionName: "swap",
+        abi: aggregatorsRouterAbi,
+        // send full amount to router first, which will deduct the swap fee before executing trade
+        value: isTokenInNative ? BigInt(amount) : BigInt("0"),
+        address: this.config.bex.aggregatorsRouter,
+      },
+    };
+  }
+}
+
+export const openOcean = new OpenOceanAggregator();

package/src/actions/dex/aggregators/wbera.ts

@@ -0,0 +1,72 @@
+import { ChainId } from "@berachain/config/internal";
+
+import { wberaAbi } from "~/abi/pol/wbera";
+import { BeraError } from "~/errors/BeraError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import type { IContractWrite } from "~/types/global";
+import { isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+class WBeraAggregator extends BaseAggregator {
+  name = Aggregators.Wrap;
+  supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
+  readonly type = "rpc";
+
+  // handles native swaps: wrap and unwrap
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+  }: Omit<IAggregatorArgs, "slippage" | "feeBps">): Promise<
+    IRawAggregatorQuote<false>
+  > {
+    this.checkChainSupport();
+
+    if (
+      (!isToken(tokenIn, "BERA") && !isToken(tokenIn, "WBERA")) ||
+      (!isToken(tokenOut, "WBERA") && !isToken(tokenOut, "BERA"))
+    ) {
+      throw new BeraError({
+        message: "Invalid token pair",
+        level: "error",
+      });
+    }
+
+    const isWrap = isToken(tokenIn, "BERA") && isToken(tokenOut, "WBERA");
+    return {
+      amountOut: amount,
+      amountIn: amount,
+      spender: undefined,
+      name: isWrap ? Aggregators.Wrap : Aggregators.Unwrap,
+      isNativeSwap: true,
+      swapFeeBps: 0,
+      calldata: isWrap
+        ? ({
+            abi: wberaAbi,
+            address: this.config.tokens.wbera,
+            functionName: "deposit",
+            params: [],
+            value: BigInt(amount),
+          } satisfies Omit<
+            IContractWrite<typeof wberaAbi, "deposit">,
+            "message" | "actionType"
+          >)
+        : ({
+            abi: wberaAbi,
+            address: this.config.tokens.wbera,
+            functionName: "withdraw",
+            params: [BigInt(amount)],
+            value: BigInt(0),
+          } satisfies Omit<
+            IContractWrite<typeof wberaAbi, "withdraw">,
+            "message" | "actionType"
+          >),
+    };
+  }
+}
+
+export const wberaSwap = new WBeraAggregator();

package/src/actions/dex/b-sdk.ts

@@ -0,0 +1,48 @@
+import {
+  API_CHAIN_NAMES,
+  BALANCER_QUERIES,
+  BALANCER_RELAYER,
+  BalancerApi,
+  CHAINS,
+  COMPOSABLE_STABLE_POOL_FACTORY,
+  NATIVE_ASSETS,
+  Token,
+  VAULT,
+  WEIGHTED_POOL_FACTORY_BALANCER_V2,
+} from "@berachain-foundation/berancer-sdk";
+import { zeroAddress } from "viem";
+import { berachain, berachainBepolia } from "viem/chains";
+
+import { type ChainId, chainConfigs } from "@berachain/config/internal";
+
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { beraToken } from "~/utils/tokens";
+
+for (const chain of Object.keys(chainConfigs)) {
+  const { config, chainId } = parseBaseArgs({
+    chainId: Number(chain) as ChainId,
+  });
+
+  API_CHAIN_NAMES[chainId] = config.bex.chainName;
+  // @ts-expect-error
+  CHAINS[chainId] = chainId === berachain.id ? berachain : berachainBepolia;
+  BALANCER_RELAYER[chainId] = config.bex.relayer;
+  VAULT[chainId] = config.bex.vault;
+  BALANCER_QUERIES[chainId] = config.bex.queries;
+
+  WEIGHTED_POOL_FACTORY_BALANCER_V2[chainId] = zeroAddress;
+  COMPOSABLE_STABLE_POOL_FACTORY[chainId] = zeroAddress;
+
+  const nativeToken = new Token(
+    chainId,
+    zeroAddress,
+    beraToken.decimals,
+    beraToken.name,
+    beraToken.symbol,
+    config.tokens.wbera,
+  );
+  // @ts-expect-error not in network list
+  NATIVE_ASSETS[chainId] = nativeToken;
+}
+
+export { BalancerApi };

package/src/actions/dex/getAllPools.ts

@@ -0,0 +1,60 @@
+import type { FetchPolicy } from "@apollo/client";
+
+import {
+  GetPools,
+  type GetPoolsQuery,
+  type GetPoolsQueryVariables,
+} from "@berachain/graphql/dex/api";
+import {
+  type GqlChain,
+  GqlPoolOrderBy,
+  GqlPoolOrderDirection,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getAllPools({
+  textSearch,
+  chain,
+  first,
+  orderBy,
+  orderDirection,
+  skip,
+  fetchPolicy,
+  userAddress,
+  blacklistedPoolIds,
+  ...args
+}: Partial<
+  GetPoolsQueryVariables & {
+    fetchPolicy: FetchPolicy;
+  }
+> &
+  BeraJS.BaseFunctionArgs = {}) {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const pools = await bexApiGraphqlClient.query<
+    GetPoolsQuery,
+    GetPoolsQueryVariables
+  >({
+    query: GetPools,
+    variables: {
+      textSearch,
+      chain: chain ?? (config.bex.chainName as GqlChain),
+      first,
+      orderBy: orderBy ?? GqlPoolOrderBy.TotalLiquidity,
+      orderDirection: orderDirection ?? GqlPoolOrderDirection.Desc,
+      skip,
+      userAddress,
+      blacklistedPoolIds,
+    },
+    fetchPolicy: fetchPolicy,
+  });
+
+  return {
+    pools: pools.data.poolGetPools ?? [],
+    count: pools.data.count ?? 0,
+  };
+}

package/src/actions/dex/getApiPool.ts

@@ -0,0 +1,47 @@
+import type { Address } from "viem";
+
+import {
+  GetPool,
+  type GetPoolQuery,
+  type GetPoolQueryVariables,
+} from "@berachain/graphql/dex/api";
+import type { GqlChain } from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getApiPool({
+  poolId,
+  account,
+  ...args
+}: {
+  poolId: string;
+  account?: Address | undefined;
+} & BeraJS.BaseFunctionArgs) {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const pool = await bexApiGraphqlClient.query<
+    GetPoolQuery,
+    GetPoolQueryVariables
+  >({
+    query: GetPool,
+    variables: {
+      id: poolId,
+      userAddress: account,
+      chain: config.bex.chainName as GqlChain,
+    },
+    fetchPolicy: "no-cache", // If we cache it seems to return an empty response
+  });
+
+  // Transform the result to match the BalancerApiPoolResult type
+  const data = pool.data.poolGetPool;
+  if (!data) {
+    throw new Error(`Pool not found for id: ${poolId} and user ${account}`);
+  }
+
+  // NOTE: we need to be able to use the output here with b-sdk's PoolState to add / withdraw liquidity, so we do some casting.
+  // If we want to avoid this, we could instead update b-sdk ourselves to pull rewardVault to pull like we do here.
+  // (see PoolStateWithBalancesAndDynamicData, packages/b-sdk/src/data/providers/balancer-api/modules/pool-state/index.ts)
+  return data;
+}

package/src/actions/dex/getGlobalLiquidityAndSwapVolume.ts

@@ -0,0 +1,29 @@
+import {
+  GetGlobalLiquidityAndSwapVolume,
+  type GetGlobalLiquidityAndSwapVolumeQuery,
+  type GetGlobalLiquidityAndSwapVolumeQueryVariables,
+  type GqlChain,
+} from "@berachain/graphql/dex/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getGlobalLiquidityAndSwapVolume(
+  args: BeraJS.BaseFunctionArgs = {},
+) {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const response = await bexApiGraphqlClient.query<
+    GetGlobalLiquidityAndSwapVolumeQuery,
+    GetGlobalLiquidityAndSwapVolumeQueryVariables
+  >({
+    query: GetGlobalLiquidityAndSwapVolume,
+    variables: {
+      chain: config.bex.chainName as GqlChain,
+    },
+  });
+
+  return response.data;
+}

package/src/actions/dex/getIsTokenExploited.ts

@@ -0,0 +1,63 @@
+import BigNumber from "bignumber.js";
+import { erc20Abi, formatUnits, type PublicClient } from "viem";
+
+import {
+  GetExploitedTokens,
+  type GetExploitedTokensQuery,
+  type GetExploitedTokensQueryVariables,
+} from "@berachain/graphql/dex/subgraph";
+
+import type { Token } from "~/types";
+import { getApolloClient } from "../clients/getApolloClient";
+
+/**
+ * 0.01% of the total supply
+ */
+const BEX_EXPLOITED_TOKEN_THRESHOLD = 0.0001 as const;
+
+/**
+ * This function checks if a token was exploited by frontrunning its deployment
+ * and creating a large amount of balance in the BEX's vault internal balance.
+ *
+ * There is a vulnerability on Balancer V2 that might lead an hacker to create a lot of internal balance of a token before it's
+ * actually deployed. In this function we're checking if wallet has an internal balance of more than BEX_EXPLOITED_TOKEN_THRESHOLD
+ *
+ * @see https://forum.balancer.fi/t/balancer-v2-token-frontrun-vulnerability-disclosure/6309
+ * @returns true if the token might have been exploited, false otherwise
+ */
+export async function getIsTokenExploited({
+  token,
+  publicClient,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  token: Token;
+  publicClient: PublicClient;
+}) {
+  const bexSubgraphClient = getApolloClient("bex.subgraph", args);
+
+  const totalSupply = await publicClient.readContract({
+    address: token.address,
+    abi: erc20Abi,
+    functionName: "totalSupply",
+  });
+  const balanceThreshold = BigNumber(
+    formatUnits(totalSupply, token.decimals),
+  ).multipliedBy(BEX_EXPLOITED_TOKEN_THRESHOLD);
+
+  const { data } = await bexSubgraphClient.query<
+    GetExploitedTokensQuery,
+    GetExploitedTokensQueryVariables
+  >({
+    query: GetExploitedTokens,
+    variables: {
+      token: token.address,
+      balance: balanceThreshold.toFixed(),
+    },
+  });
+
+  if (data.userInternalBalances.length > 0) {
+    return true;
+  }
+
+  return false;
+}

package/src/actions/dex/getOnChainPool.ts

@@ -0,0 +1,216 @@
+import {
+  stablePoolAbi_V3,
+  vaultV2Abi,
+  weightedPoolFactoryAbi_V3,
+  weightedPoolV4Abi_V2,
+} from "@berachain-foundation/berancer-sdk";
+import {
+  type Address,
+  erc20Abi,
+  formatEther,
+  formatUnits,
+  type Hex,
+  isAddress,
+  isHex,
+  type PublicClient,
+} from "viem";
+
+import { GqlPoolType } from "@berachain/graphql/pol/api";
+
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { initBeraError } from "~/errors/initBeraError";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getPoolPausedState, type PoolStatus } from "./getPoolPausedState";
+
+export interface OnChainPool {
+  pausedState: PoolStatus;
+  address: Address;
+  id: Hex;
+  name: string;
+
+  poolTokens: [
+    /**
+     * The addresses of the tokens in the pool
+     */
+    readonly Address[],
+    /**
+     * The balances of the tokens in the pool
+     */
+    string[],
+    /**
+     * The last change block of the pool
+     */
+    number,
+  ];
+  totalSupply: string;
+  swapFee: string;
+  decimals: number;
+  weights: readonly string[] | undefined;
+  version: any;
+  factory: Address;
+  type: GqlPoolType;
+  /**
+   * For example, if value is 300000n and precision is 1000n, the user-set amplification parameter would be 300000n / 1000n = 300n.
+   *
+   * The first number is the raw value, the second number is a boolean indicating if the amplification parameter is being updated, and the third number is the precision factor.
+   * @see https://github.com/balancer/docs-developers/blob/main/references/valuing-balancer-lp-tokens/pools/stablepools.md#getamplificationparameter
+   */
+  amplificationParameter: readonly [number, boolean, number] | undefined;
+}
+
+export async function getOnChainPool({
+  poolId,
+  publicClient,
+  ...args
+}: {
+  poolId: string;
+  publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<OnChainPool> {
+  const { config } = parseBaseArgs(args);
+  const address = poolId.slice(0, 42) as Address;
+  if (!isAddress(address) || !isHex(poolId)) {
+    throw new InvalidArgumentError({
+      property: "poolId",
+      value: poolId,
+      expected: "Hex",
+    });
+  }
+  try {
+    const [
+      name,
+      poolTokens,
+      totalSupply,
+      swapFee,
+      _version,
+      _decimals,
+      isComposableStable,
+      isWeighted,
+      poolPausedState,
+    ] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: erc20Abi,
+        functionName: "name",
+      }),
+      publicClient.readContract({
+        address: config.bex.vault,
+        abi: vaultV2Abi,
+        functionName: "getPoolTokens",
+        args: [poolId],
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi,
+        functionName: "totalSupply",
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V2,
+        functionName: "getSwapFeePercentage",
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V2,
+        functionName: "version",
+      }),
+      publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V2,
+        functionName: "decimals",
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.composableStable,
+        abi: weightedPoolFactoryAbi_V3,
+        functionName: "isPoolFromFactory",
+        args: [address],
+      }),
+      publicClient.readContract({
+        address: config.bex.factories.weighted,
+        abi: weightedPoolFactoryAbi_V3,
+        functionName: "isPoolFromFactory",
+        args: [address],
+      }),
+      getPoolPausedState({ publicClient, poolAddress: address }),
+    ]);
+
+    const decimals = Number(_decimals);
+    const version = JSON.parse(_version);
+
+    let virtualSupply: bigint | undefined;
+    let weights: readonly bigint[] | undefined;
+    let amplificationParameter: readonly [bigint, boolean, bigint] | undefined;
+
+    if (isComposableStable) {
+      // This returns the actual supply excluding preminted BPTs
+      [virtualSupply, amplificationParameter] = await Promise.all([
+        publicClient.readContract({
+          address,
+          abi: [
+            {
+              type: "function",
+              name: "getActualSupply",
+              stateMutability: "view",
+              inputs: [],
+              outputs: [
+                {
+                  type: "uint256",
+                },
+              ],
+            },
+          ],
+          functionName: "getActualSupply",
+        }),
+        // NOTE: it is possible to pull this from the subgraph, but not using GqlPoolBase, we'd have to query a specific pool type.
+        publicClient.readContract({
+          address,
+          abi: stablePoolAbi_V3,
+          functionName: "getAmplificationParameter",
+        }),
+      ]);
+    } else if (version.name === "WeightedPool") {
+      weights = await publicClient.readContract({
+        address,
+        abi: weightedPoolV4Abi_V2,
+        functionName: "getNormalizedWeights",
+      });
+    }
+
+    if (!isComposableStable && !isWeighted) {
+      throw new Error(`Pool ${address} is not a valid BEX pool`);
+    }
+
+    return {
+      name,
+      address,
+      id: poolId,
+      poolTokens: [
+        poolTokens[0],
+        poolTokens[1].map(String),
+        Number(poolTokens[2]),
+      ],
+      totalSupply: formatUnits(virtualSupply ?? totalSupply, decimals),
+      swapFee: formatEther(swapFee),
+      decimals,
+      weights: weights?.map((weight) => formatEther(weight)),
+      version,
+      factory: isComposableStable
+        ? config.bex.factories.composableStable
+        : config.bex.factories.weighted,
+      type: isComposableStable ? GqlPoolType.Stable : GqlPoolType.Weighted,
+
+      amplificationParameter: amplificationParameter
+        ? [
+            // raw value
+            Number(amplificationParameter[0]),
+            // is updating
+            amplificationParameter[1],
+            // precision factor
+            Number(amplificationParameter[2]),
+          ]
+        : undefined,
+      pausedState: poolPausedState,
+    };
+  } catch (e) {
+    throw initBeraError({ cause: e });
+  }
+}