@berachain/berajs 0.1.1 → 0.2.0

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

@@ -0,0 +1,84 @@
+import { ChainId } from "@berachain/config/internal";
+
+import { wberaAbi } from "~/abi/pol/wbera";
+import { Aggregators } from "~/enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote, Token } from "~/types/dex";
+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";
+
+  checkChainSupport({
+    tokenIn,
+    tokenOut,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+  }): boolean {
+    if (
+      // same chain
+      tokenIn.chainId !== tokenOut.chainId ||
+      // must be one of our chains
+      !super.checkChainSupport({ tokenIn, tokenOut })
+    ) {
+      return false;
+    }
+
+    return (
+      (isToken(tokenIn, "BERA") && isToken(tokenOut, "WBERA")) ||
+      (isToken(tokenIn, "WBERA") && isToken(tokenOut, "BERA"))
+    );
+  }
+
+  // handles native swaps: wrap and unwrap
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+  }: Omit<
+    IAggregatorArgs,
+    "slippage" | "feeBps"
+  >): Promise<IRawAggregatorQuote> {
+    this.assertChainSupport({ tokenIn, tokenOut });
+
+    const isWrap = isToken(tokenIn, "BERA") && isToken(tokenOut, "WBERA");
+
+    return {
+      amountOut: amount,
+      amountIn: amount,
+      allowanceRequirements: [],
+      name: isWrap ? Aggregators.Wrap : Aggregators.Unwrap,
+      isNativeSwap: true,
+      swapFeeBps: 0,
+      getCalldata: () => {
+        return 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,51 @@
+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;
+
+  // this needs to be typed this way, because leaving @ts-expect-error
+  // is incredibly expensive (TypeScript takes 4 seconds to compile)
+  (CHAINS as Record<number, any>)[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 { erc20Abi, formatUnits, type PublicClient } from "viem";
+
+import {
+  GetExploitedTokens,
+  type GetExploitedTokensQuery,
+  type GetExploitedTokensQueryVariables,
+} from "@berachain/graphql/dex/subgraph";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import type { Token } from "~/types/dex";
+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 });
+  }
+}

package/src/actions/dex/getPoolEvents.ts

@@ -0,0 +1,35 @@
+import {
+  GetPoolEvents,
+  type GetPoolEventsQuery,
+  type GetPoolEventsQueryVariables,
+} from "@berachain/graphql/dex/api";
+import type { GqlChain, GqlPoolEventType } from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getPoolEvents({
+  poolId,
+  typeInArray,
+  ...args
+}: {
+  poolId: string;
+  typeInArray: GqlPoolEventType[];
+} & BeraJS.BaseFunctionArgs) {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query<
+    GetPoolEventsQuery,
+    GetPoolEventsQueryVariables
+  >({
+    query: GetPoolEvents,
+    variables: {
+      poolId,
+      typeIn: typeInArray,
+      chain: config.bex.chainName as GqlChain,
+    },
+  });
+
+  return response.data;
+}

package/src/actions/dex/getPoolHistoricalData.ts

@@ -0,0 +1,51 @@
+import { isHex } from "viem";
+
+import {
+  GetPoolHistoricalData,
+  type GetPoolHistoricalDataQuery,
+  type GetPoolHistoricalDataQueryVariables,
+  type GqlChain,
+  type PoolHistoricalDataFragment,
+} from "@berachain/graphql/dex/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+
+/** @deprecated */
+export type PoolDayData = {
+  date: number;
+  tvlUsd: string;
+  volumeUsd: string;
+  feesUsd: string;
+};
+
+interface GetPoolHistoricalDataProps {
+  poolId: string;
+  chain: GqlChain;
+}
+
+export async function getPoolHistoricalData({
+  poolId,
+  chain,
+  ...args
+}: GetPoolHistoricalDataProps & BeraJS.BaseFunctionArgs): Promise<
+  PoolHistoricalDataFragment[] | undefined
+> {
+  if (!poolId || !isHex(poolId))
+    throw new InvalidArgumentError({
+      property: "poolId",
+      value: poolId,
+      expected: "hex string",
+    });
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const { data } = await bexApiGraphqlClient.query<
+    GetPoolHistoricalDataQuery,
+    GetPoolHistoricalDataQueryVariables
+  >({
+    query: GetPoolHistoricalData,
+    variables: { poolId, chain },
+  });
+  return data.poolGetSnapshots;
+}

package/src/actions/dex/getPoolPausedState.ts

@@ -0,0 +1,40 @@
+import { weightedPoolV4Abi_V2 } from "@berachain-foundation/berancer-sdk";
+import type { Address, PublicClient } from "viem";
+
+export interface PoolStatus {
+  isPoolInRecoveryMode: boolean;
+  isPoolPaused: boolean;
+}
+
+export async function getPoolPausedState({
+  publicClient,
+  poolAddress,
+}: {
+  publicClient: PublicClient;
+  poolAddress: Address;
+}) {
+  const abi = weightedPoolV4Abi_V2;
+  // NOTE: we are only intersted in functions that span both ABIs, so I'll use weighted here. For SOME REASON. Balancer did
+  // not include inRecoveryMode etc in the stable ABI (despite it EXISTING in both weighted/stable) see for yourself:
+  // <scanner>/address/0xF7F214A9543c1153eF5DF2edCd839074615F248c/contract/80000/readContract#F28
+  // ... so we will just use the weighted ABI here no matter the pool type, just be mindful not to call any type-specific functions
+  const results = await publicClient.multicall({
+    contracts: [
+      {
+        address: poolAddress,
+        abi,
+        functionName: "inRecoveryMode",
+      },
+      {
+        address: poolAddress,
+        abi,
+        functionName: "getPausedState",
+      },
+    ],
+    allowFailure: false, // NOTE: this disallows partial failures of the multicall
+  });
+  return {
+    isPoolInRecoveryMode: results[0],
+    isPoolPaused: results[1][0],
+  } as PoolStatus;
+}