@berachain/berajs 0.1.0 → 0.1.2

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

@@ -0,0 +1,255 @@
+import {
+  type Address,
+  Slippage,
+  type SorSwapResult,
+  Swap,
+  SwapKind,
+  Token,
+  TokenAmount,
+} from "@berachain-foundation/berancer-sdk";
+import * as Sentry from "@sentry/nextjs";
+import { decodeFunctionData, formatEther, zeroAddress } from "viem";
+
+import { getUriFromLink } from "@berachain/config";
+import { ChainId } from "@berachain/config/internal";
+
+import { balancerVaultAbi } from "~/abi/bex/balancerVault";
+import { BalancerApi } from "~/actions/dex/b-sdk";
+import { assertPublicClient } from "~/errors/assert";
+import { BeraError } from "~/errors/BeraError";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { RequestError } from "~/errors/RequestError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+// Constants
+const DEFAULT_DEADLINE = 60 * 5; // default transaction deadline in seconds
+const STALE_PRICE_THRESHOLD = 0.05; // 5% threshold for stale prices
+const swapKind = SwapKind.GivenIn;
+
+class BexAggregator extends BaseAggregator {
+  name = Aggregators.HubPools;
+  supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
+  readonly url = getUriFromLink(this.config.api);
+  readonly type = "graphql";
+
+  /**
+   * Helper function to convert zero address to wrapped token address
+   */
+  private convertZeroToWrapped(address: Address): Address {
+    return isToken(address, "BERA") ? this.config.tokens.wbera : address;
+  }
+
+  /**
+   * Helper to calculate price impact percentage
+   */
+  private calculatePriceImpact(priceImpact: {
+    error: string | null;
+    priceImpact?: string;
+  }): number {
+    if (priceImpact.error) {
+      console.error("Swap price impact error", priceImpact);
+      return 0;
+    }
+
+    return Number(priceImpact.priceImpact);
+  }
+
+  /**
+   * Helper to check for stale SOR prices
+   */
+  private checkStalePrices(
+    onChainAmount: TokenAmount,
+    sorPaths: { pools: string[] }[],
+    sorAmount: string,
+    queryData: IAggregatorArgs,
+  ): void {
+    // Check for stale prices
+    const deltaFromSorAmount =
+      Number.parseFloat(formatEther(onChainAmount.scale18)) /
+      Number.parseFloat(sorAmount);
+
+    if (Math.abs(1 - deltaFromSorAmount) > STALE_PRICE_THRESHOLD) {
+      console.warn(
+        "SOR returned stale prices. Delta from return amount is more than 5%",
+        {
+          deltaFromSorAmount,
+        },
+      );
+
+      const error = new BeraError({
+        reason: "SOR_STALE_PRICES",
+        level: "warning",
+        message:
+          "SOR returned stale prices. Delta from return amount is more than 5%",
+      });
+      Sentry.captureException(error, {
+        level: "warning",
+        extra: {
+          deltaFromSorAmount,
+          pools: sorPaths.map((p) => p.pools),
+          onChainAmount: formatEther(onChainAmount.scale18),
+          sorAmount,
+          queryData,
+        },
+        fingerprint: ["SOR_STALE_PRICES"],
+      });
+    }
+  }
+
+  async getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote<false>> {
+    const balancerApi = new BalancerApi(
+      this.url,
+      // @ts-expect-error b-sdk has more chains than berajs
+      this.chainId,
+    );
+    const {
+      tokenIn,
+      tokenOut,
+      tokenInDecimals,
+      tokenOutDecimals,
+      amount,
+      slippage,
+      account = zeroAddress,
+      publicClient,
+    } = args;
+    this.checkChainSupport();
+
+    assertPublicClient(publicClient);
+
+    if (!tokenInDecimals) {
+      throw new InvalidArgumentError({
+        property: "tokenInDecimals",
+        value: tokenInDecimals,
+        expected: "number",
+        chainId: this.chainId,
+      });
+    }
+
+    if (!tokenOutDecimals) {
+      throw new InvalidArgumentError({
+        property: "tokenOutDecimals",
+        value: tokenOutDecimals,
+        expected: "number",
+        chainId: this.chainId,
+      });
+    }
+
+    const wberaIsBera = isToken(tokenIn, "BERA") || isToken(tokenOut, "BERA");
+
+    // Initialize tokens
+    const tokenInV3 = new Token(
+      this.chainId,
+      this.convertZeroToWrapped(tokenIn as Address),
+      tokenInDecimals,
+    );
+    const tokenOutV3 = new Token(
+      this.chainId,
+      this.convertZeroToWrapped(tokenOut as Address),
+      tokenOutDecimals,
+    );
+
+    const tokenAmount = TokenAmount.fromRawAmount(
+      tokenInV3,
+      amount as `${number}`,
+    );
+
+    // swap paths
+    const {
+      paths: sorPaths,
+      priceImpact,
+      returnAmount: sorAmount,
+    }: SorSwapResult = await balancerApi.sorSwapPaths.fetchSorSwapPaths({
+      // @ts-expect-error b-sdk has more chains than berajs
+      chainId: this.chainId,
+      tokenIn: tokenInV3.address,
+      tokenOut: tokenOutV3.address,
+      swapKind,
+      swapAmount: tokenAmount,
+    });
+
+    if (!sorPaths?.length) {
+      throw new RequestError({
+        response: undefined,
+        endpoint: {
+          url: this.url,
+          name: this.name,
+          type: this.type,
+        },
+        reason: BaseAggregator.PATH_NOT_FOUND_REASON,
+        chainId: this.chainId,
+        payload: {
+          tokenIn: tokenInV3.address,
+          tokenOut: tokenOutV3.address,
+          swapKind,
+          swapAmount: tokenAmount,
+        },
+        message: `No swap paths returned from Balancer API`,
+      });
+    }
+
+    // execute swap query
+    const swap = new Swap({
+      chainId: this.chainId,
+      paths: sorPaths,
+      swapKind,
+      userData: "0x" as `0x${string}`,
+    });
+    const queryOutput = await swap.query(publicClient.transport.url);
+
+    if (!("expectedAmountOut" in queryOutput)) {
+      throw new Error("No Bex paths found");
+    }
+
+    this.checkStalePrices(
+      queryOutput.expectedAmountOut,
+      sorPaths,
+      sorAmount,
+      args,
+    );
+
+    // format quote response
+    const formattedQuote = {
+      amountOut: queryOutput.expectedAmountOut.amount.toString(),
+      amountIn: amount,
+      spender: queryOutput.to,
+      name: this.name,
+      priceImpactPercentage: this.calculatePriceImpact(priceImpact),
+      swapFeeBps: 0,
+    };
+    if (account === zeroAddress) return formattedQuote;
+
+    // generate user transaction data
+    const callData = swap.buildCall({
+      slippage: Slippage.fromPercentage(slippage.toString() as `${number}`),
+      deadline: BigInt(Math.round(Date.now() / 1000) + DEFAULT_DEADLINE),
+      queryOutput,
+      sender: account as Address,
+      recipient: account as Address,
+      wethIsEth: wberaIsBera,
+    });
+
+    const { args: params, functionName } = decodeFunctionData({
+      abi: balancerVaultAbi,
+      data: callData.callData,
+    });
+
+    return {
+      ...formattedQuote,
+      calldata: {
+        params,
+        functionName,
+        abi: balancerVaultAbi,
+        address: callData.to,
+        value: callData.value || BigInt(0),
+      },
+    };
+  }
+}
+
+export const bex = new BexAggregator();

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

@@ -0,0 +1,50 @@
+import { ChainId } from "@berachain/config/internal";
+
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+class RedeemBgtAggregator extends BaseAggregator {
+  name = Aggregators.RedeemBgt;
+  supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
+  readonly type = "rpc";
+  // handles native swaps: wrap and unwrap
+  async getQuote({
+    tokenIn,
+    amount,
+  }: Omit<
+    IAggregatorArgs,
+    "slippage" | "feeBps" | "tokenOut" | "account"
+  >): Promise<IRawAggregatorQuote> {
+    this.checkChainSupport();
+
+    if (!isToken(tokenIn, "BGT", { config: this.config })) {
+      throw new InvalidArgumentError({
+        property: "tokenIn",
+        value: tokenIn,
+        expected: "BGT",
+        level: "warning",
+      });
+    }
+
+    return {
+      amountOut: amount,
+      amountIn: amount,
+      spender: undefined,
+      name: Aggregators.RedeemBgt,
+      isNativeSwap: true,
+      swapFeeBps: 0,
+      // not adding calldata here because it depends on the connected wallet
+      // bgt redeem requires a receiver address
+      // moreover this is a sensitive operation, better be sure of what data is being sent
+      // by controlling it on the consumer side
+    } as const;
+  }
+}
+
+export const bgtRedeem = new RedeemBgtAggregator();

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

@@ -0,0 +1,113 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { BaseAggregator } from "./base";
+
+class EnsoAggregator extends BaseAggregator {
+  name = Aggregators.Enso;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+
+  notFoundMessages: string[] = [
+    "Could not build shortcuts for route",
+    "Swap not found for a required underlying of defi route,",
+  ];
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    aggregatorsFeeBps,
+    proxyAggregatorsThroughVercel = false,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    this.checkChainSupport();
+
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn, tokenOut);
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    this.url = proxyAggregatorsThroughVercel
+      ? `/api/aggregators?aggregator=enso`
+      : `${this.config.bex.aggregatorsProxyUrl}/enso/api/v1/shortcuts/route?`;
+
+    const url = new URL(this.url);
+    url.searchParams.set(
+      "fromAddress",
+      this.config.bex.aggregatorsRouterExecutor,
+    );
+    url.searchParams.set("receiver", this.config.bex.aggregatorsRouterExecutor);
+    url.searchParams.set("spender", this.config.bex.aggregatorsRouterExecutor);
+    url.searchParams.set("amountIn", inputAmountAfterFees);
+    url.searchParams.set("tokenIn", tokenInAddress);
+    url.searchParams.set("tokenOut", tokenOutAddress);
+    url.searchParams.set("chainId", ChainId.MAINNET.toString());
+    url.searchParams.set("slippage", (Number(slippage) * 100).toString());
+    url.searchParams.set("refundReceiver", account);
+
+    const response = await this.fetch(url);
+
+    const quote = await response.json();
+
+    const inputData = this.getInputData({
+      tokenIn: tokenInAddress,
+      amountIn: amount,
+      isNative: isTokenInNative,
+    });
+
+    const outputData = {
+      tokenOut: tokenOutAddress,
+      receiver: account,
+      minAmountOut: this.getMinAmountOut(quote.amountOut.toString(), slippage),
+      isNative: isTokenOutNative,
+    };
+
+    const aggregatorData = {
+      aggregator: quote.tx?.to,
+      data: quote.tx?.data,
+    };
+
+    return {
+      amountOut: quote.amountOut.toString(),
+      amountIn: amount,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+
+      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 enso = new EnsoAggregator();

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

@@ -0,0 +1,136 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+const BASE_URL = "https://api.magpiefi.xyz/aggregator";
+
+class FlyAggregator extends BaseAggregator {
+  name = Aggregators.Fly;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+  notFoundMessages: string[] = [
+    "Couldn't recognize to token",
+    "There is not enough liquidity. Amount is too high.",
+    "Routes were not found",
+  ];
+
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    aggregatorsFeeBps,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    this.checkChainSupport();
+
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn, tokenOut);
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    const url = new URL(`${BASE_URL}/quote`);
+    this.url = url.toString();
+    const params = new URLSearchParams({
+      fromTokenAddress: tokenInAddress,
+      toTokenAddress: tokenOutAddress,
+      sellAmount: inputAmountAfterFees,
+      slippage: (slippage / 100).toString(),
+      gasless: "false",
+      network: "berachain",
+    });
+
+    if (account !== zeroAddress) {
+      // fly will transfer funds from the executor and will send amountOut to the executor
+      // which in turn will send the funds to the account
+      params.set("fromAddress", this.config.bex.aggregatorsRouterExecutor);
+      params.set("toAddress", this.config.bex.aggregatorsRouterExecutor);
+    }
+    url.search = params.toString();
+
+    const response = await this.fetch(url);
+
+    const quoteData = await response.json();
+
+    const formattedQuote = {
+      amountOut: quoteData.amountOut,
+      amountIn: amount,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps ?? 0,
+    };
+    // if no account, return quote early
+    if (account === zeroAddress) return formattedQuote;
+
+    // fetch transaction data immediately to improve UX and prevent potential failures during swap execution
+    const txUrl = new URL(`${BASE_URL}/transaction`);
+    this.url = txUrl.toString();
+
+    const txParams = new URLSearchParams({
+      quoteId: quoteData.id,
+      estimateGas: "false",
+    });
+    txUrl.search = txParams.toString();
+
+    const txResponse = await this.fetch(txUrl);
+
+    const txData = await txResponse.json();
+
+    const inputData = this.getInputData({
+      tokenIn: tokenInAddress,
+      amountIn: amount,
+      isNative: isTokenInNative,
+    });
+
+    const outputData = {
+      tokenOut: tokenOutAddress,
+      receiver: account,
+      minAmountOut: this.getMinAmountOut(quoteData.amountOut, slippage),
+      isNative: isTokenOutNative,
+    };
+
+    const aggregatorData = {
+      aggregator: txData.to,
+      data: txData.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: isToken(tokenIn, "BERA") ? BigInt(amount) : BigInt("0"),
+        address: this.config.bex.aggregatorsRouter,
+      },
+    };
+  }
+}
+
+export const fly = new FlyAggregator();