@berachain/berajs 0.1.1 → 0.1.2

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

@@ -0,0 +1,171 @@
+import { formatUnits, parseUnits, zeroAddress } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { aggregatorsRouterAbi } from "~/abi";
+import { BeraError } from "~/errors/BeraError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+} from "~/types";
+import { SwapReferrer } from "~/types/dex";
+import { BaseAggregator } from "./base";
+
+class HaikuAggregator extends BaseAggregator {
+  name = Aggregators.Haiku;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+
+  notFoundMessages: string[] = [
+    "token not found",
+    "Token is not supported",
+    "No route found for the given input or the liquidity is not enough",
+    "Invalid input amount. Please ensure the total amount of input is greater than 0.001 USD",
+  ];
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    tokenInDecimals,
+    tokenOutDecimals,
+    aggregatorsFeeBps,
+    proxyAggregatorsThroughVercel = false,
+    referrer,
+    rewardVault,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    if (tokenInDecimals === undefined || tokenOutDecimals === undefined) {
+      throw new BeraError({
+        message: "Missing required params",
+        level: "error",
+      });
+    }
+
+    this.checkChainSupport();
+    const {
+      tokenInAddress,
+      tokenOutAddress,
+      isTokenInNative,
+      isTokenOutNative,
+    } = this.parseAddresses(tokenIn, tokenOut);
+
+    const inputAmountAfterFees = this.getAmountAfterFees(
+      amount,
+      aggregatorsFeeBps,
+    );
+
+    // get route quote from haiku api
+    const quoteBody = {
+      intent: {
+        allowancesMode: "approve",
+        slippage: slippage / 100,
+        receiver: this.config.bex.aggregatorsRouterExecutor,
+        input_positions: {
+          [`bera:${tokenInAddress}`]: formatUnits(
+            BigInt(inputAmountAfterFees),
+            tokenInDecimals,
+          ),
+        },
+        target_weights: {
+          [`bera:${tokenOutAddress}`]: 1, // 100% into the output token
+        },
+      },
+    };
+
+    // haiku request to use separate API KEYs for zap and swap
+    // hence the separate proxy paths (api keys are used at the proxy level)
+    const proxyPath = referrer === SwapReferrer.ZAP ? "zap-haiku" : "haiku";
+
+    this.url = proxyAggregatorsThroughVercel
+      ? `/api/aggregators?aggregator=haikuQuote`
+      : `${this.config.bex.aggregatorsProxyUrl}/${proxyPath}/v1/quoteIntent`;
+
+    const quoteResponse = await this.fetch(
+      // using vercel proxy in development to avoid CORS issues
+      this.url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(quoteBody),
+      },
+    );
+
+    const quoteData = await quoteResponse.json();
+
+    const formattedQuote = {
+      amountOut: parseUnits(
+        quoteData.balances[0].amount,
+        tokenOutDecimals,
+      ).toString(),
+      amountIn: amount,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+    };
+
+    // If no account, return quote early
+    if (account === zeroAddress) return formattedQuote;
+
+    this.url = proxyAggregatorsThroughVercel
+      ? `/api/aggregators?aggregator=haikuSolve`
+      : `${this.config.bex.aggregatorsProxyUrl}/${proxyPath}/v1/solveIntent`;
+
+    const solveResponse = await this.fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        quoteId: quoteData.quoteId,
+      }),
+    });
+
+    const solveData = await solveResponse.json();
+
+    const inputData = this.getInputData({
+      tokenIn: tokenInAddress,
+      amountIn: amount,
+      isNative: isTokenInNative,
+      isPermit2Approval: true, // haiku requires permit2 approval
+      permit2SpenderAddress: this.config.bex.haikuAgentAddress,
+    });
+
+    const outputData = {
+      tokenOut: tokenOutAddress,
+      receiver: account,
+      minAmountOut: this.getMinAmountOut(formattedQuote.amountOut, slippage),
+      isNative: isTokenOutNative,
+    };
+
+    const aggregatorData = {
+      aggregator: solveData.to,
+      data: solveData.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 haiku = new HaikuAggregator();

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

@@ -0,0 +1,245 @@
+import { BigNumber } from "bignumber.js";
+import { type Address, formatUnits } from "viem";
+
+import { ChainId } from "@berachain/config/internal";
+
+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 { assertPublicClient } from "~/errors/assert";
+import { BeraError } from "~/errors/BeraError";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import {
+  Aggregators,
+  type IAggregatorArgs,
+  type IRawAggregatorQuote,
+  type 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
+   */
+  static 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),
+    );
+  }
+
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    publicClient,
+    account,
+    honeyNativeState,
+  }: IHoneyNativeArgs): Promise<IRawAggregatorQuote<false> | undefined> {
+    const { collateralList: collaterals } = honeyNativeState ?? {};
+    if (!collaterals) {
+      throw new InvalidArgumentError({
+        message: "Invalid Honey Context state",
+        property: "collaterals",
+        value: collaterals,
+        expected: "TokenWithOrder[]",
+      });
+    }
+    assertPublicClient(publicClient);
+
+    this.checkChainSupport();
+
+    const isMint = isToken(tokenOut, this.honeyToken);
+
+    // these should never happen but just in case
+    // checking that the tokenOut & tokenIn are correct to allow mint or redeem
+    if (
+      !HoneyNativeAggregator.isHoneyNativeSwap({
+        tokenIn: tokenIn as Address,
+        tokenOut: tokenOut as Address,
+        honeyNativeState,
+      })
+    ) {
+      throw new BeraError({
+        message: "Honey Aggregator only supports minting or redeeming Honey",
+      });
+    }
+
+    /**
+     * 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 as Address) : (tokenOut as 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?.formattedBalance ?? "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 = account
+      ? await getSwapPayload({
+          state: {
+            actionType: isMint ? "mint" : "redeem",
+            fromAmount: [honeyFormattedAmountIn],
+            collaterals: hubOrderedCollaterals,
+            isBasketModeEnabled: false, // In Hub, we don't support basket mode
+          },
+          account: account,
+          collateralList: hubOrderedCollaterals,
+          publicClient,
+          priceFeedMap: undefined,
+          isPythWrapperEnabled: false,
+        })
+      : undefined;
+
+    // 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(),
+      spender: this.config.honey.factory,
+      name: Aggregators.Honey,
+      swapFeeBps: 0,
+      calldata: payload,
+    };
+  }
+}
+
+export const honeyNative = new HoneyNativeAggregator();

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

@@ -0,0 +1,142 @@
+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 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.checkChainSupport();
+    const {
+      isTokenInNative,
+      isTokenOutNative,
+      tokenInAddress,
+      tokenOutAddress,
+    } = this.parseAddresses(tokenIn, tokenOut);
+
+    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,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      swapFeeBps: aggregatorsFeeBps!,
+    };
+
+    // If no account, return quote early
+    if (account === zeroAddress) return formattedQuote;
+
+    // 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,
+    });
+
+    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 {
+      ...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 kyberswap = new KyberSwapAggregator();

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

@@ -0,0 +1,110 @@
+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 OogaboogaAggregator extends BaseAggregator {
+  name = Aggregators.Oogabooga;
+  supportedChains = [ChainId.MAINNET];
+  readonly type = "rest";
+
+  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,
+    );
+
+    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,
+      spender: this.config.bex.aggregatorsRouter,
+      name: this.name,
+      priceImpactPercentage: quote.priceImpact,
+      swapFeeBps: aggregatorsFeeBps!,
+    };
+
+    // if no account, return quote early
+    if (account === zeroAddress) return formattedQuote;
+
+    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 {
+      ...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 oogabooga = new OogaboogaAggregator();