@berachain/berajs 0.2.5 → 0.2.6-patch.2

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),
+  };
+}

package/src/actions/enso/getBendDemultiplyBundle.ts

@@ -0,0 +1,325 @@
+import type { BundleAction, EnsoClient } from "@ensofinance/sdk";
+import { type Address, formatUnits, type Hex, type PublicClient } from "viem";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import { assertAddress, assertPositive } from "../../errors/assert";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import type { Token } from "../../types/dex";
+import type { BendDemultiplyBundleResponse } from "../../types/enso";
+import { assembleBendFlashloanTransactions } from "./flashloan";
+import { computeSwapOutputRatio, toEnsoAddress } from "./util";
+
+// full-repay cleanup needs a non-trivial leftover debt balance after `repay`.
+// without this proportional buffer, enso may fail to route near-zero dust.
+const FULL_REPAY_CLEANUP_BUFFER_BPS = 25n; // 0.25%
+const BPS_DIVISOR = 10_000n;
+
+export interface GetBendDemultiplyBundleArgs {
+  fromAddress: Address;
+  repayAmount: string;
+  collateralToken: Token;
+  loanToken: Token;
+  marketId: Hex;
+  primaryAddress: Address;
+  chainId: number;
+  ensoClient: EnsoClient;
+  slippage: number;
+  publicClient: PublicClient;
+  collateralPriceInLoanAsset: string;
+  currentCollateral: string;
+  currentDebt: string;
+  ensoWalletV2Address: Address;
+  isAuthorized: boolean;
+}
+
+/**
+ * Calculate the collateral amount to flashloan and sell in order to repay
+ * the target debt amount.
+ *
+ *   collateralNeeded = repayAmount / (collateralPrice * swapOutputRatio)
+ *
+ * This is the inverse of the multiply direction: we need enough collateral
+ * that, after swapping to the loan token with slippage, covers the repay
+ * amount. The result is clamped to `currentCollateral` (can't withdraw
+ * more than exists in the position).
+ */
+export function calculateDemultiplyCollateralAmount({
+  repayAmount,
+  collateralPriceInLoanAsset,
+  collateralToken,
+  loanToken,
+  slippage,
+  currentCollateral,
+}: {
+  repayAmount: string;
+  collateralPriceInLoanAsset: string;
+  collateralToken: Token;
+  loanToken: Token;
+  slippage: number;
+  currentCollateral: string;
+}): string {
+  const swapOutputRatio = computeSwapOutputRatio(slippage);
+  const collateralPrice = new BigNumber(collateralPriceInLoanAsset);
+
+  if (collateralPrice.lte(0)) {
+    throw new InvalidArgumentError({
+      property: "collateralPriceInLoanAsset",
+      value: collateralPriceInLoanAsset,
+      expected: "a value greater than zero",
+    });
+  }
+
+  const loanDecimalsMul = new BigNumber(10).pow(loanToken.decimals);
+  const collateralDecimalsMul = new BigNumber(10).pow(collateralToken.decimals);
+
+  const repayAmountHuman = new BigNumber(repayAmount).dividedBy(
+    loanDecimalsMul,
+  );
+
+  const flashloanCollateralHuman = repayAmountHuman
+    .dividedBy(collateralPrice)
+    .dividedBy(swapOutputRatio);
+
+  const flashloanCollateralRaw = flashloanCollateralHuman
+    .multipliedBy(collateralDecimalsMul)
+    .integerValue(BigNumber.ROUND_UP);
+
+  if (flashloanCollateralRaw.lte(0)) return "0";
+
+  return BigNumber.minimum(
+    flashloanCollateralRaw,
+    new BigNumber(currentCollateral),
+  ).toFixed(0);
+}
+
+/**
+ * Estimate the position change after executing a demultiply.
+ *
+ * Unlike multiply, these values represent *reductions* from the current
+ * position — the caller subtracts them to get the new totals.
+ * Returns human-readable (formatted) values for display.
+ */
+export function getPositionEstimate({
+  repayAmount,
+  collateralToWithdraw,
+  collateralToken,
+  loanToken,
+}: {
+  repayAmount: string;
+  collateralToWithdraw: string;
+  collateralToken: Token;
+  loanToken: Token;
+}): BendDemultiplyBundleResponse["positionEstimate"] {
+  return {
+    finalCollateral: formatUnits(
+      BigInt(collateralToWithdraw),
+      collateralToken.decimals,
+    ),
+    totalBorrow: formatUnits(BigInt(repayAmount), loanToken.decimals),
+  };
+}
+
+export async function getBendDemultiplyBundle({
+  fromAddress,
+  repayAmount,
+  collateralToken,
+  loanToken,
+  marketId,
+  primaryAddress,
+  chainId,
+  ensoClient,
+  slippage,
+  publicClient,
+  collateralPriceInLoanAsset,
+  currentCollateral,
+  currentDebt,
+  ensoWalletV2Address,
+  isAuthorized,
+}: GetBendDemultiplyBundleArgs): Promise<BendDemultiplyBundleResponse> {
+  assertAddress(fromAddress, "fromAddress");
+  assertPositive(repayAmount, "repayAmount");
+  assertPositive(currentDebt, "currentDebt");
+
+  const rawRepayAmount = BigInt(repayAmount);
+  const rawCurrentDebt = BigInt(currentDebt);
+  const isFullRepayment = rawRepayAmount >= rawCurrentDebt;
+
+  const collateralAddress = toEnsoAddress(collateralToken.address);
+  const loanAddress = toEnsoAddress(loanToken.address);
+
+  // proportional extra debt amount (in raw units) reserved for full-repay cleanup.
+  const rawCleanupDebtAmountFromBps =
+    (rawRepayAmount * FULL_REPAY_CLEANUP_BUFFER_BPS + (BPS_DIVISOR - 1n)) /
+    BPS_DIVISOR;
+  const rawFullRepaymentCleanupDebtAmount = isFullRepayment
+    ? rawCleanupDebtAmountFromBps
+    : 0n;
+  // on full repay, quote flashloan collateral against repay + cleanup buffer.
+  // this intentionally creates remaining debt token in the callback so it can
+  // be swapped back to collateral and re-deposited.
+  const rawTargetRepayForFlashloanQuote = (
+    rawRepayAmount + rawFullRepaymentCleanupDebtAmount
+  ).toString();
+
+  const collateralToWithdraw = calculateDemultiplyCollateralAmount({
+    repayAmount: rawTargetRepayForFlashloanQuote,
+    collateralPriceInLoanAsset,
+    collateralToken,
+    loanToken,
+    slippage,
+    currentCollateral,
+  });
+  const isFlashloanCollateralClamped =
+    BigInt(collateralToWithdraw) >= BigInt(currentCollateral);
+  // if flashloan collateral is clamped by current collateral, skip cleanup to
+  // avoid adding extra callback steps when there is no safe collateral headroom.
+  const shouldRunFullRepaymentCleanup =
+    isFullRepayment &&
+    rawFullRepaymentCleanupDebtAmount > 0n &&
+    !isFlashloanCollateralClamped;
+
+  if (BigInt(collateralToWithdraw) <= 0n) {
+    throw new InvalidArgumentError({
+      property: "collateralToWithdraw",
+      value: collateralToWithdraw,
+      expected: "positive amount",
+    });
+  }
+
+  const baseCallbackActions = [
+    // [0] Swap flashloaned collateral into loan tokens
+    {
+      protocol: "enso",
+      action: "route",
+      args: {
+        tokenIn: collateralAddress,
+        tokenOut: loanAddress,
+        amountIn: collateralToWithdraw,
+        slippage: slippage * 100,
+      },
+    },
+    // [1] Repay debt using the swapped loan tokens
+    {
+      protocol: "bend",
+      action: "repay",
+      args: {
+        primaryAddress,
+        positionId: marketId,
+        tokenIn: loanAddress,
+        amountIn: { useOutputOfCallAt: 0 },
+        onBehalfOf: fromAddress,
+      },
+    },
+  ];
+
+  // On full repayment: swap leftover debt-token dust back to collateral and
+  // re-deposit it, so dust isn't left in the user's wallet.
+  // Cleanup indices are computed dynamically from baseCallbackActions length.
+  const cleanupStartIdx = baseCallbackActions.length;
+  const fullRepaymentCleanupActions = shouldRunFullRepaymentCleanup
+    ? [
+        // Read remaining debt token balance after repay
+        {
+          protocol: "enso",
+          action: "balance",
+          args: {
+            token: loanAddress,
+          },
+        },
+        // Swap remaining debt tokens back to collateral
+        {
+          protocol: "enso",
+          action: "route",
+          args: {
+            tokenIn: loanAddress,
+            tokenOut: collateralAddress,
+            amountIn: {
+              useOutputOfCallAt: cleanupStartIdx,
+            },
+            slippage: slippage * 100,
+          },
+        },
+        // Re-deposit recovered collateral into Bend
+        {
+          protocol: "bend",
+          action: "deposit",
+          args: {
+            primaryAddress,
+            positionId: marketId,
+            tokenIn: collateralAddress,
+            amountIn: {
+              useOutputOfCallAt: cleanupStartIdx + 1,
+            },
+            onBehalfOf: fromAddress,
+          },
+        },
+      ]
+    : [];
+
+  const callbackActions = [
+    ...baseCallbackActions,
+    ...fullRepaymentCleanupActions,
+    // Final action: withdraw collateral to repay the flashloan
+    {
+      protocol: "bend",
+      action: "withdraw",
+      args: {
+        primaryAddress,
+        positionId: marketId,
+        tokenOut: collateralAddress,
+        amountOut: collateralToWithdraw,
+        onBehalfOf: fromAddress,
+      },
+    },
+  ];
+
+  const flashloanActions = [
+    {
+      protocol: "bend",
+      action: "flashloan",
+      args: {
+        flashloanToken: collateralAddress,
+        flashloanAmount: collateralToWithdraw,
+        tokenOut: loanAddress,
+        callback: callbackActions,
+      },
+    },
+  ];
+
+  // @ts-expect-error Enso SDK BundleAction typing does not include Bend flashloan action shape yet.
+  const bundleActions: BundleAction[] = flashloanActions;
+
+  const bundle = await ensoClient.getBundleData(
+    {
+      fromAddress,
+      receiver: fromAddress,
+      spender: fromAddress,
+      chainId,
+      routingStrategy: "ensowallet-v2",
+    },
+    bundleActions,
+  );
+
+  const { transactions } = await assembleBendFlashloanTransactions({
+    fromAddress,
+    amountIn: "0",
+    tokenIn: collateralToken,
+    primaryAddress,
+    bundle,
+    publicClient,
+    ensoWalletV2Address,
+    isAuthorized,
+  });
+
+  return {
+    bundle,
+    transactions,
+    positionEstimate: getPositionEstimate({
+      repayAmount,
+      collateralToWithdraw,
+      collateralToken,
+      loanToken,
+    }),
+  };
+}