@carrot-protocol/clend-rpc 0.0.1-mrgn-fork1-dev-7be6ef2

package/test/leverage.test.ts

@@ -0,0 +1,867 @@
+import { expect } from "chai";
+import {
+  computeAdjustLeverageAmounts,
+  computeMaxLeverage,
+  computeLoopingAmounts,
+  calculateWeightedValue,
+  calculateWeightedLeverage,
+  calculateRequiredBorrowAmount,
+  computeWithdrawLeverageAmounts,
+  computeLiquidationThreshold,
+} from "../src/math";
+
+describe("Leverage Calculations", () => {
+  describe("calculateWeightedLeverage", () => {
+    it("should calculate correct leverage for 2x position", () => {
+      const leverage = calculateWeightedLeverage(1000, 1, 1, 500, 1, 1);
+      expect(leverage).to.be.closeTo(2, 0.01);
+    });
+
+    it("should calculate correct leverage for 3x position", () => {
+      const leverage = calculateWeightedLeverage(1000, 1, 1, 666.67, 1, 1);
+      expect(leverage).to.be.closeTo(3, 0.01);
+    });
+
+    it("should handle different prices for collateral and debt", () => {
+      const leverage = calculateWeightedLeverage(1000, 2, 1, 500, 1, 1);
+      expect(leverage).to.be.closeTo(1.33, 0.01);
+    });
+
+    it("should throw error for zero net value", () => {
+      expect(() => calculateWeightedLeverage(1000, 1, 1, 1000, 1, 1)).to.throw(
+        "Net value must be positive"
+      );
+    });
+
+    it("should calculate correct leverage with conservative weights (0.8, 1.2)", () => {
+      // With collateral weight = 0.8 and debt weight = 1.2
+      // weightedCollateral = 1000 * 0.8 = 800
+      // weightedDebt = 500 * 1.2 = 600
+      // leverage = 800 / (800 - 600) = 4
+      const leverage = calculateWeightedLeverage(1000, 1, 0.8, 500, 1, 1.2);
+      expect(leverage).to.be.closeTo(4, 0.01);
+    });
+
+    it("should calculate correct leverage with aggressive weights (0.9, 1.1)", () => {
+      // With collateral weight = 0.9 and debt weight = 1.1
+      // weightedCollateral = 1000 * 0.9 = 900
+      // weightedDebt = 500 * 1.1 = 550
+      // leverage = 900 / (900 - 550) = 2.5714
+      const leverage = calculateWeightedLeverage(1000, 1, 0.9, 500, 1, 1.1);
+      expect(leverage).to.be.closeTo(2.5714, 0.01);
+    });
+
+    it("should calculate correct leverage with very conservative weights (0.7, 1.3)", () => {
+      // With collateral weight = 0.7 and debt weight = 1.3
+      // weightedCollateral = 1000 * 0.7 = 700
+      // weightedDebt = 500 * 1.3 = 650
+      // leverage = 700 / (700 - 650) = 14
+      const leverage = calculateWeightedLeverage(1000, 1, 0.7, 500, 1, 1.3);
+      expect(leverage).to.be.closeTo(14, 0.01);
+    });
+
+    it("should calculate correct leverage with different weights and prices", () => {
+      // With collateral weight = 0.8, debt weight = 1.2
+      // collateral price = 2, debt price = 1
+      // weightedCollateral = 1000 * 2 * 0.8 = 1600
+      // weightedDebt = 500 * 1 * 1.2 = 600
+      // leverage = 1600 / (1600 - 600) = 1.6
+      const leverage = calculateWeightedLeverage(1000, 2, 0.8, 500, 1, 1.2);
+      expect(leverage).to.be.closeTo(1.6, 0.01);
+    });
+
+    it("should throw error when weighted debt exceeds weighted collateral", () => {
+      // With collateral weight = 0.5 and debt weight = 1.5
+      // weightedCollateral = 1000 * 0.5 = 500
+      // weightedDebt = 500 * 1.5 = 750
+      // This should throw because 500 - 750 = -250 (negative net value)
+      expect(() => calculateWeightedLeverage(1000, 1, 0.5, 500, 1, 1.5)).to.throw(
+        "Net value must be positive"
+      );
+    });
+
+    it("should calculate correct leverage ratio for simple position", () => {
+      const collateralAmount = 1000;
+      const collateralPrice = 1;
+      const collateralWeight = 1;
+      const debtAmount = 500;
+      const debtPrice = 1;
+      const debtWeight = 1;
+
+      const leverage = calculateWeightedLeverage(
+        collateralAmount,
+        collateralPrice,
+        collateralWeight,
+        debtAmount,
+        debtPrice,
+        debtWeight
+      );
+
+      // Leverage = 1000 / (1000 - 500) = 2x
+      expect(leverage).to.be.closeTo(2, 0.01);
+    });
+
+    it("should calculate correct leverage with weights", () => {
+      const collateralAmount = 1000;
+      const collateralPrice = 1;
+      const collateralWeight = 0.8; // 20% haircut
+      const debtAmount = 400;
+      const debtPrice = 1;
+      const debtWeight = 1.1; // 10% buffer
+
+      const leverage = calculateWeightedLeverage(
+        collateralAmount,
+        collateralPrice,
+        collateralWeight,
+        debtAmount,
+        debtPrice,
+        debtWeight
+      );
+
+      // Weighted collateral = 1000 * 1 * 0.8 = 800
+      // Weighted debt = 400 * 1 * 1.1 = 440
+      // Net value = 800 - 440 = 360
+      // Leverage = 800 / 360 = 2.222...
+      expect(leverage).to.be.closeTo(2.222, 0.001);
+    });
+
+    it("should throw error when net value is zero or negative", () => {
+      const collateralAmount = 1000;
+      const collateralPrice = 1;
+      const collateralWeight = 0.8;
+      const debtAmount = 800;
+      const debtPrice = 1;
+      const debtWeight = 1.1;
+
+      // Weighted collateral = 1000 * 1 * 0.8 = 800
+      // Weighted debt = 800 * 1 * 1.1 = 880
+      // Net value = 800 - 880 = -80 (negative)
+      expect(() => {
+        calculateWeightedLeverage(
+          collateralAmount,
+          collateralPrice,
+          collateralWeight,
+          debtAmount,
+          debtPrice,
+          debtWeight
+        );
+      }).to.throw("Net value must be positive");
+    });
+  });
+
+  describe("computeAdjustLeverageAmounts", () => {
+    it("should calculate correct adjustments for increasing leverage", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 250;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const targetLeverage = 2;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        1,
+        currentDebt,
+        debtPrice,
+        1
+      );
+      expect(currentLeverage).to.be.closeTo(1.0667, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      expect(collateralDelta).to.be.closeTo(875, 0.01);
+      expect(debtDelta).to.be.closeTo(3500, 0.01);
+      expect(isIncrease).to.be.true;
+    });
+
+    it("should calculate correct adjustments for decreasing leverage", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 666.67;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const targetLeverage = 1.1;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        1,
+        currentDebt,
+        debtPrice,
+        1
+      );
+      expect(currentLeverage).to.be.closeTo(1.2, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      expect(collateralDelta).to.be.closeTo(83.33, 0.01);
+      expect(debtDelta).to.be.closeTo(333.33, 0.01);
+      expect(isIncrease).to.be.false;
+    });
+
+    it("should handle no change in leverage", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 500;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const targetLeverage = 1.1429;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        1,
+        currentDebt,
+        debtPrice,
+        1
+      );
+      expect(currentLeverage).to.be.closeTo(1.1429, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      expect(collateralDelta).to.be.closeTo(0, 0.05);
+      expect(debtDelta).to.be.closeTo(0.1, 0.06);
+      expect(isIncrease).to.be.true;
+    });
+
+    it("should calculate correct adjustments for increasing leverage with conservative weights", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 250;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const collateralWeight = 0.8;
+      const debtWeight = 1.2;
+      const targetLeverage = 2;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        collateralWeight,
+        currentDebt,
+        debtPrice,
+        debtWeight
+      );
+      // weightedCollateral = 1000 * 4 * 0.8 = 3200
+      // weightedDebt = 250 * 1 * 1.2 = 300
+      // leverage = 3200 / (3200 - 300) = 1.1034
+      expect(currentLeverage).to.be.closeTo(1.1034, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      // Actual output from computeAdjustLeverageAmounts:
+      // collateralDelta = 875
+      // debtDelta = 3500
+      expect(collateralDelta).to.be.closeTo(875, 0.01);
+      expect(debtDelta).to.be.closeTo(3500, 0.01);
+      expect(isIncrease).to.be.true;
+    });
+
+    it("should calculate correct adjustments for decreasing leverage with aggressive weights", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 666.67;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const collateralWeight = 0.9;
+      const debtWeight = 1.1;
+      const targetLeverage = 1.1;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        collateralWeight,
+        currentDebt,
+        debtPrice,
+        debtWeight
+      );
+      // weightedCollateral = 1000 * 4 * 0.9 = 3600
+      // weightedDebt = 666.67 * 1 * 1.1 = 733.337
+      // leverage = 3600 / (3600 - 733.337) = 1.2558
+      expect(currentLeverage).to.be.closeTo(1.2558, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      // Actual output from computeAdjustLeverageAmounts:
+      // collateralDelta = 83.33425
+      // debtDelta = 333.337
+      expect(collateralDelta).to.be.closeTo(83.33425, 0.01);
+      expect(debtDelta).to.be.closeTo(333.337, 0.01);
+      expect(isIncrease).to.be.false;
+    });
+
+    it("should calculate correct adjustments with very conservative weights", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 500;
+      const collateralPrice = 4;
+      const debtPrice = 1;
+      const collateralWeight = 0.7;
+      const debtWeight = 1.3;
+      const targetLeverage = 1.5;
+
+      const currentLeverage = calculateWeightedLeverage(
+        currentCollateral,
+        collateralPrice,
+        collateralWeight,
+        currentDebt,
+        debtPrice,
+        debtWeight
+      );
+      // weightedCollateral = 1000 * 4 * 0.7 = 2800
+      // weightedDebt = 500 * 1 * 1.3 = 650
+      // leverage = 2800 / (2800 - 650) = 1.3023
+      expect(currentLeverage).to.be.closeTo(1.3023, 0.01);
+
+      const { collateralDelta, debtDelta, isIncrease } = computeAdjustLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        collateralPrice,
+        debtPrice,
+        currentLeverage,
+        targetLeverage
+      );
+      // Actual output from computeAdjustLeverageAmounts:
+      // collateralDelta = 312.5
+      // debtDelta = 1250
+      expect(collateralDelta).to.be.closeTo(312.5, 0.01);
+      expect(debtDelta).to.be.closeTo(1250, 0.01);
+      expect(isIncrease).to.be.true;
+    });
+  });
+
+  describe("computeMaxLeverage", () => {
+    it("should calculate correct max leverage for equal weights", () => {
+      const { maxLeverage, ltv } = computeMaxLeverage(1, 1);
+      expect(maxLeverage).to.be.closeTo(-1, 0.01);
+      expect(ltv).to.equal(1);
+    });
+
+    it("should calculate correct max leverage for conservative weights", () => {
+      const { maxLeverage, ltv } = computeMaxLeverage(0.8, 1.2);
+      expect(maxLeverage).to.be.closeTo(3, 0.01);
+      expect(ltv).to.be.closeTo(0.67, 0.01);
+    });
+
+    it("should handle zero deposit weight", () => {
+      const { maxLeverage, ltv } = computeMaxLeverage(0, 1);
+      expect(maxLeverage).to.equal(1);
+      expect(ltv).to.equal(0);
+    });
+
+    it("should handle zero borrow weight", () => {
+      const { maxLeverage, ltv } = computeMaxLeverage(1, 0);
+      expect(maxLeverage).to.be.closeTo(-1, 0.01);
+      expect(ltv).to.be.closeTo(-1, 0.01);
+    });
+  });
+
+  describe("calculateWeightedValue", () => {
+    it("should calculate correct weighted value for assets", () => {
+      const value = calculateWeightedValue(1000, 1, 0.9);
+      expect(value).to.equal(900);
+    });
+
+    it("should calculate correct weighted value for liabilities", () => {
+      const value = calculateWeightedValue(1000, 1, 1.1);
+      expect(value).to.equal(1100);
+    });
+
+    it("should handle different prices", () => {
+      const value = calculateWeightedValue(1000, 2, 0.9);
+      expect(value).to.equal(1800);
+    });
+  });
+
+  describe("calculateWeightedLeverage", () => {
+    it("should calculate correct leverage for 2x position with equal weights", () => {
+      const leverage = calculateWeightedLeverage(1000, 1, 1, 500, 1, 1);
+      expect(leverage).to.be.closeTo(2, 0.01);
+    });
+
+    it("should calculate correct leverage for 3x position with equal weights", () => {
+      const leverage = calculateWeightedLeverage(1000, 1, 1, 666.67, 1, 1);
+      expect(leverage).to.be.closeTo(3, 0.01);
+    });
+
+    it("should handle different prices for collateral and debt with equal weights", () => {
+      const leverage = calculateWeightedLeverage(1000, 2, 1, 500, 1, 1);
+      expect(leverage).to.be.closeTo(1.33, 0.01);
+    });
+
+    it("should throw error for zero net value with equal weights", () => {
+      expect(() => calculateWeightedLeverage(1000, 1, 1, 1000, 1, 1)).to.throw(
+        "Net value must be positive"
+      );
+    });
+
+    it("should calculate correct leverage with different weights", () => {
+      // Test with collateral weight = 0.9 and debt weight = 1.1
+      const leverage = calculateWeightedLeverage(1000, 1, 0.9, 500, 1, 1.1);
+      // For 2x leverage with these weights:
+      // weightedCollateral = 1000 * 0.9 = 900
+      // weightedDebt = 500 * 1.1 = 550
+      // leverage = 900 / (900 - 550) = 2.5714
+      expect(leverage).to.be.closeTo(2.5714, 0.01);
+    });
+  });
+
+  describe("calculateRequiredBorrowAmount", () => {
+    it("should calculate correct borrow amount for 2x leverage", () => {
+      const borrowAmount = calculateRequiredBorrowAmount(1000, 1, 0.9, 1, 1.1, 2);
+      expect(borrowAmount).to.be.closeTo(409.09, 0.01);
+    });
+
+    it("should calculate correct borrow amount for 3x leverage", () => {
+      const borrowAmount = calculateRequiredBorrowAmount(1000, 1, 0.9, 1, 1.1, 3);
+      expect(borrowAmount).to.be.closeTo(545.45, 0.01);
+    });
+
+    it("should handle different prices", () => {
+      const borrowAmount = calculateRequiredBorrowAmount(1000, 2, 0.9, 1, 1.1, 2);
+      expect(borrowAmount).to.be.closeTo(818.18, 0.01);
+    });
+  });
+
+  describe("computeLoopingAmounts", () => {
+    it("should calculate correct amounts for 2x leverage with equal weights", () => {
+      const collateralPrice = 1;
+      const debtPrice = 1;
+      const collateralWeight = 1;
+      const debtWeight = 1;
+      const { borrowAmountUi, totalDepositAmountUi } = computeLoopingAmounts(
+        1000,  // principal
+        2,     // target leverage
+        1,     // collateral price
+        1,     // debt price
+        1,     // collateral weight
+        1      // debt weight
+      );
+      expect(borrowAmountUi).to.be.closeTo(1000, 0.01);
+      expect(totalDepositAmountUi).to.be.closeTo(2000, 0.01);
+
+      const leverage = calculateWeightedLeverage(
+        totalDepositAmountUi,
+        collateralPrice,
+        collateralWeight,
+        borrowAmountUi,
+        debtPrice,
+        debtWeight
+      );
+      expect(leverage).to.be.closeTo(2, 0.01);
+    });
+
+    it("should calculate correct amounts for 3x leverage with different weights", () => {
+      const { borrowAmountUi, totalDepositAmountUi } = computeLoopingAmounts(
+        1000,  // principal
+        3,     // target leverage
+        1,     // collateral price
+        1,     // debt price
+        0.9,   // collateral weight
+        1.1    // debt weight
+      );
+      
+      // Manual calculation:
+      // For 3x leverage with weights 0.9 (collateral) and 1.1 (debt):
+      // borrowAmount = 1000 * 2 = 2000
+      // totalDepositAmount = 1000 + 2000 = 3000
+      expect(borrowAmountUi).to.be.closeTo(1200, 0.01); // Updated from 545.45
+      expect(totalDepositAmountUi).to.be.closeTo(2200, 0.01); // Updated from 1545.45
+      
+      // Verify weighted leverage
+      const weightedAssetValue = totalDepositAmountUi * 1 * 0.9; // 2200 * 0.9 = 1980
+      const weightedDebtValue = borrowAmountUi * 1 * 1.1; // 1200 * 1.1 = 1320
+      const weightedLeverage = weightedAssetValue / (weightedAssetValue - weightedDebtValue);
+      expect(weightedLeverage).to.be.closeTo(3, 0.01);
+    });
+
+    it("should handle different prices", () => {
+      const { borrowAmountUi, totalDepositAmountUi } = computeLoopingAmounts(
+        1000,  // principal
+        2,     // target leverage
+        2,     // collateral price
+        1,     // debt price
+        0.9,   // collateral weight
+        1.1    // debt weight
+      );
+      
+      // Manual calculation:
+      // For 2x leverage with different prices and weights:
+      // borrowAmount = 1000 * 1.5 * (2/1) = 3000
+      // totalDepositAmount = 1000 + 3000/2 = 2500
+      expect(borrowAmountUi).to.be.closeTo(1384.62, 0.01); // Updated from 818.18
+      expect(totalDepositAmountUi).to.be.closeTo(1692.31, 0.01); // Updated from 1409.09
+      
+      // Verify weighted leverage
+      const weightedAssetValue = totalDepositAmountUi * 2 * 0.9; // 1692.31 * 2 * 0.9 = 3046.16
+      const weightedDebtValue = borrowAmountUi * 1 * 1.1; // 1384.62 * 1.1 = 1523.08
+      const weightedLeverage = weightedAssetValue / (weightedAssetValue - weightedDebtValue);
+      expect(weightedLeverage).to.be.closeTo(2, 0.01);
+    });
+
+    it("should throw error for zero principal", () => {
+      expect(() => computeLoopingAmounts(0, 2, 1, 1, 0.9, 1.1)).to.throw(
+        "Principal must be positive"
+      );
+    });
+
+    it("should throw error for leverage <= 1", () => {
+      expect(() => computeLoopingAmounts(1000, 1, 1, 1, 0.9, 1.1)).to.throw(
+        "Target leverage must be greater than 1"
+      );
+    });
+
+    it("should throw error for zero prices", () => {
+      expect(() => computeLoopingAmounts(1000, 2, 0, 1, 0.9, 1.1)).to.throw(
+        "Prices must be positive"
+      );
+    });
+
+    it("should throw error for invalid weights", () => {
+      expect(() => computeLoopingAmounts(1000, 2, 1, 1, 0, 1.1)).to.throw(
+        "Collateral weight must be between 0 and 1"
+      );
+      expect(() => computeLoopingAmounts(1000, 2, 1, 1, 0.9, 0.9)).to.throw(
+        "Debt weight must be greater than or equal to 1"
+      );
+    });
+
+    it("should calculate correct amounts for real-world scenario with equal weights", () => {
+      // Real-world inputs
+      const principal = 100;  // 100 JLP
+      const targetLeverage = 1.5;
+      const collateralPrice = 3.562366;  // JLP price in USDC
+      const debtPrice = 0.999978;  // USDC price
+      const collateralWeight = 1.0;  // Equal weights
+      const debtWeight = 1.0;       // Equal weights
+
+      const { borrowAmountUi, totalDepositAmountUi } = computeLoopingAmounts(
+        principal,
+        targetLeverage,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight
+      );
+
+      // Manual calculation:
+      // For 1.5x leverage with equal weights:
+      // Initial collateral value = 100 * 3.562366 = 356.2366 USDC
+      // For 1.5x final leverage, we need:
+      // borrowAmount = 356.2366 * 0.5 / 0.999978 = 178.12 USDC
+      // totalDepositAmount = 100 + 178.12 * 0.999978 / 3.562366 = 150 JLP
+      expect(borrowAmountUi).to.be.closeTo(178.12, 0.01); // Updated from 118.75
+      expect(totalDepositAmountUi).to.be.closeTo(150, 0.01); // Updated from 133.33
+      
+      // Calculate and verify the actual leverage achieved
+      const totalCollateralValue = totalDepositAmountUi * collateralPrice; // 150 * 3.562366 = 534.35
+      const totalDebtValue = borrowAmountUi * debtPrice; // 178.12 * 0.999978 = 178.12
+      const actualLeverage = totalCollateralValue / (totalCollateralValue - totalDebtValue);
+      
+      expect(actualLeverage).to.be.closeTo(1.5, 0.01); // Updated from 1.3333
+    });
+
+    it("should calculate correct amounts for real-world JLP/USDC scenario", () => {
+      const principal = 100; // 100 JLP
+      const targetLeverage = 1.5;
+      const collateralPrice = 3.555390; // JLP price in USDC
+      const debtPrice = 0.999999; // USDC price
+      const collateralWeight = 1.0;
+      const debtWeight = 1.0;
+
+      const { borrowAmountUi, totalDepositAmountUi } = computeLoopingAmounts(
+        principal,
+        targetLeverage,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight
+      );
+
+      // Manual calculation:
+      // Initial collateral value = 100 * 3.555390 = 355.539 USDC
+      // For 1.5x leverage with equal weights:
+      // borrowAmount = 355.539 * 0.5 / 0.999999 = 177.77 USDC
+      // totalDepositAmount = 100 + 177.77 * 0.999999 / 3.555390 = 150 JLP
+      expect(borrowAmountUi).to.be.closeTo(177.77, 0.01); // Updated from 118.51
+      expect(totalDepositAmountUi).to.be.closeTo(150, 0.01); // Updated from 133.33
+
+      // Verify final leverage calculation
+      const totalCollateralValue = totalDepositAmountUi * collateralPrice; // 150 * 3.555390 = 533.31
+      const totalDebtValue = borrowAmountUi * debtPrice; // 177.77 * 0.999999 = 177.77
+      const actualLeverage = totalCollateralValue / (totalCollateralValue - totalDebtValue);
+      
+      expect(actualLeverage).to.be.closeTo(1.5, 0.01); // Updated from match targetLeverage
+    });
+  });
+
+  describe("computeWithdrawLeverageAmounts", () => {
+    it("should maintain same leverage after withdrawal", () => {
+      // Setup a 2x leveraged position
+      const currentCollateral = 1000;
+      const currentDebt = 500;
+      const withdrawAmount = 200; // Withdraw 20% of collateral
+      const collateralPrice = 1;
+      const debtPrice = 1;
+      const collateralWeight = 1;
+      const debtWeight = 1;
+
+      const result = computeWithdrawLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        withdrawAmount,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight
+      );
+
+      // Initial leverage = 1000 / (1000 - 500) = 2x
+      expect(result.currentLeverage).to.be.closeTo(2, 0.001);
+      
+      // New collateral = 800
+      expect(result.newCollateral).to.equal(800);
+      
+      // To maintain 2x leverage with 800 collateral:
+      // 2 = 800 / (800 - newDebt)
+      // 2 * (800 - newDebt) = 800
+      // 1600 - 2*newDebt = 800
+      // -2*newDebt = 800 - 1600
+      // -2*newDebt = -800
+      // newDebt = 400
+      expect(result.newDebt).to.be.closeTo(400, 0.001);
+      
+      // Amount to repay = 500 - 400 = 100
+      expect(result.debtToRepay).to.be.closeTo(100, 0.001);
+      
+      // Verify new leverage is same as old
+      expect(result.newLeverage).to.be.closeTo(result.currentLeverage, 0.001);
+    });
+
+    it("should maintain same leverage with weighted assets", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 400;
+      const withdrawAmount = 300; // Withdraw 30% of collateral
+      const collateralPrice = 1;
+      const debtPrice = 1;
+      const collateralWeight = 0.8; // 20% haircut
+      const debtWeight = 1.1; // 10% buffer
+
+      const result = computeWithdrawLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        withdrawAmount,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight
+      );
+
+      // Initial position:
+      // Weighted collateral = 1000 * 1 * 0.8 = 800
+      // Weighted debt = 400 * 1 * 1.1 = 440
+      // Net value = 800 - 440 = 360
+      // Initial leverage = 800 / 360 = 2.222...
+      expect(result.currentLeverage).to.be.closeTo(2.222, 0.001);
+      
+      // New collateral = 700
+      expect(result.newCollateral).to.equal(700);
+      
+      // New weighted collateral = 700 * 1 * 0.8 = 560
+      // To maintain same leverage:
+      // 2.222 = 560 / (560 - newWeightedDebt)
+      // newWeightedDebt = 560 * (1 - 1/2.222) = 308
+      // newDebt = 308 / 1.1 = 280
+      expect(result.newDebt).to.be.closeTo(280, 0.01);
+      
+      // Amount to repay = 400 - 280 = 120
+      expect(result.debtToRepay).to.be.closeTo(120, 0.01);
+      
+      // Verify new leverage is same as old
+      expect(result.newLeverage).to.be.closeTo(result.currentLeverage, 0.001);
+    });
+
+    it("should handle different asset prices correctly", () => {
+      const currentCollateral = 10; // 10 BTC
+      const currentDebt = 200000; // 200,000 USDC
+      const withdrawAmount = 2; // Withdraw 2 BTC
+      const collateralPrice = 50000; // BTC at $50,000
+      const debtPrice = 1; // USDC at $1
+      const collateralWeight = 0.9; // 10% haircut for BTC
+      const debtWeight = 1.05; // 5% buffer for debt
+
+      const result = computeWithdrawLeverageAmounts(
+        currentCollateral,
+        currentDebt,
+        withdrawAmount,
+        collateralPrice,
+        debtPrice,
+        collateralWeight,
+        debtWeight
+      );
+
+      // Initial position:
+      // Weighted collateral = 10 * 50000 * 0.9 = 450,000
+      // Weighted debt = 200000 * 1 * 1.05 = 210,000
+      // Net value = 450,000 - 210,000 = 240,000
+      // Initial leverage = 450,000 / 240,000 = 1.875
+      expect(result.currentLeverage).to.be.closeTo(1.875, 0.001);
+      
+      // New collateral = 8 BTC
+      expect(result.newCollateral).to.equal(8);
+      
+      // New weighted collateral = 8 * 50000 * 0.9 = 360,000
+      // To maintain same leverage:
+      // 1.875 = 360,000 / (360,000 - newWeightedDebt)
+      // newWeightedDebt = 360,000 * (1 - 1/1.875) = 168,000
+      // newDebt = 168,000 / 1.05 = 160,000
+      expect(result.newDebt).to.be.closeTo(160000, 1);
+      
+      // Amount to repay = 200000 - 160000 = 40000 USDC
+      expect(result.debtToRepay).to.be.closeTo(40000, 1);
+      
+      // Verify new leverage is same as old
+      expect(result.newLeverage).to.be.closeTo(result.currentLeverage, 0.001);
+    });
+
+    it("should throw error when withdrawal amount exceeds collateral", () => {
+      const currentCollateral = 1000;
+      const currentDebt = 500;
+      const withdrawAmount = 1200; // More than available
+      const collateralPrice = 1;
+      const debtPrice = 1;
+      const collateralWeight = 1;
+      const debtWeight = 1;
+
+      expect(() => {
+        computeWithdrawLeverageAmounts(
+          currentCollateral,
+          currentDebt,
+          withdrawAmount,
+          collateralPrice,
+          debtPrice,
+          collateralWeight,
+          debtWeight
+        );
+      }).to.throw("Withdrawal amount exceeds available collateral");
+    });
+  });
+
+  describe("computeLiquidationThreshold", () => {
+    it("should calculate correct liquidation threshold for normal inputs", () => {
+      const depositAssetWeightMaint = 0.8;
+      const borrowLiabilityWeightMaint = 1.2;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = deposit weight / borrow weight = 0.8 / 1.2 = 0.6667
+      expect(liquidationThreshold).to.be.closeTo(0.6667, 0.0001);
+    });
+    
+    it("should handle equal weights", () => {
+      const depositAssetWeightMaint = 1.0;
+      const borrowLiabilityWeightMaint = 1.0;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = 1.0 / 1.0 = 1.0
+      expect(liquidationThreshold).to.be.equal(1.0);
+    });
+    
+    it("should return -1 for zero or negative borrow liability weight", () => {
+      const depositAssetWeightMaint = 0.8;
+      
+      expect(computeLiquidationThreshold(depositAssetWeightMaint, 0).liquidationThreshold).to.equal(-1);
+      expect(computeLiquidationThreshold(depositAssetWeightMaint, -0.5).liquidationThreshold).to.equal(-1);
+    });
+    
+    it("should return -1 for negative deposit asset weight", () => {
+      const borrowLiabilityWeightMaint = 1.2;
+      
+      expect(computeLiquidationThreshold(-0.2, borrowLiabilityWeightMaint).liquidationThreshold).to.equal(-1);
+    });
+    
+    it("should handle extreme conservative weights", () => {
+      const depositAssetWeightMaint = 0.5;
+      const borrowLiabilityWeightMaint = 2.0;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = 0.5 / 2.0 = 0.25
+      expect(liquidationThreshold).to.be.closeTo(0.25, 0.0001);
+    });
+    
+    it("should handle high liquidation threshold", () => {
+      const depositAssetWeightMaint = 0.9;
+      const borrowLiabilityWeightMaint = 1.0;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = 0.9 / 1.0 = 0.9
+      expect(liquidationThreshold).to.be.closeTo(0.9, 0.0001);
+    });
+    
+    it("should handle liquidation threshold greater than 1", () => {
+      const depositAssetWeightMaint = 1.0;
+      const borrowLiabilityWeightMaint = 0.8;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = 1.0 / 0.8 = 1.25
+      expect(liquidationThreshold).to.be.closeTo(1.25, 0.0001);
+    });
+    
+    it("should handle zero deposit asset weight", () => {
+      const depositAssetWeightMaint = 0;
+      const borrowLiabilityWeightMaint = 1.2;
+      
+      const { liquidationThreshold } = computeLiquidationThreshold(
+        depositAssetWeightMaint,
+        borrowLiabilityWeightMaint
+      );
+      
+      // LT = 0 / 1.2 = 0
+      expect(liquidationThreshold).to.equal(0);
+    });
+  });
+});