@kamino-finance/klend-sdk 3.2.24 → 3.2.26

package/dist/classes/obligation.d.ts

@@ -37,6 +37,14 @@ interface BorrowStats {
     userTotalBorrowBorrowFactorAdjusted: Decimal;
     positions: number;
 }
+interface DepositStats {
+    deposits: Map<PublicKey, Position>;
+    userTotalDeposit: Decimal;
+    userTotalCollateralDeposit: Decimal;
+    borrowLimit: Decimal;
+    liquidationLtv: Decimal;
+    borrowLiquidationLimit: Decimal;
+}
 export declare class KaminoObligation {
     obligationAddress: PublicKey;
     state: Obligation;
@@ -118,33 +126,13 @@ export declare class KaminoObligation {
      */
     getNumberOfPositions(): number;
     getNetAccountValue(): Decimal;
-    /**
-     * Get the loan to value and liquidation loan to value for a collateral token reserve as ratios, accounting for the obligation elevation group if it is active
-     * @param market
-     * @param reserve
-     */
-    getLtvForReserve(market: KaminoMarket, reserve: KaminoReserve): {
-        maxLtv: Decimal;
-        liquidationLtv: Decimal;
-    };
-    /**
-     * Get the borrow factor for a borrow reserve, accounting for the obligation elevation group if it is active
-     * @param reserve
-     */
-    getBorrowFactorForReserve(reserve: KaminoReserve): Decimal;
     /**
      * @returns the potential elevation groups the obligation qualifies for
      */
     getElevationGroups(kaminoMarket: KaminoMarket): Array<number>;
     static getElevationGroupsForReserves(reserves: Array<KaminoReserve>): Array<number>;
-    calculateSimulatedBorrow(oldStats: ObligationStats, oldBorrows: Map<PublicKey, Position>, borrowAmount: Decimal, mint: PublicKey, reserves: Map<PublicKey, KaminoReserve>): {
-        stats: ObligationStats;
-        borrows: Map<PublicKey, Position>;
-    };
-    calculateSimulatedDeposit(oldStats: ObligationStats, oldDeposits: Map<PublicKey, Position>, amount: Decimal, mint: PublicKey, reserves: Map<PublicKey, KaminoReserve>, market: KaminoMarket): {
-        stats: ObligationStats;
-        deposits: Map<PublicKey, Position>;
-    };
+    simulateDepositChange(obligationDeposits: ObligationCollateral[], changeInLamports: number, changeReserve: PublicKey, collateralExchangeRates: Map<PublicKey, Decimal>): ObligationCollateral[];
+    simulateBorrowChange(obligationBorrows: ObligationLiquidity[], changeInLamports: number, changeReserve: PublicKey): ObligationLiquidity[];
     /**
      * Calculate the newly modified stats of the obligation
      */
@@ -156,24 +144,17 @@ export declare class KaminoObligation {
         mintDebt?: PublicKey;
         market: KaminoMarket;
         reserves: Map<PublicKey, KaminoReserve>;
+        slot: number;
+        elevationGroupOverride?: number;
     }): {
         stats: ObligationStats;
         deposits: Map<PublicKey, Position>;
         borrows: Map<PublicKey, Position>;
     };
     estimateObligationInterestRate: (market: KaminoMarket, reserve: KaminoReserve, borrow: ObligationLiquidity, currentSlot: number) => Decimal;
-    private calculateDeposits;
-    private calculateBorrows;
     private calculatePositions;
-    static calculateObligationDeposits(market: KaminoMarket, obligation: Obligation, collateralExchangeRates: Map<PublicKey, Decimal> | null, elevationGroup: number, getPx: (reserve: KaminoReserve) => Decimal): {
-        deposits: Map<PublicKey, Position>;
-        userTotalDeposit: Decimal;
-        userTotalCollateralDeposit: Decimal;
-        borrowLimit: Decimal;
-        liquidationLtv: Decimal;
-        borrowLiquidationLimit: Decimal;
-    };
-    static calculateObligationBorrows(market: KaminoMarket, obligation: Obligation, cumulativeBorrowRates: Map<PublicKey, Decimal> | null, elevationGroup: number, getPx: (reserve: KaminoReserve) => Decimal): BorrowStats;
+    static calculateObligationDeposits(market: KaminoMarket, obligationDeposits: ObligationCollateral[], collateralExchangeRates: Map<PublicKey, Decimal> | null, elevationGroup: number, getPx: (reserve: KaminoReserve) => Decimal): DepositStats;
+    static calculateObligationBorrows(market: KaminoMarket, obligationBorrows: ObligationLiquidity[], cumulativeBorrowRates: Map<PublicKey, Decimal> | null, elevationGroup: number, getPx: (reserve: KaminoReserve) => Decimal): BorrowStats;
     getMaxLoanLtvGivenElevationGroup(market: KaminoMarket, elevationGroup: number, slot: number): Decimal;
     getBorrowPower(market: KaminoMarket, liquidityMint: PublicKey, slot: number, elevationGroup?: number): Decimal;
     getMaxBorrowAmountV2(market: KaminoMarket, liquidityMint: PublicKey, slot: number, elevationGroup?: number): Decimal;

package/dist/classes/obligation.js

@@ -17,6 +17,7 @@ const decimal_js_1 = __importDefault(require("decimal.js"));
 const accounts_1 = require("../idl_codegen/accounts");
 const bn_js_1 = __importDefault(require("bn.js"));
 const fraction_1 = require("./fraction");
+const types_1 = require("../idl_codegen/types");
 const utils_1 = require("./utils");
 const utils_2 = require("../utils");
 class KaminoObligation {
@@ -39,7 +40,7 @@ class KaminoObligation {
         };
         this.obligationAddress = obligationAddress;
         this.state = obligation;
-        const { borrows, deposits, refreshedStats } = this.calculatePositions(market, obligation, collateralExchangeRates, cumulativeBorrowRates);
+        const { borrows, deposits, refreshedStats } = this.calculatePositions(market, obligation.deposits, obligation.borrows, obligation.elevationGroup, collateralExchangeRates, cumulativeBorrowRates);
         this.deposits = deposits;
         this.borrows = borrows;
         this.refreshedStats = refreshedStats;
@@ -195,21 +196,6 @@ class KaminoObligation {
     getNetAccountValue() {
         return this.refreshedStats.netAccountValue;
     }
-    /**
-     * Get the loan to value and liquidation loan to value for a collateral token reserve as ratios, accounting for the obligation elevation group if it is active
-     * @param market
-     * @param reserve
-     */
-    getLtvForReserve(market, reserve) {
-        return KaminoObligation.getLtvForReserve(market, reserve, this.state.elevationGroup);
-    }
-    /**
-     * Get the borrow factor for a borrow reserve, accounting for the obligation elevation group if it is active
-     * @param reserve
-     */
-    getBorrowFactorForReserve(reserve) {
-        return KaminoObligation.getBorrowFactorForReserve(reserve, this.state.elevationGroup);
-    }
     /**
      * @returns the potential elevation groups the obligation qualifies for
      */
@@ -250,141 +236,85 @@ class KaminoObligation {
         }
         return activeElevationGroups;
     }
-    calculateSimulatedBorrow(oldStats, oldBorrows, borrowAmount, mint, reserves) {
-        const newStats = Object.assign({}, oldStats);
-        const newBorrows = new utils_2.PubkeyHashMap([...oldBorrows.entries()]);
-        let borrowPosition = undefined;
-        for (const oldBorrow of oldBorrows.values()) {
-            if (oldBorrow.mintAddress.equals(mint)) {
-                borrowPosition = Object.assign({}, oldBorrow);
+    simulateDepositChange(obligationDeposits, changeInLamports, changeReserve, collateralExchangeRates) {
+        const newDeposits = [];
+        for (let i = 0; i < obligationDeposits.length; i++) {
+            if (obligationDeposits[i].depositReserve.equals(changeReserve)) {
+                const coll = Object.assign({}, obligationDeposits[i]);
+                const exchangeRate = collateralExchangeRates.get(changeReserve);
+                const changeInCollateral = new decimal_js_1.default(changeInLamports).mul(exchangeRate);
+                const updatedDeposit = new decimal_js_1.default(obligationDeposits[i].depositedAmount.toNumber()).add(changeInCollateral);
+                coll.depositedAmount = new bn_js_1.default((0, utils_1.positiveOrZero)(updatedDeposit).toString());
+                newDeposits.push(new types_1.ObligationCollateral(coll));
             }
-        }
-        let reserve = undefined;
-        for (const kaminoReserve of reserves.values()) {
-            if (kaminoReserve.getLiquidityMint().equals(mint)) {
-                reserve = kaminoReserve;
+            else {
+                newDeposits.push(obligationDeposits[i]);
             }
         }
-        if (!reserve) {
-            throw new Error(`No reserve found for mint ${mint}`);
-        }
-        if (!borrowPosition) {
-            borrowPosition = {
-                reserveAddress: reserve.address,
-                mintAddress: mint,
-                amount: new decimal_js_1.default(0),
-                marketValueRefreshed: new decimal_js_1.default(0),
-            };
-        }
-        if (!reserve.state.config.elevationGroups.includes(this.state.elevationGroup)) {
-            throw new Error(`User would have to downgrade the elevation group in order to be able to borrow from this reserve`);
-        }
-        const borrowFactor = this.getBorrowFactorForReserve(reserve);
-        const borrowValueUSD = borrowAmount.mul(reserve.getOracleMarketPrice()).dividedBy(reserve.getMintFactor());
-        const borrowValueBorrowFactorAdjustedUSD = borrowValueUSD.mul(borrowFactor);
-        newStats.userTotalBorrow = (0, utils_1.positiveOrZero)(newStats.userTotalBorrow.plus(borrowValueUSD));
-        newStats.userTotalBorrowBorrowFactorAdjusted = (0, utils_1.positiveOrZero)(newStats.userTotalBorrowBorrowFactorAdjusted.plus(borrowValueBorrowFactorAdjustedUSD));
-        borrowPosition.amount = (0, utils_1.positiveOrZero)(borrowPosition.amount.plus(borrowAmount));
-        borrowPosition.mintAddress = mint;
-        borrowPosition.marketValueRefreshed = (0, utils_1.positiveOrZero)(borrowPosition.marketValueRefreshed.plus(borrowValueUSD));
-        newBorrows.set(borrowPosition.reserveAddress, borrowPosition);
-        return {
-            borrows: newBorrows,
-            stats: newStats,
-        };
+        return newDeposits;
     }
-    calculateSimulatedDeposit(oldStats, oldDeposits, amount, mint, reserves, market) {
-        const newStats = Object.assign({}, oldStats);
-        const newDeposits = new utils_2.PubkeyHashMap([...oldDeposits.entries()]);
-        let depositPosition = undefined;
-        for (const oldDeposit of oldDeposits.values()) {
-            if (oldDeposit.mintAddress.equals(mint)) {
-                depositPosition = Object.assign({}, oldDeposit);
+    simulateBorrowChange(obligationBorrows, changeInLamports, changeReserve) {
+        const newBorrows = [];
+        for (let i = 0; i < obligationBorrows.length; i++) {
+            if (obligationBorrows[i].borrowReserve.equals(changeReserve)) {
+                const borrow = Object.assign({}, obligationBorrows[i]);
+                const newBorrowedAmount = new fraction_1.Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
+                const newBorrowedAmountSf = fraction_1.Fraction.fromDecimal((0, utils_1.positiveOrZero)(newBorrowedAmount)).getValue();
+                borrow.borrowedAmountSf = newBorrowedAmountSf;
+                newBorrows.push(new types_1.ObligationLiquidity(borrow));
             }
-        }
-        let reserve = undefined;
-        for (const kaminoReserve of reserves.values()) {
-            if (kaminoReserve.getLiquidityMint().equals(mint)) {
-                reserve = kaminoReserve;
+            else {
+                newBorrows.push(obligationBorrows[i]);
             }
         }
-        if (!reserve) {
-            throw new Error(`No reserve found for mint ${mint}`);
-        }
-        if (!depositPosition) {
-            depositPosition = {
-                reserveAddress: reserve.address,
-                mintAddress: mint,
-                amount: new decimal_js_1.default(0),
-                marketValueRefreshed: new decimal_js_1.default(0),
-            };
-        }
-        if (!reserve.state.config.elevationGroups.includes(this.state.elevationGroup)) {
-            throw new Error(`User would have to downgrade the elevation group in order to be able to deposit in this reserve`);
-        }
-        const { maxLtv, liquidationLtv } = this.getLtvForReserve(market, reserve);
-        const supplyAmount = amount; //.mul(reserve.getCollateralExchangeRate()).floor();
-        const supplyAmountMultiplierUSD = supplyAmount
-            .mul(reserve.getOracleMarketPrice())
-            .dividedBy('1'.concat(Array(reserve.stats.decimals + 1).join('0')));
-        newStats.userTotalDeposit = (0, utils_1.positiveOrZero)(newStats.userTotalDeposit.plus(supplyAmountMultiplierUSD));
-        newStats.borrowLimit = (0, utils_1.positiveOrZero)(newStats.borrowLimit.plus(supplyAmountMultiplierUSD.mul(maxLtv)));
-        newStats.borrowLiquidationLimit = (0, utils_1.positiveOrZero)(newStats.borrowLiquidationLimit.plus(supplyAmountMultiplierUSD.mul(liquidationLtv)));
-        newStats.liquidationLtv = (0, utils_1.valueOrZero)(newStats.borrowLiquidationLimit.div(newStats.userTotalDeposit));
-        depositPosition.amount = (0, utils_1.positiveOrZero)(depositPosition.amount.plus(amount));
-        depositPosition.mintAddress = mint;
-        depositPosition.marketValueRefreshed = (0, utils_1.positiveOrZero)(depositPosition.marketValueRefreshed.plus(supplyAmount.mul(reserve.getOracleMarketPrice()).dividedBy(reserve.getMintFactor())));
-        newDeposits.set(depositPosition.reserveAddress, depositPosition);
-        return {
-            deposits: newDeposits,
-            stats: newStats,
-        };
+        return newBorrows;
     }
     /**
      * Calculate the newly modified stats of the obligation
      */
-    // TODO: Elevation group problems
     // TODO: Shall we set up position limits?
     getSimulatedObligationStats(params) {
-        const { amountCollateral, amountDebt, action, mintCollateral, mintDebt, market, reserves } = params;
+        var _a;
+        const { amountCollateral, amountDebt, action, mintCollateral, mintDebt, market } = params;
         let newStats = Object.assign({}, this.refreshedStats);
+        const { collateralExchangeRates, cumulativeBorrowRates } = KaminoObligation.getRatesForObligation(market, this.state, params.slot);
+        const elevationGroup = (_a = params.elevationGroupOverride) !== null && _a !== void 0 ? _a : this.state.elevationGroup;
         let newDeposits = new utils_2.PubkeyHashMap([...this.deposits.entries()]);
         let newBorrows = new utils_2.PubkeyHashMap([...this.borrows.entries()]);
+        // Any action can impact both deposit stats and borrow stats if elevation group is changed
+        // so we have to recalculate the entire position, not just an updated deposit or borrow
+        // as both LTVs and borrow factors can change, affecting all calcs
+        const collateralReserve = mintCollateral ? market.getReserveByMint(mintCollateral).address : undefined;
+        const debtReserve = mintDebt ? market.getReserveByMint(mintDebt).address : undefined;
+        let newObligationDeposits = this.state.deposits;
+        let newObligationBorrows = this.state.borrows;
         switch (action) {
             case 'deposit': {
                 if (amountCollateral === undefined || mintCollateral === undefined) {
                     throw Error('amountCollateral & mintCollateral are required for deposit action');
                 }
-                const { stats, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, amountCollateral, mintCollateral, reserves, market);
-                newStats = stats;
-                newDeposits = deposits;
+                newObligationDeposits = this.simulateDepositChange(this.state.deposits, amountCollateral.toNumber(), collateralReserve, collateralExchangeRates);
                 break;
             }
             case 'borrow': {
                 if (amountDebt === undefined || mintDebt === undefined) {
                     throw Error('amountDebt & mintDebt are required for borrow action');
                 }
-                const { stats, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, amountDebt, mintDebt, reserves);
-                newStats = stats;
-                newBorrows = borrows;
+                newObligationBorrows = this.simulateBorrowChange(this.state.borrows, amountDebt.toNumber(), debtReserve);
                 break;
             }
             case 'repay': {
                 if (amountDebt === undefined || mintDebt === undefined) {
                     throw Error('amountDebt & mintDebt are required for repay action');
                 }
-                const { stats, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, new decimal_js_1.default(amountDebt).neg(), mintDebt, reserves);
-                newStats = stats;
-                newBorrows = borrows;
+                newObligationBorrows = this.simulateBorrowChange(this.state.borrows, amountDebt.neg().toNumber(), debtReserve);
                 break;
             }
             case 'withdraw': {
                 if (amountCollateral === undefined || mintCollateral === undefined) {
                     throw Error('amountCollateral & mintCollateral are required for withdraw action');
                 }
-                const { stats, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, new decimal_js_1.default(amountCollateral).neg(), mintCollateral, reserves, market);
-                newStats = stats;
-                newDeposits = deposits;
+                newObligationDeposits = this.simulateDepositChange(this.state.deposits, amountCollateral.neg().toNumber(), collateralReserve, collateralExchangeRates);
                 break;
             }
             case 'depositAndBorrow': {
@@ -394,11 +324,8 @@ class KaminoObligation {
                     mintDebt === undefined) {
                     throw Error('amountColl & amountDebt & mintCollateral & mintDebt are required for depositAndBorrow action');
                 }
-                const { stats: statsAfterDeposit, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, amountCollateral, mintCollateral, reserves, market);
-                const { stats, borrows } = this.calculateSimulatedBorrow(statsAfterDeposit, this.borrows, amountDebt, mintDebt, reserves);
-                newStats = stats;
-                newDeposits = deposits;
-                newBorrows = borrows;
+                newObligationDeposits = this.simulateDepositChange(this.state.deposits, amountCollateral.toNumber(), collateralReserve, collateralExchangeRates);
+                newObligationBorrows = this.simulateBorrowChange(this.state.borrows, amountDebt.toNumber(), debtReserve);
                 break;
             }
             case 'repayAndWithdraw': {
@@ -408,17 +335,18 @@ class KaminoObligation {
                     mintDebt === undefined) {
                     throw Error('amountColl & amountDebt & mintCollateral & mintDebt are required for repayAndWithdraw action');
                 }
-                const { stats: statsAfterRepay, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, new decimal_js_1.default(amountDebt).neg(), mintDebt, reserves);
-                const { stats: statsAfterWithdraw, deposits } = this.calculateSimulatedDeposit(statsAfterRepay, this.deposits, new decimal_js_1.default(amountCollateral).neg(), mintCollateral, reserves, market);
-                newStats = statsAfterWithdraw;
-                newDeposits = deposits;
-                newBorrows = borrows;
+                newObligationDeposits = this.simulateDepositChange(this.state.deposits, amountCollateral.neg().toNumber(), collateralReserve, collateralExchangeRates);
+                newObligationBorrows = this.simulateBorrowChange(this.state.borrows, amountDebt.neg().toNumber(), debtReserve);
                 break;
             }
             default: {
                 throw Error(`Invalid action type ${action} for getSimulatedObligationStats`);
             }
         }
+        const { borrows, deposits, refreshedStats } = this.calculatePositions(market, newObligationDeposits, newObligationBorrows, elevationGroup, collateralExchangeRates, cumulativeBorrowRates);
+        newStats = refreshedStats;
+        newDeposits = deposits;
+        newBorrows = borrows;
         newStats.netAccountValue = newStats.userTotalDeposit.minus(newStats.userTotalBorrow);
         newStats.loanToValue = (0, utils_1.valueOrZero)(newStats.userTotalBorrowBorrowFactorAdjusted.dividedBy(newStats.userTotalDeposit));
         newStats.leverage = (0, utils_1.valueOrZero)(newStats.userTotalDeposit.dividedBy(newStats.netAccountValue));
@@ -428,17 +356,12 @@ class KaminoObligation {
             borrows: newBorrows,
         };
     }
-    calculateDeposits(market, obligation, collateralExchangeRates, getPx) {
-        return KaminoObligation.calculateObligationDeposits(market, obligation, collateralExchangeRates, obligation.elevationGroup, getPx);
-    }
-    calculateBorrows(market, obligation, cumulativeBorrowRates, getPx) {
-        return KaminoObligation.calculateObligationBorrows(market, obligation, cumulativeBorrowRates, obligation.elevationGroup, getPx);
-    }
-    calculatePositions(market, obligation, collateralExchangeRates, cumulativeBorrowRates) {
+    calculatePositions(market, obligationDeposits, obligationBorrows, elevationGroup, collateralExchangeRates, cumulativeBorrowRates) {
         const getOraclePx = (reserve) => reserve.getOracleMarketPrice();
-        const depositStatsOraclePrice = this.calculateDeposits(market, obligation, collateralExchangeRates, getOraclePx);
-        const borrowStatsOraclePrice = this.calculateBorrows(market, obligation, cumulativeBorrowRates, getOraclePx);
+        const depositStatsOraclePrice = KaminoObligation.calculateObligationDeposits(market, obligationDeposits, collateralExchangeRates, elevationGroup, getOraclePx);
+        const borrowStatsOraclePrice = KaminoObligation.calculateObligationBorrows(market, obligationBorrows, cumulativeBorrowRates, elevationGroup, getOraclePx);
         const netAccountValueScopeRefreshed = depositStatsOraclePrice.userTotalDeposit.minus(borrowStatsOraclePrice.userTotalBorrow);
+        // TODO: Fix this?
         const potentialElevationGroupUpdate = 0;
         return {
             deposits: depositStatsOraclePrice.deposits,
@@ -458,17 +381,17 @@ class KaminoObligation {
             },
         };
     }
-    static calculateObligationDeposits(market, obligation, collateralExchangeRates, elevationGroup, getPx) {
+    static calculateObligationDeposits(market, obligationDeposits, collateralExchangeRates, elevationGroup, getPx) {
         let userTotalDeposit = new decimal_js_1.default(0);
         let userTotalCollateralDeposit = new decimal_js_1.default(0);
         let borrowLimit = new decimal_js_1.default(0);
         let borrowLiquidationLimit = new decimal_js_1.default(0);
         const deposits = new utils_2.PubkeyHashMap();
-        for (let i = 0; i < obligation.deposits.length; i++) {
-            if (!(0, utils_2.isNotNullPubkey)(obligation.deposits[i].depositReserve)) {
+        for (let i = 0; i < obligationDeposits.length; i++) {
+            if (!(0, utils_2.isNotNullPubkey)(obligationDeposits[i].depositReserve)) {
                 continue;
             }
-            const deposit = obligation.deposits[i];
+            const deposit = obligationDeposits[i];
             const reserve = market.getReserveByAddress(deposit.depositReserve);
             if (!reserve) {
                 throw new Error(`Obligation contains a deposit belonging to reserve: ${deposit.depositReserve} but the reserve was not found on the market. Deposit amount: ${deposit.depositedAmount}`);
@@ -506,16 +429,16 @@ class KaminoObligation {
             borrowLiquidationLimit,
         };
     }
-    static calculateObligationBorrows(market, obligation, cumulativeBorrowRates, elevationGroup, getPx) {
+    static calculateObligationBorrows(market, obligationBorrows, cumulativeBorrowRates, elevationGroup, getPx) {
         let userTotalBorrow = new decimal_js_1.default(0);
         let userTotalBorrowBorrowFactorAdjusted = new decimal_js_1.default(0);
         let positions = 0;
         const borrows = new utils_2.PubkeyHashMap();
-        for (let i = 0; i < obligation.borrows.length; i++) {
-            if (!(0, utils_2.isNotNullPubkey)(obligation.borrows[i].borrowReserve)) {
+        for (let i = 0; i < obligationBorrows.length; i++) {
+            if (!(0, utils_2.isNotNullPubkey)(obligationBorrows[i].borrowReserve)) {
                 continue;
             }
-            const borrow = obligation.borrows[i];
+            const borrow = obligationBorrows[i];
             const reserve = market.getReserveByAddress(borrow.borrowReserve);
             if (!reserve) {
                 throw new Error(`Obligation contains a borrow belonging to reserve: ${borrow.borrowReserve} but the reserve was not found on the market. Borrow amount: ${KaminoObligation.getBorrowAmount(borrow)}`);
@@ -557,7 +480,7 @@ class KaminoObligation {
     getMaxLoanLtvGivenElevationGroup(market, elevationGroup, slot) {
         const getOraclePx = (reserve) => reserve.getOracleMarketPrice();
         const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(market, this.state, slot);
-        const { borrowLimit, userTotalDeposit } = KaminoObligation.calculateObligationDeposits(market, this.state, collateralExchangeRates, elevationGroup, getOraclePx);
+        const { borrowLimit, userTotalDeposit } = KaminoObligation.calculateObligationDeposits(market, this.state.deposits, collateralExchangeRates, elevationGroup, getOraclePx);
         if (borrowLimit.eq(0) || userTotalDeposit.eq(0)) {
             return new decimal_js_1.default(0);
         }
@@ -587,8 +510,8 @@ class KaminoObligation {
         const borrowFactor = KaminoObligation.getBorrowFactorForReserve(reserve, elevationGroup);
         const getOraclePx = (reserve) => reserve.getOracleMarketPrice();
         const { collateralExchangeRates, cumulativeBorrowRates } = KaminoObligation.getRatesForObligation(market, this.state, slot);
-        const { borrowLimit } = KaminoObligation.calculateObligationDeposits(market, this.state, collateralExchangeRates, elevationGroup, getOraclePx);
-        const { userTotalBorrowBorrowFactorAdjusted } = KaminoObligation.calculateObligationBorrows(market, this.state, cumulativeBorrowRates, elevationGroup, getOraclePx);
+        const { borrowLimit } = KaminoObligation.calculateObligationDeposits(market, this.state.deposits, collateralExchangeRates, elevationGroup, getOraclePx);
+        const { userTotalBorrowBorrowFactorAdjusted } = KaminoObligation.calculateObligationBorrows(market, this.state.borrows, cumulativeBorrowRates, elevationGroup, getOraclePx);
         const maxObligationBorrowPower = borrowLimit // adjusted available amount
             .minus(userTotalBorrowBorrowFactorAdjusted)
             .div(borrowFactor)
@@ -671,7 +594,7 @@ class KaminoObligation {
         // Check if the loan can be migrated based on LTV
         const getOraclePx = (reserve) => reserve.getOracleMarketPrice();
         const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(market, this.state, slot);
-        const { borrowLimit } = KaminoObligation.calculateObligationDeposits(market, this.state, collateralExchangeRates, elevationGroup, getOraclePx);
+        const { borrowLimit } = KaminoObligation.calculateObligationDeposits(market, this.state.deposits, collateralExchangeRates, elevationGroup, getOraclePx);
         const isEligibleBasedOnLtv = this.refreshedStats.userTotalBorrowBorrowFactorAdjusted.lte(borrowLimit);
         return isEligibleBasedOnLtv;
     }
@@ -722,7 +645,7 @@ class KaminoObligation {
             }
         }
         const elevationGroupActivated = reserve.state.config.elevationGroups.includes(elevationGroup) && elevationGroup !== 0;
-        const borrowFactor = this.getBorrowFactorForReserve(reserve);
+        const borrowFactor = KaminoObligation.getBorrowFactorForReserve(reserve, elevationGroup);
         const maxObligationBorrowPower = this.refreshedStats.borrowLimit // adjusted available amount
             .minus(this.refreshedStats.userTotalBorrowBorrowFactorAdjusted)
             .div(borrowFactor)
@@ -794,7 +717,7 @@ class KaminoObligation {
         if (this.refreshedStats.userTotalBorrowBorrowFactorAdjusted.equals(new decimal_js_1.default(0))) {
             return new decimal_js_1.default(userDepositPositionAmount);
         }
-        const { maxLtv: reserveMaxLtv } = this.getLtvForReserve(market, depositReserve);
+        const { maxLtv: reserveMaxLtv } = KaminoObligation.getLtvForReserve(market, depositReserve, this.state.elevationGroup);
         // bf adjusted debt value > allowed_borrow_value
         if (this.refreshedStats.userTotalBorrowBorrowFactorAdjusted.gte(this.refreshedStats.borrowLimit)) {
             return new decimal_js_1.default(0);