@berachain/berajs 0.2.4 → 0.2.6-patch.1

package/src/actions/dex/getApiPool.ts

@@ -7,8 +7,8 @@ import {
 } from "@berachain/graphql/dex/api";
 import type { GqlChain } from "@berachain/graphql/pol/api";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { getApolloClient } from "../clients/getApolloClient";
 
 export async function getApiPool({
   poolId,

package/src/actions/dex/getGlobalLiquidityAndSwapVolume.ts

@@ -5,8 +5,8 @@ import {
   type GqlChain,
 } from "@berachain/graphql/dex/api";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { getApolloClient } from "../clients/getApolloClient";
 
 export async function getGlobalLiquidityAndSwapVolume(
   args: BeraJS.BaseFunctionArgs = {},

package/src/actions/dex/getIsTokenExploited.ts

@@ -7,7 +7,7 @@ import {
 } from "@berachain/graphql/dex/subgraph";
 import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
-import type { Token } from "~/types/dex";
+import type { Token } from "../../types/dex";
 import { getApolloClient } from "../clients/getApolloClient";
 
 /**

package/src/actions/dex/getOnChainPool.ts

@@ -17,9 +17,9 @@ import {
 
 import { GqlPoolType } from "@berachain/graphql/pol/api";
 
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import { initBeraError } from "~/errors/initBeraError";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import { initBeraError } from "../../errors/initBeraError";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { getPoolPausedState, type PoolStatus } from "./getPoolPausedState";
 
 export interface OnChainPool {

package/src/actions/dex/getPoolEvents.ts

@@ -5,8 +5,8 @@ import {
 } from "@berachain/graphql/dex/api";
 import type { GqlChain, GqlPoolEventType } from "@berachain/graphql/pol/api";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { getApolloClient } from "../clients/getApolloClient";
 
 export async function getPoolEvents({
   poolId,

package/src/actions/dex/getPoolHistoricalData.ts

@@ -8,8 +8,8 @@ import {
   type PoolHistoricalDataFragment,
 } from "@berachain/graphql/dex/api";
 
-import { getApolloClient } from "~/actions/clients/getApolloClient";
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
+import { getApolloClient } from "../clients/getApolloClient";
 
 /** @deprecated */
 export type PoolDayData = {

package/src/actions/dex/getVaultPausedState.ts

@@ -2,7 +2,7 @@ import type { PublicClient } from "viem";
 
 import { vaultAbi as balancerVaultAbi } from "@berachain/abis/bex/vault";
 
-import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
 export async function getVaultPausedState({
   publicClient,

package/src/actions/enso/__tests__/getBendDemultiplyBundle.action.unit.test.ts

@@ -0,0 +1,175 @@
+import {
+  type Address,
+  ethAddress,
+  getAddress,
+  parseUnits,
+  zeroAddress,
+} from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { getBendDemultiplyBundle } from "../getBendDemultiplyBundle";
+import {
+  collateral18,
+  loan6,
+  MOCK_BUNDLE_RESPONSE,
+  makeMockEnsoClient,
+  makeMockPublicClient,
+  TEST_ADDRESS,
+  TEST_MARKET_ID,
+  TEST_PRIMARY,
+} from "./helpers";
+
+vi.mock("../flashloan", () => ({
+  assembleBendFlashloanTransactions: vi.fn().mockResolvedValue({
+    transactions: [
+      { to: "0xbundle", data: "0x1234", value: 0n, gasLimit: 500000n },
+    ],
+    approvals: [],
+    ensoWalletFlashloanAdapter: "0x3333333333333333333333333333333333333333",
+  }),
+}));
+
+const mockEnsoClient = makeMockEnsoClient() as any;
+const mockPublicClient = makeMockPublicClient() as any;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockEnsoClient.getBundleData.mockResolvedValue(MOCK_BUNDLE_RESPONSE);
+});
+
+describe("getBendDemultiplyBundle", () => {
+  const baseArgs = {
+    fromAddress: TEST_ADDRESS,
+    repayAmount: parseUnits("5000", 6).toString(),
+    collateralToken: collateral18,
+    loanToken: loan6,
+    marketId: TEST_MARKET_ID,
+    primaryAddress: TEST_PRIMARY,
+    chainId: ChainId.MAINNET,
+    ensoClient: mockEnsoClient,
+    slippage: 0.5,
+    publicClient: mockPublicClient,
+    collateralPriceInLoanAsset: "2000",
+    currentCollateral: parseUnits("100", 18).toString(),
+    currentDebt: parseUnits("10000", 6).toString(),
+    ensoWalletV2Address: getAddress(
+      "0x2222222222222222222222222222222222222222",
+    ),
+    isAuthorized: true,
+  };
+
+  it("throws for missing fromAddress", async () => {
+    await expect(
+      getBendDemultiplyBundle({
+        ...baseArgs,
+        fromAddress: "" as Address,
+      }),
+    ).rejects.toThrow("fromAddress");
+  });
+
+  it("throws for zero repayAmount", async () => {
+    await expect(
+      getBendDemultiplyBundle({
+        ...baseArgs,
+        repayAmount: "0",
+      }),
+    ).rejects.toThrow("repayAmount");
+  });
+
+  it("throws for zero currentDebt", async () => {
+    await expect(
+      getBendDemultiplyBundle({
+        ...baseArgs,
+        currentDebt: "0",
+      }),
+    ).rejects.toThrow("currentDebt");
+  });
+
+  it("partial repay: no cleanup actions in callback", async () => {
+    await getBendDemultiplyBundle(baseArgs);
+
+    const bundleActions = mockEnsoClient.getBundleData.mock.calls[0][1];
+    expect(bundleActions).toHaveLength(1);
+    expect(bundleActions[0].action).toBe("flashloan");
+
+    // partial: route + repay + withdraw = 3 callback actions
+    const callback = bundleActions[0].args.callback;
+    expect(callback).toHaveLength(3);
+    expect(callback[0].action).toBe("route");
+    expect(callback[1].action).toBe("repay");
+    expect(callback[2].action).toBe("withdraw");
+  });
+
+  it("full repay: includes cleanup actions in callback", async () => {
+    await getBendDemultiplyBundle({
+      ...baseArgs,
+      repayAmount: parseUnits("10000", 6).toString(), // repay all debt
+    });
+
+    const callback =
+      mockEnsoClient.getBundleData.mock.calls[0][1][0].args.callback;
+    // full repay: route + repay + balance + route_back + deposit + withdraw = 6
+    expect(callback).toHaveLength(6);
+    expect(callback[0].action).toBe("route");
+    expect(callback[1].action).toBe("repay");
+    expect(callback[2].action).toBe("balance"); // cleanup
+    expect(callback[3].action).toBe("route"); // cleanup swap back
+    expect(callback[4].action).toBe("deposit"); // cleanup redeposit
+    expect(callback[5].action).toBe("withdraw");
+  });
+
+  it("full repay with clamped collateral: skips cleanup", async () => {
+    // Very little collateral — flashloan amount will be clamped
+    await getBendDemultiplyBundle({
+      ...baseArgs,
+      repayAmount: parseUnits("10000", 6).toString(),
+      currentCollateral: parseUnits("1", 18).toString(), // only 1 ETH
+    });
+
+    const callback =
+      mockEnsoClient.getBundleData.mock.calls[0][1][0].args.callback;
+    // clamped = no cleanup: route + repay + withdraw = 3
+    expect(callback).toHaveLength(3);
+  });
+
+  it("calls ensoClient with ensowallet-v2 strategy", async () => {
+    await getBendDemultiplyBundle(baseArgs);
+
+    const bundleConfig = mockEnsoClient.getBundleData.mock.calls[0][0];
+    expect(bundleConfig.routingStrategy).toBe("ensowallet-v2");
+    expect(bundleConfig.fromAddress).toBe(TEST_ADDRESS);
+  });
+
+  it("returns positionEstimate as reductions", async () => {
+    const result = await getBendDemultiplyBundle(baseArgs);
+
+    expect(result.positionEstimate).toBeDefined();
+    // These are reduction amounts, should be positive
+    expect(Number(result.positionEstimate.finalCollateral)).toBeGreaterThan(0);
+    expect(Number(result.positionEstimate.totalBorrow)).toBeGreaterThan(0);
+  });
+
+  it("normalizes zeroAddress to ethAddress", async () => {
+    const zeroCollateral = { ...collateral18, address: zeroAddress };
+
+    await getBendDemultiplyBundle({
+      ...baseArgs,
+      collateralToken: zeroCollateral,
+    });
+
+    const flashloanArgs = mockEnsoClient.getBundleData.mock.calls[0][1][0].args;
+    expect(flashloanArgs.flashloanToken).toBe(ethAddress);
+  });
+
+  it("passes amountIn as '0' to assembleBendFlashloanTransactions", async () => {
+    const { assembleBendFlashloanTransactions } = await import("../flashloan");
+
+    await getBendDemultiplyBundle(baseArgs);
+
+    expect(assembleBendFlashloanTransactions).toHaveBeenCalledWith(
+      expect.objectContaining({ amountIn: "0" }),
+    );
+  });
+});

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

@@ -0,0 +1,150 @@
+import { parseUnits } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { InvalidArgumentError } from "../../../errors/InvalidArgumentError";
+import {
+  calculateDemultiplyCollateralAmount,
+  getPositionEstimate,
+} from "../getBendDemultiplyBundle";
+import { collateral6, collateral18, loan6, loan18 } from "./helpers";
+
+describe("calculateDemultiplyCollateralAmount", () => {
+  const baseArgs = {
+    repayAmount: parseUnits("10000", 6).toString(), // repay 10000 USDC
+    collateralPriceInLoanAsset: "2000", // 1 ETH = 2000 USDC
+    collateralToken: collateral18,
+    loanToken: loan6,
+    slippage: 0.5,
+    currentCollateral: parseUnits("100", 18).toString(), // 100 ETH available
+  };
+
+  it("calculates collateral needed to cover repayment", () => {
+    const result = calculateDemultiplyCollateralAmount(baseArgs);
+    const collateralEth = Number(result) / 1e18;
+
+    // Need to repay 10000 USDC, price is 2000 USDC/ETH, slippage 0.5%
+    // collateral = 10000 / (2000 * 0.995) ≈ 5.025 ETH
+    expect(collateralEth).toBeGreaterThan(5);
+    expect(collateralEth).toBeLessThan(5.1);
+  });
+
+  it("clamps to currentCollateral when needed amount exceeds position", () => {
+    const result = calculateDemultiplyCollateralAmount({
+      ...baseArgs,
+      currentCollateral: parseUnits("2", 18).toString(), // only 2 ETH
+    });
+
+    // Needs ~5 ETH but only has 2, should clamp
+    expect(result).toBe(parseUnits("2", 18).toString());
+  });
+
+  it("throws for zero price", () => {
+    expect(() =>
+      calculateDemultiplyCollateralAmount({
+        ...baseArgs,
+        collateralPriceInLoanAsset: "0",
+      }),
+    ).toThrow(InvalidArgumentError);
+  });
+
+  it("throws for negative price", () => {
+    expect(() =>
+      calculateDemultiplyCollateralAmount({
+        ...baseArgs,
+        collateralPriceInLoanAsset: "-100",
+      }),
+    ).toThrow(InvalidArgumentError);
+  });
+
+  it("returns '0' when repay amount is zero", () => {
+    const result = calculateDemultiplyCollateralAmount({
+      ...baseArgs,
+      repayAmount: "0",
+    });
+    expect(result).toBe("0");
+  });
+
+  it("returns integer string (no decimals)", () => {
+    const result = calculateDemultiplyCollateralAmount(baseArgs);
+    expect(result).toMatch(/^\d+$/);
+  });
+
+  it("higher slippage requires more collateral", () => {
+    const lowSlippage = calculateDemultiplyCollateralAmount({
+      ...baseArgs,
+      slippage: 0.5,
+    });
+    const highSlippage = calculateDemultiplyCollateralAmount({
+      ...baseArgs,
+      slippage: 5,
+    });
+
+    expect(Number(highSlippage)).toBeGreaterThan(Number(lowSlippage));
+  });
+
+  it("works with reversed decimal pairs (6 -> 18)", () => {
+    const result = calculateDemultiplyCollateralAmount({
+      repayAmount: parseUnits("5", 18).toString(), // repay 5 ETH
+      collateralPriceInLoanAsset: "0.0005", // 1 USDC = 0.0005 ETH
+      collateralToken: collateral6,
+      loanToken: loan18,
+      slippage: 0.5,
+      currentCollateral: parseUnits("1000000", 6).toString(), // 1M USDC
+    });
+
+    const collateralUsdc = Number(result) / 1e6;
+    // Need 5 ETH, price is 0.0005 ETH/USDC → need 10000 USDC + slippage
+    expect(collateralUsdc).toBeGreaterThan(10000);
+    expect(collateralUsdc).toBeLessThan(10100);
+  });
+});
+
+describe("getPositionEstimate (demultiply)", () => {
+  it("returns collateral and debt reductions in human-readable format", () => {
+    const result = getPositionEstimate({
+      repayAmount: parseUnits("5000", 6).toString(),
+      collateralToWithdraw: parseUnits("3", 18).toString(),
+      collateralToken: collateral18,
+      loanToken: loan6,
+    });
+
+    expect(Number(result.finalCollateral)).toBe(3);
+    expect(Number(result.totalBorrow)).toBe(5000);
+  });
+
+  it("handles small amounts without precision loss", () => {
+    const result = getPositionEstimate({
+      repayAmount: "1", // 1 raw unit = 0.000001 USDC
+      collateralToWithdraw: "1", // 1 raw unit = 1e-18 ETH
+      collateralToken: collateral18,
+      loanToken: loan6,
+    });
+
+    expect(Number(result.totalBorrow)).toBeCloseTo(0.000001, 10);
+    expect(Number(result.finalCollateral)).toBeCloseTo(1e-18, 25);
+  });
+
+  it("handles zero values", () => {
+    const result = getPositionEstimate({
+      repayAmount: "0",
+      collateralToWithdraw: "0",
+      collateralToken: collateral18,
+      loanToken: loan6,
+    });
+
+    expect(Number(result.finalCollateral)).toBe(0);
+    expect(Number(result.totalBorrow)).toBe(0);
+  });
+
+  it("works with 6-decimal collateral", () => {
+    const result = getPositionEstimate({
+      repayAmount: parseUnits("1", 18).toString(),
+      collateralToWithdraw: parseUnits("2000", 6).toString(),
+      collateralToken: collateral6,
+      loanToken: loan18,
+    });
+
+    expect(Number(result.finalCollateral)).toBe(2000);
+    expect(Number(result.totalBorrow)).toBe(1);
+  });
+});

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

@@ -0,0 +1,138 @@
+import {
+  type Address,
+  ethAddress,
+  getAddress,
+  parseUnits,
+  zeroAddress,
+} from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { getBendMultiplyBundle } from "../getBendMultiplyBundle";
+import {
+  collateral18,
+  loan6,
+  MOCK_BUNDLE_RESPONSE,
+  makeMockEnsoClient,
+  makeMockPublicClient,
+  TEST_ADDRESS,
+  TEST_MARKET_ID,
+  TEST_PRIMARY,
+} from "./helpers";
+
+vi.mock("../flashloan", () => ({
+  assembleBendFlashloanTransactions: vi.fn().mockResolvedValue({
+    transactions: [
+      { to: "0xbundle", data: "0x1234", value: 0n, gasLimit: 500000n },
+    ],
+    approvals: [],
+    ensoWalletFlashloanAdapter: "0x3333333333333333333333333333333333333333",
+  }),
+}));
+
+const mockEnsoClient = makeMockEnsoClient() as any;
+const mockPublicClient = makeMockPublicClient() as any;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockEnsoClient.getBundleData.mockResolvedValue(MOCK_BUNDLE_RESPONSE);
+});
+
+describe("getBendMultiplyBundle", () => {
+  const baseArgs = {
+    fromAddress: TEST_ADDRESS,
+    rawSupplyCollateralAmount: parseUnits("10", 18).toString(),
+    rawCurrentCollateralAmount: "0",
+    rawCurrentBorrowAmount: "0",
+    collateralToken: collateral18,
+    loanToken: loan6,
+    marketId: TEST_MARKET_ID,
+    primaryAddress: TEST_PRIMARY,
+    chainId: ChainId.MAINNET,
+    ensoClient: mockEnsoClient,
+    slippage: 0.5,
+    leverageMultiplier: 2,
+    publicClient: mockPublicClient,
+    formattedCollateralPriceInLoanAsset: "2000",
+    ensoWalletV2Address: getAddress(
+      "0x2222222222222222222222222222222222222222",
+    ),
+    isAuthorized: true,
+  };
+
+  it("throws for missing fromAddress", async () => {
+    await expect(
+      getBendMultiplyBundle({
+        ...baseArgs,
+        fromAddress: "" as Address,
+      }),
+    ).rejects.toThrow("fromAddress");
+  });
+
+  it("uses deposit-only actions when leverage = 1", async () => {
+    await getBendMultiplyBundle({
+      ...baseArgs,
+      leverageMultiplier: 1,
+    });
+
+    const bundleActions = mockEnsoClient.getBundleData.mock.calls[0][1];
+    expect(bundleActions).toHaveLength(1);
+    expect(bundleActions[0].action).toBe("deposit");
+  });
+
+  it("uses flashloan actions when leverage > 1", async () => {
+    await getBendMultiplyBundle(baseArgs);
+
+    const bundleActions = mockEnsoClient.getBundleData.mock.calls[0][1];
+    expect(bundleActions).toHaveLength(1);
+    expect(bundleActions[0].action).toBe("flashloan");
+    expect(bundleActions[0].args.callback).toHaveLength(4);
+  });
+
+  it("flashloan callback has correct action order", async () => {
+    await getBendMultiplyBundle(baseArgs);
+
+    const callback =
+      mockEnsoClient.getBundleData.mock.calls[0][1][0].args.callback;
+    expect(callback[0].action).toBe("route"); // swap loan -> collateral
+    expect(callback[1].action).toBe("balance"); // check collateral balance
+    expect(callback[2].action).toBe("deposit"); // deposit collateral
+    expect(callback[3].action).toBe("borrow"); // borrow to repay flashloan
+  });
+
+  it("calls ensoClient.getBundleData with ensowallet-v2 strategy", async () => {
+    await getBendMultiplyBundle(baseArgs);
+
+    const bundleConfig = mockEnsoClient.getBundleData.mock.calls[0][0];
+    expect(bundleConfig.routingStrategy).toBe("ensowallet-v2");
+    expect(bundleConfig.fromAddress).toBe(TEST_ADDRESS);
+    expect(bundleConfig.chainId).toBe(ChainId.MAINNET);
+  });
+
+  it("returns positionEstimate with transactions", async () => {
+    const result = await getBendMultiplyBundle(baseArgs);
+
+    expect(result.bundle).toBeDefined();
+    expect(result.transactions).toBeDefined();
+    expect(result.positionEstimate).toBeDefined();
+    expect(Number(result.positionEstimate.finalCollateral)).toBeGreaterThan(0);
+    expect(Number(result.positionEstimate.totalBorrow)).toBeGreaterThan(0);
+  });
+
+  it("normalizes zeroAddress to ethAddress for tokens", async () => {
+    const zeroCollateral = {
+      ...collateral18,
+      address: zeroAddress,
+    };
+
+    await getBendMultiplyBundle({
+      ...baseArgs,
+      collateralToken: zeroCollateral,
+    });
+
+    const bundleActions = mockEnsoClient.getBundleData.mock.calls[0][1];
+    const flashloanArgs = bundleActions[0].args;
+    expect(flashloanArgs.tokenIn).toBe(ethAddress);
+  });
+});