@berachain/berajs 0.1.1 → 0.2.0

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

@@ -0,0 +1,254 @@
+import { type Address, formatUnits } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import {
+  getHoneyPreview,
+  type HoneyPreviewArgs,
+  HoneyPreviewMethod,
+} from "~/actions/honey/getHoneyPreview";
+import { getHoneyVaultsBalance } from "~/actions/honey/getHoneyVaultsBalance";
+import { getSwapPayload } from "~/actions/honey/getSwapPayload";
+import { isBasketModeEnabled } from "~/actions/honey/isBasketModeEnabled";
+import type { HoneyConfigContextReturn } from "~/contexts/HoneyConfigProvider";
+import { Aggregators } from "~/enum/dex";
+import { assertPublicClient } from "~/errors/assert";
+import { BeraError } from "~/errors/BeraError";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import type {
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+  Token,
+  TokenWithMetadata,
+} from "~/types/dex";
+import { getHoneyToken, isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+interface IHoneyNativeArgs
+  extends Omit<
+    IAggregatorArgs,
+    "slippage" | "feeBps" | "aggregatorsFeeBps" | "referrer"
+  > {}
+
+function _getPreviewMethod(isMint: boolean): HoneyPreviewMethod {
+  return isMint ? HoneyPreviewMethod.Mint : HoneyPreviewMethod.Redeem;
+}
+
+export class HoneyNativeAggregator extends BaseAggregator {
+  name = Aggregators.Honey;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rpc";
+
+  readonly honeyToken: TokenWithMetadata = getHoneyToken(this);
+
+  /**
+   * Determines if the swap is a honey mint or redeem based on the tokenIn, tokenOut and the colalterals passed.
+   * @returns True if the swap is a honey mint or redeem
+   */
+  isHoneyNativeSwap({
+    tokenIn,
+    tokenOut,
+    honeyNativeState,
+    ...args
+  }: BeraJS.BaseFunctionArgs & {
+    tokenIn: Address;
+    tokenOut: Address;
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+  }) {
+    if (!honeyNativeState?.collateralList) return false;
+
+    const isMint = isToken(tokenOut, "HONEY", args);
+    const isRedeem = isToken(tokenIn, "HONEY", args);
+
+    if (!isMint && !isRedeem) return false;
+
+    return honeyNativeState.collateralList.some((coll) =>
+      isToken(coll.address, isMint ? tokenIn : tokenOut),
+    );
+  }
+
+  checkChainSupport({
+    tokenIn,
+    tokenOut,
+    honeyNativeState,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+  }): boolean {
+    return (
+      super.checkChainSupport({ tokenIn, tokenOut }) &&
+      tokenIn.chainId === tokenOut.chainId &&
+      this.isHoneyNativeSwap({
+        tokenIn: tokenIn.address,
+        tokenOut: tokenOut.address,
+        honeyNativeState,
+      })
+    );
+  }
+
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    publicClient,
+    account,
+    honeyNativeState,
+  }: IHoneyNativeArgs): Promise<IRawAggregatorQuote | undefined> {
+    const { collateralList: collaterals } = honeyNativeState ?? {};
+    if (!collaterals) {
+      throw new InvalidArgumentError({
+        message: "Invalid Honey Context state",
+        property: "collaterals",
+        value: collaterals,
+        expected: "TokenWithOrder[]",
+      });
+    }
+    assertPublicClient(publicClient);
+
+    this.assertChainSupport({ tokenIn, tokenOut });
+
+    const isMint = isToken(tokenOut, this.honeyToken);
+
+    /**
+     * The collaterals on Honey are managed with a state that changes the order based on the selected collateral.
+     * hub does not do that, so we need to order the collaterals based on the tokenIn.
+     * The first collateral will be the tokenIn.
+     *  */
+    const hubOrderedCollaterals = collaterals;
+
+    // Check if the token requested as collateral is a valid collateral token that can be used to mint or redeem honey
+    const collateral = collaterals.find((collateral) =>
+      isToken(collateral.address, isMint ? tokenIn.address : tokenOut.address),
+    );
+    if (!collateral) {
+      throw new BeraError({
+        message: "This collateral is not part of the Honey protocol",
+      });
+    }
+
+    /*
+     * honeyVaultBalances: Balances of the collateral's vault to check if the vault has enough liquidity
+     * isBasketMode: Whether the basket mode is enabled
+     */
+    const [honeyVaultBalances, isBasketMode] = await Promise.all([
+      getHoneyVaultsBalance({
+        client: publicClient,
+        collateralList: [collateral],
+      }),
+      isBasketModeEnabled({
+        client: publicClient,
+        isMint,
+        collateralList: collaterals,
+        latestPrices: undefined, // no need to get the latest prices for the aggregator
+        isPythWrapperEnabled: false, // Pyth wrapper is not supported for the aggregator
+      }),
+    ]);
+    if (!honeyVaultBalances) {
+      throw new BeraError({
+        message: "Failed to fetch the Honey vault balances",
+      });
+    }
+    // Need this to prevent mint or redeem in case of a basket mode
+    if (isBasketMode) {
+      return undefined;
+    }
+
+    const collateralVaultBalance = honeyVaultBalances[0];
+
+    // Order the collaterals manually
+    const collateralIdx = collateral.order;
+    if (hubOrderedCollaterals.length > 1 && collateralIdx !== 0) {
+      hubOrderedCollaterals.splice(collateralIdx, 1);
+      hubOrderedCollaterals.unshift(collateral);
+    }
+
+    // Honey's contract expects the amount to be in a raw format
+    const honeyFormattedAmountIn = formatUnits(
+      BigInt(amount),
+      isMint ? collateral.decimals : this.honeyToken.decimals,
+    );
+
+    // Parameters for the honey preview call
+    const quoteParams = {
+      client: publicClient,
+      collateral: collateral,
+      collateralList: collaterals,
+      amount: honeyFormattedAmountIn,
+      method: _getPreviewMethod(isMint),
+      latestPrices: undefined, // no need to get the latest prices for the aggregator
+      isPythWrapperEnabled: false, // Pyth wrapper is not supported for the aggregator
+    } satisfies HoneyPreviewArgs;
+
+    // Get the quote for the Honey mint
+    const quoteData = await getHoneyPreview(quoteParams);
+
+    if (!quoteData) {
+      throw new BeraError({
+        message: "Failed to fetch the Honey preview",
+      });
+    }
+
+    // The quote contains the honey & the collaterals amount, but we'll only ever need honey
+    const { honey: honeyQuote, collaterals: collateralsQuote } = quoteData;
+
+    // check if the vault has enough liquidity to redeem the collateral
+    const haveEnoughLiquidity = !isMint
+      ? new BigNumber(collateralVaultBalance?.balance.formatted ?? "0").gte(
+          formatUnits(
+            collateralsQuote[collateral.address],
+            collateral.decimals,
+          ),
+        )
+      : true;
+
+    if (!haveEnoughLiquidity) {
+      return undefined;
+    }
+
+    /**
+     * Get the swap payload for the Honey mint
+     * If the account is not provided, we will not get the payload
+     */
+    const payload = await getSwapPayload({
+      state: {
+        actionType: isMint ? "mint" : "redeem",
+        fromAmount: [honeyFormattedAmountIn],
+        collaterals: hubOrderedCollaterals,
+        isBasketModeEnabled: false, // In Hub, we don't support basket mode
+      },
+      collateralList: hubOrderedCollaterals,
+      publicClient,
+      priceFeedMap: undefined,
+      isPythWrapperEnabled: false,
+    });
+
+    // In case the user is not connected the payload will not be generated but the preview yes
+    if (!payload && account) {
+      throw new BeraError({
+        message: "Failed to fetch the Honey swap payload",
+      });
+    }
+
+    return {
+      amountIn: amount,
+      amountOut: isMint
+        ? honeyQuote.toString()
+        : collateralsQuote[collateral.address].toString(),
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: amount,
+        spender: this.config.bex.aggregatorsRouter,
+      }),
+      name: Aggregators.Honey,
+      swapFeeBps: 0,
+      getCalldata: ({ account }) => {
+        return payload({ account });
+      },
+    };
+  }
+}
+
+export const honeyNative = new HoneyNativeAggregator();

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

@@ -0,0 +1,144 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { Aggregators } from "~/enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
+import { BaseAggregator } from "./base";
+
+class KyberSwapAggregator extends BaseAggregator {
+  name = Aggregators.KyberSwap;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+
+  notFoundMessages = [
+    "token not found",
+    "route not found",
+    "amountIn is greater than max allowed",
+  ];
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    aggregatorsFeeBps,
+    proxyAggregatorsThroughVercel = false,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    this.assertChainSupport({ tokenIn, tokenOut });
+    const {
+      isTokenInNative,
+      isTokenOutNative,
+      tokenInAddress,
+      tokenOutAddress,
+    } = this.parseAddresses(tokenIn.address, tokenOut.address);
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    this.url = proxyAggregatorsThroughVercel
+      ? `/api/aggregators?aggregator=kyberswapRoutes`
+      : `${this.config.bex.aggregatorsProxyUrl}/kyberswap/berachain/api/v1/routes`;
+
+    const url = new URL(this.url);
+    // First, get route quote
+    url.searchParams.set("tokenIn", tokenInAddress);
+    url.searchParams.set("tokenOut", tokenOutAddress);
+    url.searchParams.set("amountIn", inputAmountAfterFees);
+    url.searchParams.set("slippageTolerance", (slippage / 100).toString());
+    url.searchParams.set("to", this.config.bex.aggregatorsRouterExecutor);
+    url.searchParams.set("clientData", JSON.stringify({ source: "berachain" }));
+
+    const routeResponse = await this.fetch(url);
+
+    const routeData = await routeResponse.json();
+    const formattedQuote = {
+      amountOut: routeData.data.routeSummary.amountOut,
+      amountIn: amount,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: amount,
+        spender: this.config.bex.aggregatorsRouter,
+      }),
+    } satisfies IRawAggregatorQuote;
+
+    // Get the build route data for transaction
+    const buildRouteBody = {
+      routeSummary: routeData.data.routeSummary,
+      sender: this.config.bex.aggregatorsRouterExecutor,
+      recipient: this.config.bex.aggregatorsRouterExecutor,
+      slippageTolerance: slippage * 100, // kyberswap expects the slippage in basis points
+      deadline: Math.floor(Date.now() / 1000) + 60 * 5, // 5 minutes from now
+      source: "berachain",
+    };
+
+    const params = url.searchParams.entries();
+
+    const buildUrl = new URL(
+      proxyAggregatorsThroughVercel
+        ? `/api/aggregators?aggregator=kyberswapBuild`
+        : `${this.config.bex.aggregatorsProxyUrl}/kyberswap/berachain/api/v1/route/build`,
+    );
+
+    for (const [key, value] of params) {
+      buildUrl.searchParams.set(key, value);
+    }
+
+    const buildRouteResponse = await this.fetch(buildUrl, {
+      method: "POST",
+      body: JSON.stringify(buildRouteBody),
+    });
+
+    const buildData = await buildRouteResponse.json();
+
+    const inputData = this.getInputData({
+      tokenIn: tokenInAddress,
+      amountIn: amount,
+      isNative: isTokenInNative,
+    });
+
+    return {
+      ...formattedQuote,
+      getCalldata: ({ account }) => {
+        const outputData = {
+          tokenOut: tokenOutAddress,
+          receiver: account,
+          minAmountOut: this.getMinAmountOut(
+            formattedQuote.amountOut,
+            slippage,
+          ),
+          isNative: isTokenOutNative,
+        };
+
+        const aggregatorData = {
+          aggregator: buildData.data.routerAddress,
+          data: buildData.data.data,
+        };
+        return {
+          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 kyberswap = new KyberSwapAggregator();

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

@@ -0,0 +1,111 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { Aggregators } from "~/enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
+import { BaseAggregator } from "./base";
+
+class OogaboogaAggregator extends BaseAggregator {
+  name = Aggregators.Oogabooga;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    aggregatorsFeeBps,
+    proxyAggregatorsThroughVercel = false,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    this.assertChainSupport({ tokenIn, tokenOut });
+
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn.address, tokenOut.address);
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    const params = new URLSearchParams({
+      tokenIn: tokenInAddress,
+      tokenOut: tokenOutAddress,
+      amount: inputAmountAfterFees,
+      slippage: (slippage / 100).toString(),
+      to: this.config.bex.aggregatorsRouterExecutor,
+      referrer: this.config.bex.aggregatorsRouter,
+    });
+    this.url = proxyAggregatorsThroughVercel
+      ? `/api/aggregators?aggregator=oogabooga&${params.toString()}`
+      : `${this.config.bex.aggregatorsProxyUrl}/oogabooga/v1/swap?${params.toString()}`;
+
+    const response = await this.fetch(this.url);
+
+    const quote = await response.json();
+
+    const formattedQuote = {
+      amountOut: quote.assumedAmountOut,
+      amountIn: amount,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        spender: this.config.bex.aggregatorsRouter,
+        rawAmount: inputAmountAfterFees,
+      }),
+      name: this.name,
+      priceImpactPercentage: quote.priceImpact,
+      swapFeeBps: aggregatorsFeeBps!,
+    } satisfies IRawAggregatorQuote;
+
+    return {
+      ...formattedQuote,
+      getCalldata: ({ account }) => {
+        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: quote.tx?.to,
+          data: quote.tx?.data,
+        };
+        return {
+          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 oogabooga = new OogaboogaAggregator();

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

@@ -0,0 +1,147 @@
+import { zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { Aggregators } from "~/enum/dex";
+import { assertPublicClient } from "~/errors/assert";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { RequestError } from "~/errors/RequestError";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
+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,
+    publicClient,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    assertPublicClient(publicClient);
+
+    if (!tokenIn.decimals) {
+      throw new InvalidArgumentError({
+        property: "tokenIn.decimals",
+        value: tokenIn.decimals,
+        expected: "number",
+        chainId: this.chainId,
+      });
+    }
+
+    this.assertChainSupport({ tokenIn, tokenOut });
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn.address, tokenOut.address);
+
+    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,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: amount,
+        spender: this.config.bex.aggregatorsRouter,
+      }),
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+    };
+
+    return {
+      ...formattedQuote,
+      getCalldata: ({ account }) => {
+        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 {
+          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();