@berachain/berajs 0.2.4 → 0.2.6-patch.1

package/src/actions/enso/__tests__/getBendMultiplyBundle.unit.test.ts

@@ -0,0 +1,194 @@
+import { parseUnits } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { InvalidArgumentError } from "../../../errors/InvalidArgumentError";
+import {
+  calculateMultiplyBorrowAmount,
+  getPositionEstimate,
+} from "../getBendMultiplyBundle";
+import { collateral6, collateral18, loan6, loan18 } from "./helpers";
+
+describe("calculateMultiplyBorrowAmount", () => {
+  const baseArgs = {
+    rawSupplyCollateralAmount: parseUnits("10", 18).toString(), // 10 ETH
+    rawCurrentCollateralAmount: "0",
+    rawCurrentBorrowAmount: "0",
+    formattedCollateralPriceInLoanAsset: "2000", // 1 ETH = 2000 USDC
+    collateralToken: collateral18,
+    loanToken: loan6,
+    slippage: 0.5,
+    leverageMultiplier: 2,
+  };
+
+  it("returns '0' for leverage <= 1", () => {
+    expect(
+      calculateMultiplyBorrowAmount({ ...baseArgs, leverageMultiplier: 1 }),
+    ).toBe("0");
+    expect(
+      calculateMultiplyBorrowAmount({ ...baseArgs, leverageMultiplier: 0.5 }),
+    ).toBe("0");
+  });
+
+  it("calculates borrow for 2x leverage on fresh position", () => {
+    const result = calculateMultiplyBorrowAmount(baseArgs);
+    const borrowUsdc = Number(result) / 1e6;
+
+    // At 2x leverage: targetLtv = 0.5, denominator = 1 - 0.5*0.995 = 0.5025
+    // borrow = (0.5 * 10e18 * rawPrice) / 0.5025 ≈ 19,900 USDC
+    // The recursive formula accounts for re-deposited swap proceeds
+    expect(borrowUsdc).toBeGreaterThan(19000);
+    expect(borrowUsdc).toBeLessThan(21000);
+  });
+
+  it("calculates borrow for 3x leverage", () => {
+    const result = calculateMultiplyBorrowAmount({
+      ...baseArgs,
+      leverageMultiplier: 3,
+    });
+    const borrowUsdc = Number(result) / 1e6;
+
+    // At 3x: targetLtv = 2/3, denominator ≈ 0.337
+    // Higher leverage = more borrowing ≈ 39,600 USDC
+    expect(borrowUsdc).toBeGreaterThan(38000);
+    expect(borrowUsdc).toBeLessThan(41000);
+  });
+
+  it("accounts for existing borrow by reducing new borrow needed", () => {
+    // Same total collateral base (15 ETH) but with existing borrow
+    const withExistingBorrow = calculateMultiplyBorrowAmount({
+      ...baseArgs,
+      rawSupplyCollateralAmount: parseUnits("5", 18).toString(),
+      rawCurrentCollateralAmount: parseUnits("10", 18).toString(),
+      rawCurrentBorrowAmount: parseUnits("10000", 6).toString(),
+    });
+    const noBorrow = calculateMultiplyBorrowAmount({
+      ...baseArgs,
+      rawSupplyCollateralAmount: parseUnits("5", 18).toString(),
+      rawCurrentCollateralAmount: parseUnits("10", 18).toString(),
+      rawCurrentBorrowAmount: "0",
+    });
+
+    // With existing borrow, less additional borrowing is needed
+    expect(Number(withExistingBorrow)).toBeLessThan(Number(noBorrow));
+  });
+
+  it("returns '0' when existing borrow already exceeds target", () => {
+    const result = calculateMultiplyBorrowAmount({
+      ...baseArgs,
+      leverageMultiplier: 2,
+      rawCurrentCollateralAmount: parseUnits("10", 18).toString(),
+      rawCurrentBorrowAmount: parseUnits("20000", 6).toString(), // already over-leveraged
+    });
+    expect(result).toBe("0");
+  });
+
+  it("throws for zero collateral price", () => {
+    expect(() =>
+      calculateMultiplyBorrowAmount({
+        ...baseArgs,
+        formattedCollateralPriceInLoanAsset: "0",
+      }),
+    ).toThrow(InvalidArgumentError);
+  });
+
+  it("throws for negative collateral price", () => {
+    expect(() =>
+      calculateMultiplyBorrowAmount({
+        ...baseArgs,
+        formattedCollateralPriceInLoanAsset: "-1",
+      }),
+    ).toThrow(InvalidArgumentError);
+  });
+
+  it("throws when slippage >= 100 (via computeSwapOutputRatio)", () => {
+    // slippage >= 100% makes swap output ratio non-positive
+    expect(() =>
+      calculateMultiplyBorrowAmount({
+        ...baseArgs,
+        slippage: 100,
+      }),
+    ).toThrow(InvalidArgumentError);
+  });
+
+  it("returns integer string (no decimals)", () => {
+    const result = calculateMultiplyBorrowAmount(baseArgs);
+    expect(result).toMatch(/^\d+$/);
+  });
+
+  it("works with reversed decimal pairs (6 -> 18)", () => {
+    const result = calculateMultiplyBorrowAmount({
+      ...baseArgs,
+      rawSupplyCollateralAmount: parseUnits("10000", 6).toString(), // 10000 USDC
+      formattedCollateralPriceInLoanAsset: "0.0005", // 1 USDC = 0.0005 ETH
+      collateralToken: collateral6,
+      loanToken: loan18,
+    });
+    const borrowEth = Number(result) / 1e18;
+    // Recursive formula: ~4.975 ETH (close to 5 ETH target at 2x)
+    expect(borrowEth).toBeGreaterThan(4.5);
+    expect(borrowEth).toBeLessThan(5.5);
+  });
+});
+
+describe("getPositionEstimate (multiply)", () => {
+  it("deposit-only: returns supply amount as collateral, zero borrow", () => {
+    const result = getPositionEstimate({
+      rawSupplyCollateralAmount: parseUnits("10", 18).toString(),
+      collateralToken: collateral18,
+      loanToken: loan6,
+      rawBorrowAmount: "0",
+      formattedCollateralPriceInLoanAsset: "2000",
+      slippage: 0.5,
+    });
+
+    expect(result.finalCollateral).toBe("10");
+    expect(result.totalBorrow).toBe("0");
+  });
+
+  it("leveraged: collateral includes supply + swapped borrow proceeds", () => {
+    const rawBorrow = parseUnits("10000", 6).toString(); // borrow 10000 USDC
+    const result = getPositionEstimate({
+      rawSupplyCollateralAmount: parseUnits("10", 18).toString(),
+      collateralToken: collateral18,
+      loanToken: loan6,
+      rawBorrowAmount: rawBorrow,
+      formattedCollateralPriceInLoanAsset: "2000", // 1 ETH = 2000 USDC
+      slippage: 0.5,
+    });
+
+    const finalCollateral = Number(result.finalCollateral);
+    const totalBorrow = Number(result.totalBorrow);
+
+    // 10 ETH supplied + (10000 USDC * 0.995 / 2000 USDC_per_ETH) ≈ 10 + 4.975 = ~14.975 ETH
+    expect(finalCollateral).toBeGreaterThan(14);
+    expect(finalCollateral).toBeLessThan(16);
+    expect(totalBorrow).toBe(10000);
+  });
+
+  it("returns formatted (human-readable) values", () => {
+    const result = getPositionEstimate({
+      rawSupplyCollateralAmount: parseUnits("1", 18).toString(),
+      collateralToken: collateral18,
+      loanToken: loan6,
+      rawBorrowAmount: "0",
+      formattedCollateralPriceInLoanAsset: "2000",
+      slippage: 1,
+    });
+
+    // Should be "1", not "1000000000000000000"
+    expect(Number(result.finalCollateral)).toBe(1);
+  });
+
+  it("handles zero borrow as deposit-only", () => {
+    const result = getPositionEstimate({
+      rawSupplyCollateralAmount: parseUnits("5", 18).toString(),
+      collateralToken: collateral18,
+      loanToken: loan6,
+      rawBorrowAmount: "0",
+      formattedCollateralPriceInLoanAsset: "2000",
+      slippage: 1,
+    });
+    expect(result.totalBorrow).toBe("0");
+    expect(Number(result.finalCollateral)).toBe(5);
+  });
+});

package/src/actions/enso/{getEnsoUserTokensWithBalances.debug.test.ts → __tests__/getEnsoUserTokensWithBalances.debug.test.ts}

@@ -17,9 +17,9 @@ import {
 
 import { getConfig } from "@berachain/wagmi/config";
 
-import { BeraMonitoring } from "~/errors/BeraMonitoring";
-import { getEnsoClient } from "../clients/getEnsoClient";
-import { getEnsoUserTokensWithBalances } from "./getEnsoUserTokensWithBalances";
+import { BeraMonitoring } from "../../../errors/BeraMonitoring";
+import { getEnsoClient } from "../../clients/getEnsoClient";
+import { getEnsoUserTokensWithBalances } from "../getEnsoUserTokensWithBalances";
 
 describe("getEnsoUserTokensWithBalances", () => {
   let fetchSpy: MockInstance<typeof global.fetch>;

package/src/actions/enso/__tests__/helpers.ts

@@ -0,0 +1,42 @@
+import { getAddress } from "viem";
+import { vi } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import type { Token } from "../../../types/dex";
+
+export const makeToken = (decimals: number, symbol = "T"): Token =>
+  ({
+    address: "0x0000000000000000000000000000000000000001",
+    decimals,
+    symbol,
+    name: symbol,
+    chainId: ChainId.MAINNET,
+  }) as Token;
+
+export const TEST_ADDRESS = getAddress(
+  "0x79f453D56C4bC66586215827FbBc7b34Bc006b33",
+);
+export const TEST_PRIMARY = getAddress(
+  "0x1111111111111111111111111111111111111111",
+);
+export const TEST_MARKET_ID =
+  "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as `0x${string}`;
+
+export const collateral18 = makeToken(18, "WETH");
+export const collateral6 = makeToken(6, "USDC");
+export const loan18 = makeToken(18, "WETH");
+export const loan6 = makeToken(6, "USDC");
+
+export const MOCK_BUNDLE_RESPONSE = {
+  tx: { to: "0xbundle", data: "0x1234", value: "0" },
+  gas: "500000",
+};
+
+export const makeMockEnsoClient = () => ({
+  getBundleData: vi.fn().mockResolvedValue(MOCK_BUNDLE_RESPONSE),
+});
+
+export const makeMockPublicClient = () => ({
+  readContract: vi.fn(),
+});

package/src/actions/enso/__tests__/util.unit.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import { InvalidArgumentError } from "../../../errors/InvalidArgumentError";
+import {
+  computeRawCollateralToLoanPrice,
+  computeSwapOutputRatio,
+} from "../util";
+import { makeToken } from "./helpers";
+
+describe("computeSwapOutputRatio", () => {
+  it("returns 0.995 for 0.5% slippage", () => {
+    const ratio = computeSwapOutputRatio(0.5);
+    expect(ratio.toNumber()).toBeCloseTo(0.995, 10);
+  });
+
+  it("returns 0.99 for 1% slippage", () => {
+    const ratio = computeSwapOutputRatio(1);
+    expect(ratio.toNumber()).toBeCloseTo(0.99, 10);
+  });
+
+  it("returns 0.9 for 10% slippage", () => {
+    const ratio = computeSwapOutputRatio(10);
+    expect(ratio.toNumber()).toBeCloseTo(0.9, 10);
+  });
+
+  it("returns 1 for 0% slippage", () => {
+    const ratio = computeSwapOutputRatio(0);
+    expect(ratio.toNumber()).toBe(1);
+  });
+
+  it("throws for slippage >= 100%", () => {
+    expect(() => computeSwapOutputRatio(100)).toThrow(InvalidArgumentError);
+  });
+
+  it("throws for slippage > 100%", () => {
+    expect(() => computeSwapOutputRatio(150)).toThrow(InvalidArgumentError);
+  });
+});
+
+describe("computeRawCollateralToLoanPrice", () => {
+  it("same decimals: raw price equals formatted price", () => {
+    const price = new BigNumber("2000");
+    const result = computeRawCollateralToLoanPrice(
+      price,
+      makeToken(18),
+      makeToken(18),
+    );
+    expect(result.toFixed()).toBe("2000");
+  });
+
+  it("collateral 18 decimals, loan 6 decimals: scales down", () => {
+    // rawPrice = 2000 * 10^6 / 10^18 = 2000 * 1e-12 = 2e-9
+    const price = new BigNumber("2000");
+    const result = computeRawCollateralToLoanPrice(
+      price,
+      makeToken(18),
+      makeToken(6),
+    );
+    expect(result.toFixed()).toBe("0.000000002");
+  });
+
+  it("collateral 6 decimals, loan 18 decimals: scales up", () => {
+    // rawPrice = 2000 * 10^18 / 10^6 = 2000 * 1e12
+    const price = new BigNumber("2000");
+    const result = computeRawCollateralToLoanPrice(
+      price,
+      makeToken(6),
+      makeToken(18),
+    );
+    expect(result.toFixed()).toBe("2000000000000000");
+  });
+
+  it("fractional price with mixed decimals", () => {
+    // 0.0005 ETH/USDC (collateral=USDC 6dec, loan=ETH 18dec)
+    // rawPrice = 0.0005 * 10^18 / 10^6 = 5 * 10^8
+    const price = new BigNumber("0.0005");
+    const result = computeRawCollateralToLoanPrice(
+      price,
+      makeToken(6),
+      makeToken(18),
+    );
+    expect(result.toNumber()).toBeCloseTo(500_000_000, 0);
+  });
+
+  it("price of zero returns zero", () => {
+    const result = computeRawCollateralToLoanPrice(
+      new BigNumber(0),
+      makeToken(18),
+      makeToken(6),
+    );
+    expect(result.toNumber()).toBe(0);
+  });
+});

package/src/actions/enso/flashloan.ts

@@ -0,0 +1,127 @@
+import type { BundleData } from "@ensofinance/sdk";
+import {
+  type Address,
+  encodeFunctionData,
+  getAddress,
+  type PublicClient,
+} from "viem";
+
+import { morphoAbi } from "@berachain/abis/bend/morpho";
+
+import { ensoWalletV2FactoryAbi } from "../../abi/enso/ensoWalletV2Factory";
+import { assertDefined } from "../../errors/assert";
+import type { AllowanceQueryItem, MinimalERC20 } from "../../types/dex";
+import type { GetZapTransactions, Quantity } from "../../types/enso";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { getEnsoWalletTransactionsWithApproval } from "./util";
+
+export async function getEnsoWalletV2Address({
+  publicClient,
+  ensoWalletV2Factory,
+  accountAddress,
+}: {
+  publicClient: PublicClient;
+  ensoWalletV2Factory: Address;
+  accountAddress: Address;
+}): Promise<Address> {
+  return publicClient.readContract({
+    address: ensoWalletV2Factory,
+    abi: ensoWalletV2FactoryAbi,
+    functionName: "getAddress",
+    args: [accountAddress],
+  }) as Promise<Address>;
+}
+
+export async function getIsBendAuthorized({
+  publicClient,
+  primaryAddress,
+  accountAddress,
+  ensoWalletV2Address,
+}: {
+  publicClient: PublicClient;
+  primaryAddress: Address;
+  accountAddress: Address;
+  ensoWalletV2Address: Address;
+}): Promise<boolean> {
+  return publicClient.readContract({
+    address: primaryAddress,
+    abi: morphoAbi,
+    functionName: "isAuthorized",
+    args: [accountAddress, ensoWalletV2Address],
+  }) as Promise<boolean>;
+}
+
+/**
+ * Assemble the final transaction list for a Bend flashloan bundle.
+ *
+ * Handles:
+ * 1. ERC-20 approval for the Enso wallet (if tokenIn is not native and
+ *    allowance is insufficient)
+ * 2. Morpho setAuthorization transaction (if not yet authorized)
+ * 3. The bundle execution transaction itself
+ *
+ * @returns `{ transactions, approvals, ensoWalletFlashloanAdapter }`
+ */
+export async function assembleBendFlashloanTransactions({
+  fromAddress,
+  amountIn,
+  tokenIn,
+  primaryAddress,
+  bundle,
+  publicClient,
+  ensoWalletV2Address,
+  isAuthorized,
+}: {
+  fromAddress: Address;
+  amountIn: Quantity;
+  tokenIn: MinimalERC20;
+  primaryAddress: Address;
+  bundle: BundleData;
+  publicClient: PublicClient;
+  ensoWalletV2Address: Address;
+  isAuthorized: boolean;
+}): Promise<{
+  transactions: GetZapTransactions;
+  approvals: AllowanceQueryItem[];
+  ensoWalletFlashloanAdapter: Address;
+}> {
+  const { config } = parseBaseArgs({});
+  const { walletFlashloanAdapter: ensoWalletFlashloanAdapter } = config.enso;
+  assertDefined(
+    ensoWalletFlashloanAdapter,
+    "config.enso.walletFlashloanAdapter",
+  );
+
+  const { transactions: ensoTransactions, approval } =
+    await getEnsoWalletTransactionsWithApproval({
+      fromAddress,
+      amountIn,
+      tokenIn,
+      bundle,
+      publicClient,
+    });
+
+  const transactions: GetZapTransactions = [];
+
+  if (!isAuthorized) {
+    transactions.push({
+      to: primaryAddress,
+      data: encodeFunctionData({
+        abi: morphoAbi,
+        functionName: "setAuthorization",
+        args: [ensoWalletV2Address, true],
+      }),
+      value: 0n,
+    });
+  }
+
+  transactions.push(...ensoTransactions);
+
+  const approvals: AllowanceQueryItem[] = approval ? [approval] : [];
+
+  return {
+    transactions,
+    approvals,
+    ensoWalletFlashloanAdapter: getAddress(ensoWalletFlashloanAdapter),
+  };
+}