@kamino-finance/klend-sdk 2.10.6

package/dist/classes/obligation.js

@@ -0,0 +1,610 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoObligation = void 0;
+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 utils_1 = require("./utils");
+const utils_2 = require("../utils");
+class KaminoObligation {
+    /**
+     * Initialise a new Obligation from the deserialized state
+     * @param market
+     * @param obligationAddress
+     * @param obligation
+     * @param collateralExchangeRates - rates from the market by reserve address, will be calculated if not provided
+     * @param cumulativeBorrowRates - rates from the market by reserve address, will be calculated if not provided
+     */
+    constructor(market, obligationAddress, obligation, collateralExchangeRates, cumulativeBorrowRates) {
+        this.estimateObligationInterestRate = (reserve, borrow, currentSlot) => {
+            const estimatedCumulativeBorrowRate = reserve.getEstimatedCumulativeBorrowRate(currentSlot);
+            const currentCumulativeBorrowRate = KaminoObligation.getCumulativeBorrowRate(borrow);
+            if (estimatedCumulativeBorrowRate.gt(currentCumulativeBorrowRate)) {
+                return estimatedCumulativeBorrowRate.div(currentCumulativeBorrowRate);
+            }
+            return new decimal_js_1.default(0);
+        };
+        this.obligationAddress = obligationAddress;
+        this.state = obligation;
+        const { borrows, deposits, refreshedStats } = this.calculatePositions(market, obligation, collateralExchangeRates, cumulativeBorrowRates);
+        this.deposits = deposits;
+        this.borrows = borrows;
+        this.refreshedStats = refreshedStats;
+        this.obligationTag = obligation.tag.toNumber();
+    }
+    static load(kaminoMarket, obligationAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield kaminoMarket.getConnection().getAccountInfoAndContext(obligationAddress);
+            if (res.value === null) {
+                return null;
+            }
+            const accInfo = res.value;
+            if (!accInfo.owner.equals(kaminoMarket.programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            const obligation = accounts_1.Obligation.decode(accInfo.data);
+            if (obligation === null) {
+                return null;
+            }
+            const { collateralExchangeRates, cumulativeBorrowRates } = KaminoObligation.getRatesForObligation(kaminoMarket, obligation, res.context.slot);
+            return new KaminoObligation(kaminoMarket, obligationAddress, obligation, collateralExchangeRates, cumulativeBorrowRates);
+        });
+    }
+    static loadAll(kaminoMarket, obligationAddresses, slot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let currentSlot = slot;
+            let obligations;
+            if (!currentSlot) {
+                [currentSlot, obligations] = yield Promise.all([
+                    kaminoMarket.getConnection().getSlot(),
+                    accounts_1.Obligation.fetchMultiple(kaminoMarket.getConnection(), obligationAddresses, kaminoMarket.programId),
+                ]);
+            }
+            else {
+                obligations = yield accounts_1.Obligation.fetchMultiple(kaminoMarket.getConnection(), obligationAddresses, kaminoMarket.programId);
+            }
+            const cumulativeBorrowRates = new utils_2.PubkeyHashMap();
+            const collateralExchangeRates = new utils_2.PubkeyHashMap();
+            for (const obligation of obligations) {
+                if (obligation !== null) {
+                    KaminoObligation.addRatesForObligation(kaminoMarket, obligation, collateralExchangeRates, cumulativeBorrowRates, currentSlot);
+                }
+            }
+            return obligations.map((obligation, i) => {
+                if (obligation === null) {
+                    return null;
+                }
+                return new KaminoObligation(kaminoMarket, obligationAddresses[i], obligation, collateralExchangeRates, cumulativeBorrowRates);
+            });
+        });
+    }
+    /**
+     * @returns the obligation borrows as a list
+     */
+    getBorrows() {
+        return [...this.borrows.values()];
+    }
+    /**
+     * @returns the obligation borrows as a list
+     */
+    getDeposits() {
+        return [...this.deposits.values()];
+    }
+    /**
+     * @returns the total deposited value of the obligation (sum of all deposits)
+     */
+    getDepositedValue() {
+        return new fraction_1.Fraction(this.state.depositedValueSf).toDecimal();
+    }
+    /**
+     * @returns the total borrowed value of the obligation (sum of all borrows -- no borrow factor)
+     */
+    getBorrowedMarketValue() {
+        return new fraction_1.Fraction(this.state.borrowedAssetsMarketValueSf).toDecimal();
+    }
+    /**
+     * @returns the total borrowed value of the obligation (sum of all borrows -- with borrow factor weighting)
+     */
+    getBorrowedMarketValueBFAdjusted() {
+        return new fraction_1.Fraction(this.state.borrowFactorAdjustedDebtValueSf).toDecimal();
+    }
+    /**
+     * @returns total borrow power of the obligation, relative to max LTV of each asset's reserve
+     */
+    getAllowedBorrowValue() {
+        return new fraction_1.Fraction(this.state.allowedBorrowValueSf).toDecimal();
+    }
+    /**
+     * @returns the borrow value at which the obligation gets liquidatable
+     * (relative to the liquidation threshold of each asset's reserve)
+     */
+    getUnhealthyBorrowValue() {
+        return new fraction_1.Fraction(this.state.unhealthyBorrowValueSf).toDecimal();
+    }
+    /**
+     *
+     * @returns Market value of the deposit in the specified obligation collateral/deposit asset (USD)
+     */
+    getDepositMarketValue(deposit) {
+        return new fraction_1.Fraction(deposit.marketValueSf).toDecimal();
+    }
+    getBorrowByReserve(reserve) {
+        return this.borrows.get(reserve);
+    }
+    getDepositByReserve(reserve) {
+        return this.deposits.get(reserve);
+    }
+    getBorrowByMint(mint) {
+        for (const value of this.borrows.values()) {
+            if (value.mintAddress.equals(mint)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    getDepositByMint(mint) {
+        for (const value of this.deposits.values()) {
+            if (value.mintAddress.equals(mint)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    /**
+     *
+     * @returns Market value of the borrow in the specified obligation liquidity/borrow asset (USD) (no borrow factor weighting)
+     */
+    getBorrowMarketValue(borrow) {
+        return new fraction_1.Fraction(borrow.marketValueSf).toDecimal();
+    }
+    /**
+     *
+     * @returns Market value of the borrow in the specified obligation liquidity/borrow asset (USD) (with borrow factor weighting)
+     */
+    getBorrowMarketValueBFAdjusted(borrow) {
+        return new fraction_1.Fraction(borrow.borrowFactorAdjustedMarketValueSf).toDecimal();
+    }
+    /**
+     * Calculate the current ratio of borrowed value to deposited value
+     */
+    loanToValue() {
+        if (this.refreshedStats.userTotalDeposit.eq(0)) {
+            return new decimal_js_1.default(0);
+        }
+        return this.refreshedStats.userTotalBorrowBorrowFactorAdjusted.div(this.refreshedStats.userTotalDeposit);
+    }
+    /**
+     * @returns the total number of positions (deposits + borrows)
+     */
+    getNumberOfPositions() {
+        return this.deposits.size + this.borrows.size;
+    }
+    getNetAccountValue() {
+        return this.refreshedStats.netAccountValue;
+    }
+    /**
+     * @returns the potential elevation groups the obligation qualifies for
+     */
+    getElevationGroups(kaminoMarket) {
+        const reserves = new utils_2.PubkeyHashMap();
+        for (const deposit of this.state.deposits.values()) {
+            if ((0, utils_2.isNotNullPubkey)(deposit.depositReserve) && !reserves.has(deposit.depositReserve)) {
+                reserves.set(deposit.depositReserve, kaminoMarket.getReserveByAddress(deposit.depositReserve));
+            }
+        }
+        for (const borrow of this.state.borrows.values()) {
+            if ((0, utils_2.isNotNullPubkey)(borrow.borrowReserve) && !reserves.has(borrow.borrowReserve)) {
+                reserves.set(borrow.borrowReserve, kaminoMarket.getReserveByAddress(borrow.borrowReserve));
+            }
+        }
+        return KaminoObligation.getElevationGroupsForReserves([...reserves.values()]);
+    }
+    static getElevationGroupsForReserves(reserves) {
+        const elevationGroupsCounts = new Map();
+        for (const reserve of reserves) {
+            for (const elevationGroup of reserve.state.config.elevationGroups) {
+                if (elevationGroup !== 0) {
+                    const count = elevationGroupsCounts.get(elevationGroup);
+                    if (count) {
+                        elevationGroupsCounts.set(elevationGroup, count + 1);
+                    }
+                    else {
+                        elevationGroupsCounts.set(elevationGroup, 1);
+                    }
+                }
+            }
+        }
+        const activeElevationGroups = new Array();
+        for (const [group, count] of elevationGroupsCounts.entries()) {
+            if (count === reserves.length) {
+                activeElevationGroups.push(group);
+            }
+        }
+        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 = oldBorrow;
+            }
+        }
+        let reserve = undefined;
+        for (const kaminoReserve of reserves.values()) {
+            if (kaminoReserve.getLiquidityMint().equals(mint)) {
+                reserve = kaminoReserve;
+            }
+        }
+        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.state.elevationGroup !== 0 ? new decimal_js_1.default(1) : new decimal_js_1.default(reserve.stats.borrowFactor).div(100);
+        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,
+        };
+    }
+    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 = oldDeposit;
+            }
+        }
+        let reserve = undefined;
+        for (const kaminoReserve of reserves.values()) {
+            if (kaminoReserve.getLiquidityMint().equals(mint)) {
+                reserve = kaminoReserve;
+            }
+        }
+        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),
+            };
+        }
+        let loanToValue = reserve.stats.loanToValuePct;
+        let liqThreshold = reserve.stats.liquidationThreshold;
+        if (this.state.elevationGroup !== 0) {
+            loanToValue = market.getElevationGroup(this.state.elevationGroup).ltvPct / 100;
+            liqThreshold = market.getElevationGroup(this.state.elevationGroup).liquidationThresholdPct / 100;
+        }
+        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 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(loanToValue)));
+        newStats.borrowLiquidationLimit = (0, utils_1.positiveOrZero)(newStats.borrowLiquidationLimit.plus(supplyAmountMultiplierUSD.mul(liqThreshold)));
+        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,
+        };
+    }
+    /**
+     * Calculate the newly modified stats of the obligation
+     */
+    // TODO: Elevation group problems
+    // TODO: Shall we set up position limits?
+    getSimulatedObligationStats(amount, action, mint, market, reserves) {
+        let newStats = Object.assign({}, this.refreshedStats);
+        let newDeposits = new utils_2.PubkeyHashMap([...this.deposits.entries()]);
+        let newBorrows = new utils_2.PubkeyHashMap([...this.borrows.entries()]);
+        switch (action) {
+            case 'deposit': {
+                const { stats, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, amount, mint, reserves, market);
+                newStats = stats;
+                newDeposits = deposits;
+                break;
+            }
+            case 'borrow': {
+                const { stats, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, amount, mint, reserves);
+                newStats = stats;
+                newBorrows = borrows;
+                break;
+            }
+            case 'repay': {
+                const { stats, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, new decimal_js_1.default(amount).neg(), mint, reserves);
+                newStats = stats;
+                newBorrows = borrows;
+                break;
+            }
+            case 'withdraw': {
+                const { stats, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, new decimal_js_1.default(amount).neg(), mint, reserves, market);
+                newStats = stats;
+                newDeposits = deposits;
+                break;
+            }
+            case 'depositAndBorrow': {
+                const { stats: statsAfterDeposit, deposits } = this.calculateSimulatedDeposit(this.refreshedStats, this.deposits, amount, mint, reserves, market);
+                const { stats, borrows } = this.calculateSimulatedBorrow(statsAfterDeposit, this.borrows, amount, mint, reserves);
+                newStats = stats;
+                newDeposits = deposits;
+                newBorrows = borrows;
+                break;
+            }
+            case 'repayAndWithdraw': {
+                const { stats: statsAfterRepay, borrows } = this.calculateSimulatedBorrow(this.refreshedStats, this.borrows, new decimal_js_1.default(amount).neg(), mint, reserves);
+                const { stats: statsAfterWithdraw, deposits } = this.calculateSimulatedDeposit(statsAfterRepay, this.deposits, amount, mint, reserves, market);
+                newStats = statsAfterWithdraw;
+                newDeposits = deposits;
+                newBorrows = borrows;
+                break;
+            }
+            default: {
+                throw Error(`Invalid action type ${action} for getSimulatedObligationStats`);
+            }
+        }
+        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));
+        return {
+            stats: newStats,
+            deposits: newDeposits,
+            borrows: newBorrows,
+        };
+    }
+    calculateDeposits(market, obligation, collateralExchangeRates, getPx) {
+        return KaminoObligation.calculateObligationDeposits(market, obligation, collateralExchangeRates, getPx);
+    }
+    calculateBorrows(market, obligation, cumulativeBorrowRates, getPx) {
+        return KaminoObligation.calculateObligationBorrows(market, obligation, cumulativeBorrowRates, getPx);
+    }
+    calculatePositions(market, obligation, collateralExchangeRates, cumulativeBorrowRates) {
+        const commonElevationGroups = this.getElevationGroups(market);
+        const getOraclePx = (reserve) => reserve.getOracleMarketPrice();
+        const depositStatsOraclePrice = this.calculateDeposits(market, obligation, collateralExchangeRates, getOraclePx);
+        const borrowStatsOraclePrice = this.calculateBorrows(market, obligation, cumulativeBorrowRates, getOraclePx);
+        const netAccountValueScopeRefreshed = depositStatsOraclePrice.userTotalDeposit.minus(borrowStatsOraclePrice.userTotalBorrow);
+        return {
+            deposits: depositStatsOraclePrice.deposits,
+            borrows: borrowStatsOraclePrice.borrows,
+            refreshedStats: {
+                borrowLimit: depositStatsOraclePrice.borrowLimit,
+                borrowLiquidationLimit: depositStatsOraclePrice.borrowLiquidationLimit,
+                userTotalBorrow: borrowStatsOraclePrice.userTotalBorrow,
+                userTotalBorrowBorrowFactorAdjusted: borrowStatsOraclePrice.userTotalBorrowBorrowFactorAdjusted,
+                userTotalDeposit: depositStatsOraclePrice.userTotalDeposit,
+                liquidationLtv: depositStatsOraclePrice.liquidationLtv,
+                borrowUtilization: borrowStatsOraclePrice.userTotalBorrowBorrowFactorAdjusted.dividedBy(depositStatsOraclePrice.borrowLimit),
+                netAccountValue: netAccountValueScopeRefreshed,
+                leverage: depositStatsOraclePrice.userTotalDeposit.dividedBy(netAccountValueScopeRefreshed),
+                loanToValue: borrowStatsOraclePrice.userTotalBorrowBorrowFactorAdjusted.dividedBy(depositStatsOraclePrice.userTotalDeposit),
+                potentialElevationGroupUpdate: commonElevationGroups,
+            },
+        };
+    }
+    static calculateObligationDeposits(market, obligation, collateralExchangeRates, 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)) {
+                continue;
+            }
+            const deposit = obligation.deposits[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}`);
+            }
+            let loanToValue = reserve.stats.loanToValuePct;
+            let liqThreshold = reserve.stats.liquidationThreshold;
+            if (obligation.elevationGroup !== 0) {
+                loanToValue = market.state.elevationGroups[obligation.elevationGroup - 1].ltvPct / 100;
+                liqThreshold = market.state.elevationGroups[obligation.elevationGroup - 1].liquidationThresholdPct / 100;
+            }
+            let exchangeRate;
+            if (collateralExchangeRates !== null) {
+                exchangeRate = collateralExchangeRates.get(reserve.address);
+            }
+            else {
+                exchangeRate = reserve.getCollateralExchangeRate();
+            }
+            const supplyAmount = new decimal_js_1.default(deposit.depositedAmount.toString()).div(exchangeRate);
+            const depositValueUsd = supplyAmount.mul(getPx(reserve)).div(reserve.getMintFactor());
+            userTotalDeposit = userTotalDeposit.add(depositValueUsd);
+            if (loanToValue !== 0) {
+                userTotalCollateralDeposit = userTotalCollateralDeposit.add(depositValueUsd);
+            }
+            borrowLimit = borrowLimit.add(depositValueUsd.mul(loanToValue));
+            borrowLiquidationLimit = borrowLiquidationLimit.add(depositValueUsd.mul(liqThreshold));
+            const position = {
+                reserveAddress: reserve.address,
+                mintAddress: reserve.getLiquidityMint(),
+                amount: supplyAmount,
+                marketValueRefreshed: depositValueUsd,
+            };
+            deposits.set(reserve.address, position);
+        }
+        return {
+            deposits,
+            userTotalDeposit,
+            userTotalCollateralDeposit,
+            borrowLimit,
+            liquidationLtv: (0, utils_1.valueOrZero)(borrowLiquidationLimit.div(userTotalDeposit)),
+            borrowLiquidationLimit,
+        };
+    }
+    static calculateObligationBorrows(market, obligation, cumulativeBorrowRates, 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)) {
+                continue;
+            }
+            const borrow = obligation.borrows[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)}`);
+            }
+            const obligationCumulativeBorrowRate = KaminoObligation.getCumulativeBorrowRate(borrow);
+            let cumulativeBorrowRate;
+            if (cumulativeBorrowRates !== null) {
+                cumulativeBorrowRate = cumulativeBorrowRates.get(reserve.address);
+            }
+            else {
+                cumulativeBorrowRate = reserve.getCumulativeBorrowRate();
+            }
+            const borrowAmount = KaminoObligation.getBorrowAmount(borrow)
+                .mul(cumulativeBorrowRate)
+                .dividedBy(obligationCumulativeBorrowRate);
+            const borrowValueUsd = borrowAmount.mul(getPx(reserve)).dividedBy(reserve.getMintFactor());
+            const borrowFactor = KaminoObligation.getBorrowFactorForReserve(reserve, obligation.elevationGroup);
+            const borrowValueBorrowFactorAdjustedUsd = borrowValueUsd.mul(borrowFactor);
+            if (!borrowAmount.eq(new decimal_js_1.default('0'))) {
+                positions += 1;
+            }
+            userTotalBorrow = userTotalBorrow.plus(borrowValueUsd);
+            userTotalBorrowBorrowFactorAdjusted = userTotalBorrowBorrowFactorAdjusted.plus(borrowValueBorrowFactorAdjustedUsd);
+            const position = {
+                reserveAddress: reserve.address,
+                mintAddress: reserve.getLiquidityMint(),
+                amount: borrowAmount,
+                marketValueRefreshed: borrowValueUsd,
+            };
+            borrows.set(reserve.address, position);
+        }
+        return {
+            borrows,
+            userTotalBorrow,
+            userTotalBorrowBorrowFactorAdjusted,
+            positions,
+        };
+    }
+    /**
+     *
+     * @returns Total borrowed amount for the specified obligation liquidity/borrow asset
+     */
+    static getBorrowAmount(borrow) {
+        return new fraction_1.Fraction(borrow.borrowedAmountSf).toDecimal();
+    }
+    /**
+     *
+     * @returns Cumulative borrow rate for the specified obligation liquidity/borrow asset
+     */
+    static getCumulativeBorrowRate(borrow) {
+        let accSf = new bn_js_1.default(0);
+        for (const value of borrow.cumulativeBorrowRateBsf.value.reverse()) {
+            accSf = accSf.add(value);
+            accSf.shrn(64);
+        }
+        return new fraction_1.Fraction(accSf).toDecimal();
+    }
+    static getRatesForObligation(kaminoMarket, obligation, slot) {
+        const collateralExchangeRates = KaminoObligation.getCollateralExchangeRatesForObligation(kaminoMarket, obligation, slot);
+        const cumulativeBorrowRates = KaminoObligation.getCumulativeBorrowRatesForObligation(kaminoMarket, obligation, slot);
+        return {
+            collateralExchangeRates,
+            cumulativeBorrowRates,
+        };
+    }
+    static addRatesForObligation(kaminoMarket, obligation, collateralExchangeRates, cumulativeBorrowRates, slot) {
+        KaminoObligation.addCollateralExchangeRatesForObligation(kaminoMarket, collateralExchangeRates, obligation, slot);
+        KaminoObligation.addCumulativeBorrowRatesForObligation(kaminoMarket, cumulativeBorrowRates, obligation, slot);
+    }
+    static getCollateralExchangeRatesForObligation(kaminoMarket, obligation, slot) {
+        const collateralExchangeRates = new utils_2.PubkeyHashMap();
+        for (let i = 0; i < obligation.deposits.length; i++) {
+            const deposit = obligation.deposits[i];
+            if ((0, utils_2.isNotNullPubkey)(deposit.depositReserve) && !collateralExchangeRates.has(deposit.depositReserve)) {
+                const reserve = kaminoMarket.getReserveByAddress(deposit.depositReserve);
+                const collateralExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, kaminoMarket.state.referralFeeBps);
+                collateralExchangeRates.set(reserve.address, collateralExchangeRate);
+            }
+        }
+        return collateralExchangeRates;
+    }
+    static addCollateralExchangeRatesForObligation(kaminoMarket, collateralExchangeRates, obligation, slot) {
+        for (let i = 0; i < obligation.deposits.length; i++) {
+            const deposit = obligation.deposits[i];
+            if ((0, utils_2.isNotNullPubkey)(deposit.depositReserve) && !collateralExchangeRates.has(deposit.depositReserve)) {
+                const reserve = kaminoMarket.getReserveByAddress(deposit.depositReserve);
+                const collateralExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, kaminoMarket.state.referralFeeBps);
+                collateralExchangeRates.set(reserve.address, collateralExchangeRate);
+            }
+        }
+    }
+    static getCumulativeBorrowRatesForObligation(kaminoMarket, obligation, slot) {
+        const cumulativeBorrowRates = new utils_2.PubkeyHashMap();
+        for (let i = 0; i < obligation.borrows.length; i++) {
+            const borrow = obligation.borrows[i];
+            if ((0, utils_2.isNotNullPubkey)(borrow.borrowReserve) && !cumulativeBorrowRates.has(borrow.borrowReserve)) {
+                const reserve = kaminoMarket.getReserveByAddress(borrow.borrowReserve);
+                const cumulativeBorrowRate = reserve.getEstimatedCumulativeBorrowRate(slot);
+                cumulativeBorrowRates.set(reserve.address, cumulativeBorrowRate);
+            }
+        }
+        return cumulativeBorrowRates;
+    }
+    static addCumulativeBorrowRatesForObligation(kaminoMarket, cumulativeBorrowRates, obligation, slot) {
+        for (let i = 0; i < obligation.borrows.length; i++) {
+            const borrow = obligation.borrows[i];
+            if ((0, utils_2.isNotNullPubkey)(borrow.borrowReserve) && !cumulativeBorrowRates.has(borrow.borrowReserve)) {
+                const reserve = kaminoMarket.getReserveByAddress(borrow.borrowReserve);
+                const cumulativeBorrowRate = reserve.getEstimatedCumulativeBorrowRate(slot);
+                cumulativeBorrowRates.set(reserve.address, cumulativeBorrowRate);
+            }
+        }
+    }
+    static getBorrowFactorForReserve(reserve, elevationGroup) {
+        if (elevationGroup !== 0) {
+            return new decimal_js_1.default(1);
+        }
+        return new decimal_js_1.default(reserve.stats.borrowFactor).div(100);
+    }
+}
+exports.KaminoObligation = KaminoObligation;
+//# sourceMappingURL=obligation.js.map