@berachain/berajs 0.2.5 → 0.2.6-patch.2

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";
 
 /**

package/src/actions/enso/util.ts

@@ -1,11 +1,44 @@
-import { type Address, erc20Abi, ethAddress } from "viem";
+import {
+  type Address,
+  encodeFunctionData,
+  erc20Abi,
+  ethAddress,
+  formatUnits,
+  getAddress,
+  zeroAddress,
+} from "viem";
 
-import type { GetZapTransactions, GetZapTransactionsArgs } from "~/types/enso";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import type { AllowanceQueryItem, Token } from "../../types/dex";
+import type {
+  GetEnsoWalletTransactionsWithApprovalArgs,
+  GetZapTransactions,
+  GetZapTransactionsArgs,
+} from "../../types/enso";
+
+/**
+ * Convert a token address to Enso-compatible format.
+ * Enso uses the special `ethAddress` sentinel for native tokens instead of `zeroAddress`.
+ */
+export function toEnsoAddress(address: Address): Address {
+  return address === zeroAddress ? ethAddress : address;
+}
+
+function toBigIntOrUndefined(
+  value: string | number | bigint | null | undefined,
+): bigint | undefined {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  return typeof value === "bigint" ? value : BigInt(value);
+}
 
 /**
  * Get the zap transactions for a given bundle.
  * @param args - The arguments for the zap transactions.
- * @returns The the zap transaction & approval transaction if required.
+ * @returns The zap transaction & approval transaction if required.
  */
 export const getTransactionsFromBundle = async ({
   fromAddress,
@@ -42,19 +75,131 @@ export const getTransactionsFromBundle = async ({
 
     // Only add approval transaction if it's actually required
     if (requiresApproval) {
+      const approvalValue = toBigIntOrUndefined(approvalRequest.tx.value) ?? 0n;
       transactions.push({
         to: approvalRequest.tx.to,
         data: approvalRequest.tx.data as `0x${string}`,
-        value: approvalRequest.tx.value as unknown as bigint,
+        value: approvalValue,
         gasLimit: BigInt(approvalRequest.gas),
       });
     }
   }
+  const bundleValue = toBigIntOrUndefined(bundle.tx.value) ?? 0n;
   transactions.push({
     to: bundle.tx.to,
     data: bundle.tx.data as `0x${string}`,
-    value: bundle.tx.value as unknown as bigint,
+    value: bundleValue,
     gasLimit: BigInt(bundle.gas),
   });
   return transactions;
 };
+
+/**
+ * Get ensowallet transactions for a bundle with approval handling.
+ * Checks allowance on the ensowallet spender and prepends approval when needed.
+ * @param args - The arguments for transaction generation.
+ * @returns The bundle transaction and optional approval transaction.
+ */
+export const getEnsoWalletTransactionsWithApproval = async ({
+  fromAddress,
+  amountIn,
+  tokenIn,
+  bundle,
+  publicClient,
+}: GetEnsoWalletTransactionsWithApprovalArgs): Promise<{
+  transactions: GetZapTransactions;
+  approval: AllowanceQueryItem | null;
+}> => {
+  const transactions: GetZapTransactions = [];
+  const spender = getAddress(bundle.tx.to);
+  let approval: AllowanceQueryItem | null = null;
+
+  /**
+   * If the token is not the native token, we need to check if approval is required.
+   */
+  const tokenInAddress = toEnsoAddress(tokenIn.address);
+  if (tokenInAddress !== ethAddress) {
+    // Check current allowance
+    const currentAllowance = await publicClient.readContract({
+      address: tokenIn.address as Address,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [fromAddress, spender],
+    });
+
+    const amountInBigInt = BigInt(amountIn);
+    const requiresApproval = currentAllowance < amountInBigInt;
+
+    // Only add approval transaction if it's actually required
+    if (requiresApproval) {
+      const raw = amountInBigInt.toString();
+      approval = {
+        token: tokenIn,
+        amount: {
+          raw,
+          formatted: formatUnits(amountInBigInt, tokenIn.decimals),
+        },
+        spender,
+      };
+
+      const approvalData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [spender, amountInBigInt],
+      });
+
+      transactions.push({
+        to: tokenIn.address,
+        data: approvalData,
+        value: 0n,
+      });
+    }
+  }
+  const bundleValue = toBigIntOrUndefined(bundle.tx.value) ?? 0n;
+  transactions.push({
+    to: bundle.tx.to,
+    data: bundle.tx.data as `0x${string}`,
+    value: bundleValue,
+    gasLimit: bundle.gas ? BigInt(bundle.gas) : undefined,
+  });
+  return { transactions, approval };
+};
+
+/**
+ * Compute the fraction of swap output retained after accounting for slippage.
+ *
+ * @param slippage  Slippage tolerance as a percentage (e.g. 0.5 means 0.5%).
+ * @returns `1 - slippage/100`. Throws if the result is non-positive.
+ */
+export function computeSwapOutputRatio(slippage: number): BigNumber {
+  const slippageRatio = new BigNumber(slippage).dividedBy(100);
+  const ratio = new BigNumber(1).minus(slippageRatio);
+
+  if (ratio.lte(0)) {
+    throw new InvalidArgumentError({
+      property: "slippage",
+      value: slippage,
+      expected: "a value lower than 100",
+    });
+  }
+
+  return ratio;
+}
+
+/**
+ * Convert a human-readable collateral-to-loan price into a raw-unit ratio.
+ *
+ * The result expresses how many raw loan-token units correspond to one raw
+ * collateral-token unit:
+ *
+ *   rawPrice = formattedPrice * (10^loanDecimals) / (10^collateralDecimals)
+ */
+export function computeRawCollateralToLoanPrice(
+  formattedPrice: BigNumber,
+  collateralToken: Token,
+  loanToken: Token,
+): BigNumber {
+  return formattedPrice
+    .multipliedBy(new BigNumber(10).pow(loanToken.decimals))
+    .dividedBy(new BigNumber(10).pow(collateralToken.decimals));
+}

package/src/actions/exports.ts

@@ -24,7 +24,6 @@ export * from "./dex/getPoolEvents";
 export * from "./dex/getPoolHistoricalData";
 export * from "./dex/getPoolPausedState";
 export * from "./dex/getPoolWithState";
-export * from "./dex/getSubgraphPool";
 export * from "./dex/getVaultPausedState";
 export * from "./governance/checkProposalField";
 export * from "./governance/computeActualStatus";
@@ -94,7 +93,6 @@ export * from "./validators/getApiEnrichedAllocation";
 export * from "./validators/getApiValidator";
 export * from "./validators/getDailyValidatorBlockStats";
 export * from "./validators/getDefaultRewardAllocation";
-export * from "./validators/getManagedValidatorByAccount";
 export * from "./validators/getStakingPoolBatch";
 export * from "./validators/getUserActiveValidators";
 export * from "./validators/getUserBoostsOnValidator";

package/src/actions/governance/__tests__/checkProposalField.unit.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, it } from "vitest";
 
 import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
 
-import { ProposalErrorCodes } from "~/enum/governance";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { ProposalErrorCodes } from "../../../enum/governance";
+import { parseBaseArgs } from "../../../utils/parseBaseArgs";
 import { checkProposalField } from "../checkProposalField";
 
 describe("checkProposalField", () => {

package/src/actions/governance/__tests__/getDecodedFunctionData.integration.test.ts

@@ -5,8 +5,8 @@ import { ChainId, defaultChainId } from "@berachain/config/internal";
 
 import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
 
-import { getServerSidePublicClient } from "~/utils/getServerSideClient";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getServerSidePublicClient } from "../../../utils/getServerSideClient";
+import { parseBaseArgs } from "../../../utils/parseBaseArgs";
 import { getDecodedFunctionData } from "../getDecodedFunctionData";
 
 describe.skipIf(defaultChainId !== ChainId.MAINNET)(

package/src/actions/governance/__tests__/getQuorum.integration.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, it } from "vitest";
 
 import { ChainId, defaultChainId } from "@berachain/config/internal";
 
-import { getServerSidePublicClient } from "~/utils/getServerSideClient";
-import { getTestClient } from "~/utils/getTestClient";
+import { getServerSidePublicClient } from "../../../utils/getServerSideClient";
+import { getTestClient } from "../../../utils/getTestClient";
 import { getQuorum } from "../getQuorum";
 
 describe("getQuorum", () => {

package/src/actions/governance/checkProposalField.ts

@@ -1,6 +1,6 @@
 import { type AbiParameter, isAddress, isHex } from "viem";
 
-import { ProposalErrorCodes } from "~/enum/governance";
+import { ProposalErrorCodes } from "../../enum/governance";
 
 type CheckProposalFieldResultMinimal = ProposalErrorCodes | null;
 

package/src/actions/governance/computeActualStatus.ts

@@ -3,7 +3,7 @@ import {
   ProposalStatus,
 } from "@berachain/graphql/governance";
 
-import { ProposalState } from "~/enum/governance";
+import { ProposalState } from "../../enum/governance";
 
 const GOVERNANCE_ACCELERATE_PROPOSAL = false;
 

package/src/actions/governance/getAllProposals.ts

@@ -11,7 +11,7 @@ import {
   type SearchProposalsQueryVariables,
 } from "@berachain/graphql/governance";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { getApolloClient } from "../clients/getApolloClient";
 import { computeActualStatus } from "./computeActualStatus";
 
 export async function getAllProposals({

package/src/actions/governance/getBodyErrors.ts

@@ -2,7 +2,7 @@ import type {
   CustomProposal,
   CustomProposalErrors,
   GovernanceTopic,
-} from "~/types/governance";
+} from "../../types/governance";
 import { checkProposalField } from "./checkProposalField";
 
 export const getBodyErrors = (

package/src/actions/governance/getProposalDetails.ts

@@ -7,7 +7,7 @@ import {
   type ProposalWithVotesFragment,
 } from "@berachain/graphql/governance";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { getApolloClient } from "../clients/getApolloClient";
 import { computeActualStatus } from "./computeActualStatus";
 
 export async function getProposalDetails({

package/src/actions/governance/getProposalFromTx.ts

@@ -13,7 +13,7 @@ import {
   type ProposalWithVotesFragment,
 } from "@berachain/graphql/governance";
 
-import { assertPublicClient } from "~/errors/assert";
+import { assertPublicClient } from "../../errors/assert";
 import { parseProposalBody } from "./parseProposalBody";
 
 export async function getProposalFromTx(