@berachain/berajs 0.1.2 → 0.2.1

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

@@ -0,0 +1,176 @@
+import type { BundleAction } from "@ensofinance/sdk";
+import { type Address, ethAddress, type Hex, zeroAddress } from "viem";
+
+import { getEnsoClient } from "~/actions/clients/getEnsoClient";
+import { Aggregators } from "~/enum/dex";
+import { assertAddress } from "~/errors/assert";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
+import { BaseAggregator } from "../base";
+
+class EnsoErc4626Aggregator extends BaseAggregator {
+  name = Aggregators.EnsoErc4626;
+  supportedChains = null;
+  readonly type = "rest";
+  needsAccountForQuote = true;
+
+  notFoundMessages: string[] = [
+    "Could not build shortcuts for route",
+    "Could not quote shortcuts for route",
+    "Swap not found for a required underlying of defi route,",
+    "No route found from",
+  ];
+
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    slippage,
+    account = zeroAddress,
+    aggregatorsFeeBps,
+    proxyAggregatorsThroughVercel = false,
+    rewardVault,
+    underlyingToken,
+  }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
+    this.assertChainSupport({ tokenIn, tokenOut });
+
+    assertAddress(account, "account");
+
+    const ensoClient = getEnsoClient({
+      useProxy: !proxyAggregatorsThroughVercel,
+    });
+
+    if (tokenIn.address === zeroAddress) tokenIn.address = ethAddress;
+    if (tokenOut.address === zeroAddress) tokenOut.address = ethAddress;
+
+    /**
+     * This is the token that will be swapped by enso, but might not be the same as the token out.
+     *
+     * If an underlying token is provided, we'll swap to that and then deposit it into the vault,
+     * assuming that token out is an ERC4626 vault.
+     */
+    const zapTokenOut = underlyingToken ?? tokenOut;
+
+    const bundleActions: BundleAction[] = [
+      // this is the base route action, which will swap the token in to the zap token out
+      // it handles cross-chain swaps and refunds the user if the swap fails
+      // this might even be the only action if no underlying token or reward vault is provided
+      {
+        protocol: "enso",
+        action: "route",
+        args: {
+          tokenIn: tokenIn.address,
+          tokenOut: zapTokenOut.address,
+          destinationChainId:
+            // must be undefined if the token is the same chain
+            tokenIn.chainId === zapTokenOut.chainId
+              ? undefined
+              : zapTokenOut.chainId,
+          refundReceiver: account,
+          amountIn: amount,
+          slippage: slippage * 100, // Enso expects slippage in basis points
+        },
+      },
+    ];
+
+    if (underlyingToken) {
+      // deposit the underlying token into the vault
+      // this works both for Staked BERA/iBera and Bend Vaults
+      bundleActions.push({
+        protocol: "erc4626",
+        action: "deposit",
+        args: {
+          amountIn: { useOutputOfCallAt: 0 },
+          tokenIn: underlyingToken.address,
+          primaryAddress: tokenOut.address,
+          tokenOut: tokenOut.address,
+        },
+      });
+    }
+
+    if (rewardVault) {
+      // if an address is provided, funds will be staked into the reward vault
+
+      // offset dynamically reads length of bundleActions array to get the output of the previous call
+      const offset = bundleActions.length;
+      bundleActions.push(
+        {
+          protocol: "enso",
+          action: "balance",
+          args: {
+            token: tokenOut.address,
+          },
+        },
+        {
+          protocol: "erc20",
+          action: "approve",
+          args: {
+            amount: { useOutputOfCallAt: offset },
+            spender: rewardVault,
+            token: tokenOut.address,
+          },
+        },
+        {
+          protocol: "enso",
+          action: "call",
+          args: {
+            address: rewardVault,
+            args: [account, { useOutputOfCallAt: offset }],
+            method: "stakeOnBehalf",
+            abi: "function stakeOnBehalf(address account, uint256 amount) external",
+          },
+        },
+        {
+          protocol: "enso",
+          action: "balance",
+          args: {
+            token: rewardVault,
+          },
+        },
+      );
+    }
+
+    const bundle = await ensoClient.getBundleData(
+      {
+        fromAddress: account,
+        receiver: account,
+        spender: account,
+        chainId: tokenIn.chainId,
+        routingStrategy: "router",
+      },
+      bundleActions,
+    );
+
+    const tokenOutAddress = (rewardVault?.toLowerCase() ??
+      tokenOut.address.toLowerCase()) as Address;
+
+    const amountOut =
+      // @ts-expect-error enso has not typed this but is returned sometimes from API.
+      bundle.minAmountsOut[tokenOutAddress] ??
+      bundle.amountsOut[tokenOutAddress] ??
+      "0";
+
+    return {
+      amountOut,
+      amountIn: amount,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: amount,
+        spender: bundle.tx.to,
+      }),
+      name: this.name,
+      swapFeeBps: 0,
+      priceImpactPercentage: bundle.priceImpact
+        ? bundle.priceImpact / 100
+        : null,
+      getCalldata: () => ({
+        address: bundle.tx.to,
+        data: bundle.tx.data as Hex,
+        value: BigInt(bundle.tx.value ?? 0),
+        // not returning gas limit because it's usually underestimated by enso.
+        // gasLimit: BigInt(bundle.gas),
+      }),
+    };
+  }
+}
+
+export const ensoErc4626 = new EnsoErc4626Aggregator();

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

@@ -0,0 +1,122 @@
+import { erc4626Abi, formatUnits } from "viem";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { ContractName } from "~/enum/contracts";
+import { Aggregators } from "~/enum/dex";
+import { assertDefined, assertPublicClient } from "~/errors/assert";
+import type { IAggregatorArgs, IRawAggregatorQuote, Token } from "~/types/dex";
+import type { IContractWrite } from "~/types/global";
+import { isToken } from "~/utils/tokens";
+import { BaseAggregator } from "./base";
+
+/**
+ * Aggregator that handles direct deposits into ERC4626 vault tokens.
+ * Instead of routing through a DEX, this deposits the underlying asset directly
+ * into the vault contract (e.g. WBERA → swBERA, HONEY → iBERA, or Bend vault underlying → vault token).
+ *
+ * Special-cases native BERA → swBERA via `depositNative` (no approval needed).
+ */
+class ERC4626Aggregator extends BaseAggregator {
+  name = Aggregators.ERC4626;
+  supportedChains = null;
+  readonly type = "rpc";
+
+  /**
+   * Returns true when tokenOut is an ERC4626 vault whose underlying asset matches tokenIn,
+   * or when depositing native BERA into swBERA.
+   */
+  checkChainSupport({
+    tokenIn,
+    tokenOut,
+    underlyingToken,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+    underlyingToken?: Token;
+  }): boolean {
+    const result =
+      super.checkChainSupport({ tokenIn, tokenOut, underlyingToken }) &&
+      !!underlyingToken &&
+      underlyingToken?.chainId === tokenOut.chainId &&
+      (isToken(underlyingToken, tokenIn) ||
+        // this is a special case for the swbera vault
+        (isToken(tokenIn, "BERA") && isToken(tokenOut, "SWBERA")));
+
+    return result;
+  }
+
+  /**
+   * Fetches a deposit quote by calling `convertToShares` on the vault.
+   * Returns calldata for either `deposit` (ERC20) or `depositNative` (BERA → swBERA).
+   */
+  async getQuote({
+    tokenIn,
+    tokenOut,
+    amount,
+    underlyingToken,
+    publicClient,
+  }: Omit<
+    IAggregatorArgs,
+    "slippage" | "feeBps"
+  >): Promise<IRawAggregatorQuote> {
+    this.assertChainSupport({ tokenIn, tokenOut, underlyingToken });
+
+    assertDefined(underlyingToken, "underlyingToken");
+    assertPublicClient(publicClient);
+
+    const rawOutputAmount = await publicClient.readContract({
+      address: tokenOut.address,
+      abi: erc4626Abi,
+      functionName: "convertToShares",
+      args: [BigInt(amount)],
+    });
+
+    const isSwBeraNative =
+      isToken(tokenOut, "SWBERA") && isToken(tokenIn, "BERA");
+
+    return {
+      amountOut: rawOutputAmount.toString(),
+      amountIn: amount,
+      allowanceRequirements: isSwBeraNative
+        ? []
+        : [
+            {
+              token: tokenIn,
+              spender: tokenOut.address,
+              amount: {
+                raw: amount,
+                formatted: formatUnits(BigInt(amount), tokenIn.decimals),
+              },
+            },
+          ],
+      name: Aggregators.ERC4626,
+      isNativeSwap: false,
+      swapFeeBps: 0,
+      getCalldata: ({ account }) =>
+        isSwBeraNative
+          ? ({
+              abi: stakeBeraVaultAbi,
+              address: tokenOut.address,
+              functionName: "depositNative",
+              params: [BigInt(amount), account],
+              value: BigInt(amount),
+            } satisfies Omit<
+              IContractWrite<typeof stakeBeraVaultAbi, "depositNative">,
+              "message" | "actionType"
+            >)
+          : ({
+              abi: erc4626Abi,
+              address: tokenOut.address,
+              functionName: "deposit",
+              contractName: ContractName.ERC4626,
+              params: [BigInt(amount), account],
+              value: 0n,
+            } satisfies Omit<
+              IContractWrite<typeof erc4626Abi, "deposit">,
+              "message" | "actionType"
+            >),
+    };
+  }
+}
+
+export const erc4626Deposit = new ERC4626Aggregator();

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

@@ -1,24 +1,23 @@
-import { zeroAddress } from "viem";
+import { type Address, type Hex, zeroAddress } from "viem";
 
 import { ChainId } from "@berachain/config/internal";
 
 import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
-import {
-  Aggregators,
-  type IAggregatorArgs,
-  type IRawAggregatorQuote,
-} from "~/types";
+import { Aggregators } from "~/enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
 import { isToken } from "~/utils/tokens";
 import { BaseAggregator } from "./base";
 
-const BASE_URL = "https://api.magpiefi.xyz/aggregator";
+const BASE_URL = "https://api.fly.trade/aggregator";
 
 class FlyAggregator extends BaseAggregator {
   name = Aggregators.Fly;
   supportedChains = [ChainId.MAINNET];
   readonly type = "rest";
+
   notFoundMessages: string[] = [
     "Couldn't recognize to token",
+    "Couldn't recognize from token",
     "There is not enough liquidity. Amount is too high.",
     "Routes were not found",
   ];
@@ -28,18 +27,18 @@ class FlyAggregator extends BaseAggregator {
     tokenOut,
     amount,
     slippage,
-    account = zeroAddress,
+    account,
     aggregatorsFeeBps,
     rewardVault,
   }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
-    this.checkChainSupport();
+    this.assertChainSupport({ tokenIn, tokenOut });
 
     const {
       tokenInAddress,
       tokenOutAddress,
       isTokenInNative,
       isTokenOutNative,
-    } = this.parseAddresses(tokenIn, tokenOut);
+    } = this.parseAddresses(tokenIn.address, tokenOut.address);
 
     const inputAmountAfterFees = this.getAmountAfterFees(
       amount,
@@ -57,12 +56,11 @@ class FlyAggregator extends BaseAggregator {
       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);
-    }
+    // 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);
@@ -72,62 +70,70 @@ class FlyAggregator extends BaseAggregator {
     const formattedQuote = {
       amountOut: quoteData.amountOut,
       amountIn: amount,
-      spender: this.config.bex.aggregatorsRouter,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: 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,
-    };
+    const txData: {
+      to: Address;
+      data: Hex;
+    } = await txResponse.json();
 
     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,
+      getCalldata: ({ account }) => {
+        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 {
+          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,
+        };
       },
     };
   }

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

@@ -2,14 +2,10 @@ import { formatUnits, parseUnits, zeroAddress } from "viem";
 
 import { ChainId } from "@berachain/config/internal";
 
-import { aggregatorsRouterAbi } from "~/abi";
+import { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import { Aggregators, SwapReferrer } from "~/enum/dex";
 import { BeraError } from "~/errors/BeraError";
-import {
-  Aggregators,
-  type IAggregatorArgs,
-  type IRawAggregatorQuote,
-} from "~/types";
-import { SwapReferrer } from "~/types/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
 import { BaseAggregator } from "./base";
 
 class HaikuAggregator extends BaseAggregator {
@@ -28,28 +24,25 @@ class HaikuAggregator extends BaseAggregator {
     tokenOut,
     amount,
     slippage,
-    account = zeroAddress,
-    tokenInDecimals,
-    tokenOutDecimals,
     aggregatorsFeeBps,
     proxyAggregatorsThroughVercel = false,
     referrer,
     rewardVault,
   }: IAggregatorArgs): Promise<IRawAggregatorQuote> {
-    if (tokenInDecimals === undefined || tokenOutDecimals === undefined) {
+    if (tokenIn.decimals === undefined || tokenOut.decimals === undefined) {
       throw new BeraError({
         message: "Missing required params",
         level: "error",
       });
     }
 
-    this.checkChainSupport();
+    this.assertChainSupport({ tokenIn, tokenOut });
     const {
       tokenInAddress,
       tokenOutAddress,
       isTokenInNative,
       isTokenOutNative,
-    } = this.parseAddresses(tokenIn, tokenOut);
+    } = this.parseAddresses(tokenIn.address, tokenOut.address);
 
     const inputAmountAfterFees = this.getAmountAfterFees(
       amount,
@@ -65,7 +58,7 @@ class HaikuAggregator extends BaseAggregator {
         input_positions: {
           [`bera:${tokenInAddress}`]: formatUnits(
             BigInt(inputAmountAfterFees),
-            tokenInDecimals,
+            tokenIn.decimals,
           ),
         },
         target_weights: {
@@ -99,17 +92,18 @@ class HaikuAggregator extends BaseAggregator {
     const formattedQuote = {
       amountOut: parseUnits(
         quoteData.balances[0].amount,
-        tokenOutDecimals,
+        tokenOut.decimals,
       ).toString(),
       amountIn: amount,
-      spender: this.config.bex.aggregatorsRouter,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: 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`;
@@ -126,43 +120,47 @@ class HaikuAggregator extends BaseAggregator {
 
     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,
+      getCalldata: ({ account }) => {
+        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 {
+          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,
+        };
       },
     };
   }