@berachain/berajs 0.1.2 → 0.2.0

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

@@ -1,24 +1,28 @@
-import { BigNumber } from "bignumber.js";
-import { type Address, isAddress, zeroAddress } from "viem";
+import { type Address, formatUnits, isAddress, zeroAddress } from "viem";
 
 import type { BeraConfig, ChainId } from "@berachain/config/internal";
 
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import type { HoneyConfigContextReturn } from "~/contexts/HoneyConfigProvider";
+import type { Aggregators } from "~/enum/dex";
 import { BeraError } from "~/errors/BeraError";
 import { initBeraError } from "~/errors/initBeraError";
-import type {
-  Aggregators,
-  IAggregatorArgs,
-  IRawAggregatorQuote,
-} from "~/types/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote, Token } from "~/types/dex";
 import { beraFetch } from "~/utils/beraFetch";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 import { isToken } from "~/utils/tokens";
 
 export abstract class BaseAggregator {
   abstract name: Aggregators;
-  abstract supportedChains: ChainId[];
+  /**
+   * Supported chains for the aggregator.
+   * If null, the aggregator is supported on all chains.
+   */
+  abstract supportedChains: number[] | null;
   static PATH_NOT_FOUND_REASON = "NO_SWAP_PATHS";
 
+  needsAccountForQuote: boolean = false;
   notFoundMessages: string[] = [];
 
   config: BeraConfig;
@@ -41,7 +45,7 @@ export abstract class BaseAggregator {
     args: IAggregatorArgs,
   ):
     | Promise<IRawAggregatorQuote | undefined>
-    | Promise<IRawAggregatorQuote<false> | undefined>;
+    | Promise<IRawAggregatorQuote | undefined>;
 
   /**
    * return wbera for native tokens to accomodate the aggregator's router logic
@@ -75,7 +79,9 @@ export abstract class BaseAggregator {
   }
 
   /**
-   * Calculate input amount after fees
+   * Calculate input amount after fees.
+   *
+   * @returns Amount in wad format
    */
   protected getAmountAfterFees(
     amount: string,
@@ -102,20 +108,20 @@ export abstract class BaseAggregator {
     amountIn,
     isNative,
     isPermit2Approval = false,
-    permit2SpenderAddress = zeroAddress,
+    permit2SpenderAddress,
   }: {
     tokenIn: Address;
     amountIn: string;
     isNative: boolean;
     isPermit2Approval?: boolean;
-    permit2SpenderAddress?: Address;
+    permit2SpenderAddress?: Address | null;
   }) {
     return {
       tokenIn,
       amountIn: BigInt(amountIn),
       isNative,
       isPermit2Approval,
-      permit2SpenderAddress,
+      permit2SpenderAddress: permit2SpenderAddress ?? zeroAddress,
     };
   }
 
@@ -137,13 +143,65 @@ export abstract class BaseAggregator {
     return BigInt(minAmountOut.toFixed(0));
   }
 
+  protected parseAllowanceRequirements({
+    tokenIn,
+    rawAmount,
+    spender,
+  }: {
+    tokenIn: Token;
+    rawAmount: string;
+    spender: Address;
+  }) {
+    return isToken(tokenIn, "BERA")
+      ? []
+      : [
+          {
+            token: tokenIn,
+            amount: {
+              raw: rawAmount,
+              formatted: formatUnits(BigInt(rawAmount), tokenIn.decimals),
+            },
+            spender,
+          },
+        ];
+  }
+
   /**
    * Check if chain is supported
    */
-  protected checkChainSupport(): void {
-    if (!this.supportedChains.includes(this.chainId)) {
+  checkChainSupport({
+    tokenIn,
+    tokenOut,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+    // needed in honey native aggregator
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+    // needed in ERC4626 aggregator
+    underlyingToken?: Token | null;
+  }): boolean {
+    if (this.supportedChains === null) {
+      return true;
+    }
+
+    return (
+      this.supportedChains.includes(tokenIn.chainId) &&
+      this.supportedChains.includes(tokenOut.chainId)
+    );
+  }
+
+  assertChainSupport({
+    tokenIn,
+    tokenOut,
+    underlyingToken,
+  }: {
+    tokenIn: Token;
+    tokenOut: Token;
+    underlyingToken?: Token | null;
+  }): void {
+    if (!this.checkChainSupport({ tokenIn, tokenOut, underlyingToken })) {
       throw new BeraError({
-        message: `${this.name} is not supported on chain ${this.chainId}`,
+        message: `${this.name} does not support tokens chain ID: ${tokenIn.chainId} and ${tokenOut.chainId}`,
         level: "error",
       });
     }

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

@@ -7,7 +7,6 @@ import {
   Token,
   TokenAmount,
 } from "@berachain-foundation/berancer-sdk";
-import * as Sentry from "@sentry/nextjs";
 import { decodeFunctionData, formatEther, zeroAddress } from "viem";
 
 import { getUriFromLink } from "@berachain/config";
@@ -15,15 +14,12 @@ import { ChainId } from "@berachain/config/internal";
 
 import { balancerVaultAbi } from "~/abi/bex/balancerVault";
 import { BalancerApi } from "~/actions/dex/b-sdk";
+import { Aggregators } from "~/enum/dex";
 import { assertPublicClient } from "~/errors/assert";
 import { BeraError } from "~/errors/BeraError";
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
 import { RequestError } from "~/errors/RequestError";
-import {
-  Aggregators,
-  type IAggregatorArgs,
-  type IRawAggregatorQuote,
-} from "~/types";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
 import { isToken } from "~/utils/tokens";
 import { BaseAggregator } from "./base";
 
@@ -63,12 +59,17 @@ class BexAggregator extends BaseAggregator {
   /**
    * Helper to check for stale SOR prices
    */
-  private checkStalePrices(
-    onChainAmount: TokenAmount,
-    sorPaths: { pools: string[] }[],
-    sorAmount: string,
-    queryData: IAggregatorArgs,
-  ): void {
+  private checkStalePrices({
+    onChainAmount,
+    sorPaths,
+    sorAmount,
+    queryData,
+  }: {
+    onChainAmount: TokenAmount;
+    sorPaths: { pools: string[] }[];
+    sorAmount: string;
+    queryData: IAggregatorArgs;
+  }): void {
     // Check for stale prices
     const deltaFromSorAmount =
       Number.parseFloat(formatEther(onChainAmount.scale18)) /
@@ -87,9 +88,6 @@ class BexAggregator extends BaseAggregator {
         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),
@@ -99,10 +97,11 @@ class BexAggregator extends BaseAggregator {
         },
         fingerprint: ["SOR_STALE_PRICES"],
       });
+      BeraMonitoring.captureException(error);
     }
   }
 
-  async getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote<false>> {
+  async getQuote(args: IAggregatorArgs): Promise<IRawAggregatorQuote> {
     const balancerApi = new BalancerApi(
       this.url,
       // @ts-expect-error b-sdk has more chains than berajs
@@ -111,47 +110,27 @@ class BexAggregator extends BaseAggregator {
     const {
       tokenIn,
       tokenOut,
-      tokenInDecimals,
-      tokenOutDecimals,
       amount,
       slippage,
       account = zeroAddress,
       publicClient,
     } = args;
-    this.checkChainSupport();
+    this.assertChainSupport({ tokenIn, tokenOut });
 
     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,
+      this.convertZeroToWrapped(tokenIn.address),
+      tokenIn.decimals,
     );
     const tokenOutV3 = new Token(
       this.chainId,
-      this.convertZeroToWrapped(tokenOut as Address),
-      tokenOutDecimals,
+      this.convertZeroToWrapped(tokenOut.address),
+      tokenOut.decimals,
     );
 
     const tokenAmount = TokenAmount.fromRawAmount(
@@ -206,47 +185,48 @@ class BexAggregator extends BaseAggregator {
       throw new Error("No Bex paths found");
     }
 
-    this.checkStalePrices(
-      queryOutput.expectedAmountOut,
+    this.checkStalePrices({
+      onChainAmount: queryOutput.expectedAmountOut,
       sorPaths,
       sorAmount,
-      args,
-    );
+      queryData: args,
+    });
 
     // format quote response
-    const formattedQuote = {
+    return {
       amountOut: queryOutput.expectedAmountOut.amount.toString(),
       amountIn: amount,
-      spender: queryOutput.to,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: 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),
+      getCalldata: ({ account }) => {
+        // 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 {
+          params,
+          functionName,
+          abi: balancerVaultAbi,
+          address: callData.to,
+          value: callData.value || BigInt(0),
+        };
       },
     };
   }

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

@@ -1,18 +1,38 @@
 import { ChainId } from "@berachain/config/internal";
 
+import { Aggregators } from "~/enum/dex";
 import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import {
-  Aggregators,
-  type IAggregatorArgs,
-  type IRawAggregatorQuote,
-} from "~/types";
-import { isToken } from "~/utils/tokens";
+import type {
+  IAggregatorArgs,
+  IRawAggregatorQuote,
+  MinimalERC20,
+} from "~/types/dex";
+import { beraToken, isToken } from "~/utils/tokens";
 import { BaseAggregator } from "./base";
 
 class RedeemBgtAggregator extends BaseAggregator {
   name = Aggregators.RedeemBgt;
   supportedChains = [ChainId.MAINNET, ChainId.BEPOLIA];
   readonly type = "rpc";
+
+  checkChainSupport({
+    tokenIn,
+    tokenOut,
+  }: {
+    tokenIn: MinimalERC20;
+    tokenOut: MinimalERC20;
+  }): boolean {
+    if (!super.checkChainSupport({ tokenIn, tokenOut })) {
+      return false;
+    }
+
+    return (
+      // only supported on same chain
+      tokenIn.chainId === tokenOut.chainId &&
+      isToken(tokenIn, "BGT", { chainId: tokenIn.chainId }) &&
+      isToken(tokenOut, "BERA")
+    );
+  }
   // handles native swaps: wrap and unwrap
   async getQuote({
     tokenIn,
@@ -21,7 +41,10 @@ class RedeemBgtAggregator extends BaseAggregator {
     IAggregatorArgs,
     "slippage" | "feeBps" | "tokenOut" | "account"
   >): Promise<IRawAggregatorQuote> {
-    this.checkChainSupport();
+    this.assertChainSupport({
+      tokenIn,
+      tokenOut: { ...beraToken, chainId: tokenIn.chainId },
+    });
 
     if (!isToken(tokenIn, "BGT", { config: this.config })) {
       throw new InvalidArgumentError({
@@ -35,7 +58,7 @@ class RedeemBgtAggregator extends BaseAggregator {
     return {
       amountOut: amount,
       amountIn: amount,
-      spender: undefined,
+      allowanceRequirements: [],
       name: Aggregators.RedeemBgt,
       isNativeSwap: true,
       swapFeeBps: 0,

package/src/actions/dex/aggregators/{enso.ts → enso/enso.ts}

@@ -3,22 +3,23 @@ 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 {
+import { Aggregators } from "~/enum/dex";
+import type { IAggregatorArgs, IRawAggregatorQuote } from "~/types/dex";
+import { BaseAggregator } from "../base";
+
+export class EnsoAggregator extends BaseAggregator {
   name = Aggregators.Enso;
   supportedChains = [ChainId.MAINNET];
   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,
@@ -29,14 +30,14 @@ class EnsoAggregator extends BaseAggregator {
     proxyAggregatorsThroughVercel = false,
     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,
@@ -86,11 +87,14 @@ class EnsoAggregator extends BaseAggregator {
     return {
       amountOut: quote.amountOut.toString(),
       amountIn: amount,
-      spender: this.config.bex.aggregatorsRouter,
+      allowanceRequirements: this.parseAllowanceRequirements({
+        tokenIn,
+        rawAmount: amount,
+        spender: this.config.bex.aggregatorsRouter,
+      }),
       name: this.name,
       swapFeeBps: aggregatorsFeeBps!,
-
-      calldata: {
+      getCalldata: () => ({
         params: [
           inputData,
           outputData,
@@ -105,7 +109,7 @@ class EnsoAggregator extends BaseAggregator {
         // 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,
-      },
+      }),
     };
   }
 }

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

@@ -0,0 +1,37 @@
+import { berachain } from "viem/chains";
+import { describe, it } from "vitest";
+
+import { mainnet } from "@berachain/config/mainnet";
+
+import { beraToken, getHoneyToken } from "~/utils/tokens";
+import { ensoErc4626 } from "./ensoErc4626";
+
+describe("ensoErc4626", () => {
+  it("should return a quote", async () => {
+    const re7Honey = {
+      ...beraToken,
+      address: mainnet.bend.production.supportedVaults[0],
+      chainId: berachain.id,
+    };
+
+    const optimism = {
+      address: "0x4200000000000000000000000000000000000042",
+      decimals: 18,
+      symbol: "OP",
+      name: "Optimism",
+      chainId: 10,
+    } as const;
+
+    const quote = await ensoErc4626.getQuote({
+      tokenIn: optimism,
+      tokenOut: re7Honey,
+      account: "0x79f453D56C4bC66586215827FbBc7B34Bc006b33",
+      amount: "10000000000000000000",
+      slippage: 1,
+      underlyingToken: getHoneyToken({ chainId: re7Honey.chainId }),
+      rewardVault: "0xdb6e93cd7bddc45ebc411619792fc5f977316c38",
+    });
+
+    console.log(quote);
+  });
+});