@berachain/berajs 0.2.4 → 0.2.6-patch.1

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

package/src/actions/enso/getBendMultiplyBundle.ts

@@ -0,0 +1,348 @@
+import type { BundleAction, EnsoClient } from "@ensofinance/sdk";
+import type { Address, Hex, PublicClient } from "viem";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import { assertAddress } from "../../errors/assert";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import type { Token } from "../../types/dex";
+import type { BendMultiplyBundleResponse } from "../../types/enso";
+import { assembleBendFlashloanTransactions } from "./flashloan";
+import {
+  computeRawCollateralToLoanPrice,
+  computeSwapOutputRatio,
+  toEnsoAddress,
+} from "./util";
+
+export interface GetBendMultiplyBundleArgs {
+  fromAddress: Address;
+  rawSupplyCollateralAmount: string;
+  rawCurrentCollateralAmount: string;
+  rawCurrentBorrowAmount: string;
+  collateralToken: Token;
+  loanToken: Token;
+  marketId: Hex;
+  primaryAddress: Address;
+  chainId: number;
+  ensoClient: EnsoClient;
+  slippage: number;
+  leverageMultiplier: number;
+  publicClient: PublicClient;
+  formattedCollateralPriceInLoanAsset: string;
+  ensoWalletV2Address: Address;
+  isAuthorized: boolean;
+}
+
+/**
+ * Calculate the loan amount needed to reach a target leverage multiplier.
+ *
+ * The closed-form formula accounts for the recursive nature of leveraged
+ * looping: each borrowed amount is swapped to collateral (losing value to
+ * slippage), then deposited, which increases borrowing capacity.
+ *
+ *   targetLtv = 1 - 1/leverage
+ *   rawPrice  = collateral-to-loan price in raw token units
+ *   denominator = 1 - targetLtv * swapOutputRatio
+ *
+ *   borrowAmount = (targetLtv * collateralBase * rawPrice - currentBorrow)
+ *                  / denominator
+ *
+ * The denominator corrects for the recursive loop: each unit of loan token
+ * that survives the swap (after slippage) becomes new collateral that
+ * enables further borrowing. When denominator <= 0, the leverage target is
+ * unreachable at the current slippage tolerance.
+ */
+export function calculateMultiplyBorrowAmount({
+  rawSupplyCollateralAmount,
+  rawCurrentCollateralAmount,
+  rawCurrentBorrowAmount,
+  formattedCollateralPriceInLoanAsset,
+  collateralToken,
+  loanToken,
+  leverageMultiplier,
+  slippage,
+}: {
+  rawSupplyCollateralAmount: string;
+  rawCurrentCollateralAmount: string;
+  rawCurrentBorrowAmount: string;
+  formattedCollateralPriceInLoanAsset: string;
+  collateralToken: Token;
+  loanToken: Token;
+  leverageMultiplier: number;
+  slippage: number;
+}): string {
+  const normalizedLeverage = Math.max(leverageMultiplier, 1);
+  if (normalizedLeverage <= 1) return "0";
+
+  const swapOutputRatio = computeSwapOutputRatio(slippage);
+  const formattedCollateralPrice = new BigNumber(
+    formattedCollateralPriceInLoanAsset,
+  );
+
+  if (formattedCollateralPrice.lte(0)) {
+    throw new InvalidArgumentError({
+      property: "formattedCollateralPriceInLoanAsset",
+      value: formattedCollateralPriceInLoanAsset,
+      expected: "a value greater than zero",
+    });
+  }
+
+  const rawCollateralToLoanPrice = computeRawCollateralToLoanPrice(
+    formattedCollateralPrice,
+    collateralToken,
+    loanToken,
+  );
+
+  const targetLtv = new BigNumber(1).minus(
+    new BigNumber(1).dividedBy(normalizedLeverage),
+  );
+  const rawCollateralBase = new BigNumber(rawCurrentCollateralAmount).plus(
+    rawSupplyCollateralAmount,
+  );
+  const rawCurrentBorrow = new BigNumber(rawCurrentBorrowAmount);
+
+  // Denominator accounts for the recursive multiplier effect of re-deposited
+  // swap proceeds. A non-positive value means slippage eats all new collateral.
+  const denominator = new BigNumber(1).minus(
+    targetLtv.multipliedBy(swapOutputRatio),
+  );
+
+  if (denominator.lte(0)) {
+    throw new InvalidArgumentError({
+      property: "leverageMultiplier",
+      value: leverageMultiplier,
+      expected: "a lower leverage target for current slippage",
+    });
+  }
+
+  const requiredRawBorrow = targetLtv
+    .multipliedBy(rawCollateralBase)
+    .multipliedBy(rawCollateralToLoanPrice)
+    .minus(rawCurrentBorrow)
+    .dividedBy(denominator);
+
+  if (requiredRawBorrow.lte(0)) return "0";
+
+  const rawBorrowAmount = requiredRawBorrow.integerValue(BigNumber.ROUND_UP);
+  if (rawBorrowAmount.lte(0)) return "0";
+
+  return rawBorrowAmount.toFixed(0);
+}
+
+/**
+ * Estimate the position after executing a multiply loop.
+ *
+ * For a deposit-only (rawBorrowAmount = 0) scenario, final collateral is just
+ * the supplied amount. When borrowing, the loan is swapped to collateral
+ * (accounting for slippage) and added to the supplied amount.
+ *
+ * Returns human-readable (formatted) values for display.
+ */
+export function getPositionEstimate({
+  rawSupplyCollateralAmount,
+  collateralToken,
+  loanToken,
+  rawBorrowAmount,
+  formattedCollateralPriceInLoanAsset,
+  slippage,
+}: {
+  rawSupplyCollateralAmount: string;
+  collateralToken: Token;
+  loanToken: Token;
+  rawBorrowAmount: string;
+  formattedCollateralPriceInLoanAsset: string;
+  slippage: number;
+}): BendMultiplyBundleResponse["positionEstimate"] {
+  const collateralDecimalsMul = new BigNumber(10).pow(collateralToken.decimals);
+  const loanDecimalsMul = new BigNumber(10).pow(loanToken.decimals);
+  const rawSupplyCollateral = new BigNumber(rawSupplyCollateralAmount);
+  const rawBorrow = new BigNumber(rawBorrowAmount);
+
+  if (rawBorrow.lte(0)) {
+    return {
+      finalCollateral: rawSupplyCollateral
+        .dividedBy(collateralDecimalsMul)
+        .toFixed(),
+      totalBorrow: "0",
+    };
+  }
+
+  const swapOutputRatio = computeSwapOutputRatio(slippage);
+  const rawCollateralToLoanPrice = computeRawCollateralToLoanPrice(
+    new BigNumber(formattedCollateralPriceInLoanAsset),
+    collateralToken,
+    loanToken,
+  );
+
+  // Collateral gained from swapping the borrowed loan tokens (after slippage)
+  const rawLoopCollateral = rawCollateralToLoanPrice.lte(0)
+    ? new BigNumber(0)
+    : rawBorrow
+        .multipliedBy(swapOutputRatio)
+        .dividedBy(rawCollateralToLoanPrice);
+
+  const finalFormattedCollateral = rawSupplyCollateral
+    .plus(rawLoopCollateral)
+    .dividedBy(collateralDecimalsMul);
+  const totalFormattedBorrow = rawBorrow.dividedBy(loanDecimalsMul);
+
+  return {
+    finalCollateral: finalFormattedCollateral.toFixed(),
+    totalBorrow: totalFormattedBorrow.toFixed(),
+  };
+}
+
+export async function getBendMultiplyBundle({
+  fromAddress,
+  rawSupplyCollateralAmount,
+  rawCurrentCollateralAmount,
+  rawCurrentBorrowAmount,
+  collateralToken,
+  loanToken,
+  marketId,
+  primaryAddress,
+  chainId,
+  ensoClient,
+  slippage,
+  leverageMultiplier,
+  publicClient,
+  formattedCollateralPriceInLoanAsset,
+  ensoWalletV2Address,
+  isAuthorized,
+}: GetBendMultiplyBundleArgs): Promise<BendMultiplyBundleResponse> {
+  assertAddress(fromAddress, "fromAddress");
+
+  const collateralAddress = toEnsoAddress(collateralToken.address);
+  const loanAddress = toEnsoAddress(loanToken.address);
+
+  const rawBorrowAmount = calculateMultiplyBorrowAmount({
+    rawSupplyCollateralAmount,
+    rawCurrentCollateralAmount,
+    rawCurrentBorrowAmount,
+    formattedCollateralPriceInLoanAsset,
+    collateralToken,
+    loanToken,
+    leverageMultiplier,
+    slippage,
+  });
+
+  // -- Callback action indices for `useOutputOfCallAt` references.
+  // These MUST match the array position of each action in the callback below.
+  const CALLBACK_IDX_ROUTE_LOAN_TO_COLLATERAL = 0;
+  const CALLBACK_IDX_BALANCE_COLLATERAL = 1;
+
+  const depositOnlyActions = [
+    {
+      protocol: "bend",
+      action: "deposit",
+      args: {
+        primaryAddress,
+        positionId: marketId,
+        tokenIn: collateralAddress,
+        amountIn: rawSupplyCollateralAmount,
+        onBehalfOf: fromAddress,
+      },
+    },
+  ];
+
+  const flashloanActions = [
+    {
+      protocol: "bend",
+      action: "flashloan",
+      args: {
+        flashloanToken: loanAddress,
+        flashloanAmount: rawBorrowAmount,
+        tokenIn: collateralAddress,
+        amountIn: rawSupplyCollateralAmount,
+        tokenOut: loanAddress,
+        callback: [
+          // [0] Swap the flashloaned loan tokens into collateral
+          {
+            protocol: "enso",
+            action: "route",
+            args: {
+              tokenIn: loanAddress,
+              tokenOut: collateralAddress,
+              amountIn: rawBorrowAmount,
+              slippage: slippage * 100,
+            },
+          },
+          // [1] Check collateral balance after swap
+          {
+            protocol: "enso",
+            action: "balance",
+            args: {
+              token: collateralAddress,
+            },
+          },
+          // [2] Deposit all collateral (from balance check) into Bend
+          {
+            protocol: "bend",
+            action: "deposit",
+            args: {
+              primaryAddress,
+              positionId: marketId,
+              tokenIn: collateralAddress,
+              amountIn: {
+                useOutputOfCallAt: CALLBACK_IDX_BALANCE_COLLATERAL,
+              },
+              onBehalfOf: fromAddress,
+            },
+          },
+          // [3] Borrow loan tokens to repay the flashloan
+          {
+            protocol: "bend",
+            action: "borrow",
+            args: {
+              primaryAddress,
+              positionId: marketId,
+              collateral: collateralAddress,
+              tokenOut: loanAddress,
+              amountOut: rawBorrowAmount,
+              onBehalfOf: fromAddress,
+            },
+          },
+        ],
+      },
+    },
+  ];
+
+  // @ts-expect-error Enso SDK BundleAction typing does not include Bend flashloan action shape yet.
+  const bundleActions: BundleAction[] =
+    rawBorrowAmount === "0" ? depositOnlyActions : flashloanActions;
+
+  const bundle = await ensoClient.getBundleData(
+    {
+      fromAddress,
+      receiver: fromAddress,
+      spender: fromAddress,
+      chainId,
+      routingStrategy: "ensowallet-v2",
+    },
+    bundleActions,
+  );
+
+  const { transactions } = await assembleBendFlashloanTransactions({
+    fromAddress,
+    amountIn: rawSupplyCollateralAmount,
+    tokenIn: collateralToken,
+    primaryAddress,
+    bundle,
+    publicClient,
+    ensoWalletV2Address,
+    isAuthorized,
+  });
+
+  return {
+    bundle,
+    transactions,
+    positionEstimate: getPositionEstimate({
+      rawSupplyCollateralAmount,
+      collateralToken,
+      loanToken,
+      rawBorrowAmount,
+      formattedCollateralPriceInLoanAsset,
+      slippage,
+    }),
+  };
+}

package/src/actions/enso/getEnsoSwapBundle.ts

@@ -1,11 +1,11 @@
 import type { BundleAction } from "@ensofinance/sdk";
 import { ethAddress, zeroAddress } from "viem";
 
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
 import type {
   GetEnsoSwapBundleArgs,
   GetZapTransactionResponse,
-} from "~/types/enso";
+} from "../../types/enso";
 import { getTransactionsFromBundle } from "./util";
 
 export async function getEnsoSwapBundle({

package/src/actions/enso/getEnsoUserTokensWithBalances.ts

@@ -2,11 +2,11 @@ import type { EnsoClient } from "@ensofinance/sdk";
 import { type Config, getChains, multicall } from "@wagmi/core";
 import { type Address, formatUnits } from "viem";
 
-import { BeraMonitoring } from "~/errors/BeraMonitoring";
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import { initBeraError } from "~/errors/initBeraError";
-import type { BalanceToken } from "~/types/dex";
-import { beraToken, isToken } from "~/utils/tokens";
+import { BeraMonitoring } from "../../errors/BeraMonitoring";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import { initBeraError } from "../../errors/initBeraError";
+import type { BalanceToken } from "../../types/dex";
+import { beraToken, isToken } from "../../utils/tokens";
 import { getBalanceCall } from "../tokens/getWalletBalances";
 
 /**