@kamino-finance/klend-sdk 5.15.2 → 5.15.3

package/dist/tests/tests/emode.test.js

@@ -0,0 +1,1319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Tests
+// - [x] test getBorrowCapForReserve() -> BorrowCapsAndCounters is correctly calculated
+// - [x] deposit and switch elevation group back and forth - with no debt
+// - [x] deposit and switch elevation group back and forth - with debt
+// - [x] borrow and switch elevation group back and forth - with no debt
+// - [x] borrow and switch elevation group back and forth - with debt
+// - [x] test isLoanEligibleForElevationGroup()
+// - [x] test getElevationGroupsForObligation()
+// - [x] test getLiquidityAvailableForDebtReserveGivenCaps()
+// - [wip] test getElevationGroupsForReservesCombination()
+// - [wip] test getBorrowPower()
+// - [ ] test getMaxBorrowAmountV2()
+// - TODO: remove all the toString()
+const chai_1 = require("chai");
+const setup_operations_1 = require("./runner/setup_operations");
+const setup_utils_1 = require("./runner/setup_utils");
+const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
+const src_1 = require("../src");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const assert_1 = require("./runner/assert");
+const kit_1 = require("@solana/kit");
+const token_2022_1 = require("@solana-program/token-2022");
+const leverage_utils_1 = require("./runner/leverage_utils");
+const env_1 = require("./runner/env");
+const tx_1 = require("./runner/tx");
+describe('isolated_and_cross_modes', () => {
+    let env;
+    before(async function () {
+        env = await (0, env_1.initEnv)();
+    });
+    it('switch_elevation_group_back_and_forth_between_0_and_elevated_one', async () => {
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            marketConfig: {
+                elevationGroups: [
+                    {
+                        maxLtv: 80,
+                        liquidationLtv: 85,
+                    },
+                    {
+                        maxLtv: 80,
+                        liquidationLtv: 85,
+                    },
+                    {
+                        maxLtv: 80,
+                        liquidationLtv: 85,
+                    },
+                ],
+            },
+            reserves: [
+                [
+                    'SOL',
+                    '100',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 1,
+                                isDebt: true,
+                            },
+                            {
+                                id: 2,
+                            },
+                        ],
+                    },
+                ],
+                [
+                    'JITOSOL',
+                    '5000',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 1,
+                            },
+                        ],
+                    },
+                ],
+                [
+                    'USDC',
+                    '5000',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 3,
+                                isDebt: true,
+                            },
+                        ],
+                    },
+                ],
+                [
+                    { symbol: 'PYUSD', tokenProgram: token_2022_1.TOKEN_2022_PROGRAM_ADDRESS },
+                    '5000',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 2,
+                                isDebt: true,
+                            },
+                            {
+                                id: 3,
+                            },
+                        ],
+                    },
+                ],
+            ],
+            loan: {
+                deposits: [['SOL', '1']],
+                borrows: [],
+                additionalBalances: [
+                    ['SOL', '9'],
+                    ['JITOSOL', '10'],
+                    ['USDC', '10'],
+                    ['PYUSD', '10'],
+                ],
+            },
+        });
+        // Create group between SOL and JITOSOL, with SOL debt - 1
+        // Create group between SOL and PyUSD, with PyUSD debt - 2
+        // Create group between USDC and PyUSD, with USDC debt - 3
+        const defaultElevationGroupNo = 0;
+        const solPyusdGroupNo = 2;
+        const userBalances = await (0, setup_utils_1.balances)(env, borrower.owner.address, kaminoMarket, [
+            'SOL',
+            'JITOSOL',
+            'USDC',
+            'PYUSD',
+        ]);
+        console.log('userBalances', userBalances);
+        let obligation = (await kaminoMarket.getObligationByWallet(borrower.owner.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        console.log('Obligation', 'Elevation Group', obligation?.state.elevationGroup);
+        chai_1.assert.equal(obligation.state.elevationGroup, defaultElevationGroupNo);
+        // Try to switch to the elevation group 2
+        const switchElevationGroupAction = await src_1.KaminoAction.buildRequestElevationGroupTxns(kaminoMarket, borrower.owner, obligation, solPyusdGroupNo);
+        const sig = await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, src_1.KaminoAction.actionToIxs(switchElevationGroupAction), [], [], 'switchElevationGroup');
+        console.log('Switch Elevation Group', sig);
+        obligation = (await kaminoMarket.getObligationByWallet(borrower.owner.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        console.log('Obligation', 'Elevation Group', obligation.state.elevationGroup);
+        chai_1.assert.equal(obligation.state.elevationGroup, solPyusdGroupNo);
+        // Try to switch back to the elevation group 0
+        const switchBackElevationGroupAction = await src_1.KaminoAction.buildRequestElevationGroupTxns(kaminoMarket, borrower.owner, obligation, defaultElevationGroupNo);
+        const sig2 = await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, src_1.KaminoAction.actionToIxs(switchBackElevationGroupAction), [], [], 'switchBackElevationGroup');
+        console.log('Switch Back Elevation Group', sig2);
+        obligation = (await kaminoMarket.getObligationByWallet(borrower.owner.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        console.log('Obligation', 'Elevation Group', obligation.state.elevationGroup);
+        chai_1.assert.equal(obligation.state.elevationGroup, defaultElevationGroupNo);
+    });
+    it('elevation_group_utils', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        const initAllElevationGroups = await kaminoMarket.getMarketElevationGroupDescriptions();
+        chai_1.assert.equal(initAllElevationGroups.length, 0);
+        // Create group between SOL and JITOSOL, with SOL debt
+        // Create group between SOL and PyUSD, with PyUSD debt
+        // Create group between USDC and PyUSD, with USDC debt
+        const res = await Promise.all([
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'USDC'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'PYUSD'),
+        ]);
+        const { mint: solMint, reserve: solReservePk } = res[0];
+        const { mint: jitosolMint, reserve: jitosolReservePk } = res[1];
+        const { mint: usdcMint, reserve: usdcReservePk } = res[2];
+        const { mint: pyusdMint, reserve: pyusdReservePk } = res[3];
+        const jitosolSolGroupNo = 1;
+        const solPyusdGroupNo = 2;
+        const pyusdUsdcGroupNo = 3;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // SOL debt, JITOSOL collateral
+        const solPyusdGroup = (0, setup_utils_1.makeElevationGroupConfig)(pyusdReservePk, solPyusdGroupNo); // PyUSD debt, SOL collateral
+        const pyusdUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, pyusdUsdcGroupNo); // USDC debt, PyUSD collateral
+        await Promise.all([
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, pyusdReservePk, solPyusdGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, pyusdUsdcGroup),
+        ]);
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo, solPyusdGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, usdcReservePk, [pyusdUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, pyusdReservePk, [solPyusdGroupNo, pyusdUsdcGroupNo]),
+        ]);
+        //
+        await kaminoMarket.reload();
+        const allElevationGroups = await kaminoMarket.getMarketElevationGroupDescriptions();
+        const numElevationGroups = 3;
+        chai_1.assert.equal(allElevationGroups.length, numElevationGroups);
+        const expectedElevationGroups = [
+            {
+                collateralReserves: new Set([jitosolReservePk]),
+                collateralLiquidityMints: new Set([jitosolMint]),
+                debtReserve: solReservePk,
+                debtLiquidityMint: solMint,
+                elevationGroup: jitosolSolGroupNo,
+                maxReservesAsCollateral: 1,
+            },
+            {
+                collateralReserves: new Set([solReservePk]),
+                collateralLiquidityMints: new Set([solMint]),
+                debtReserve: pyusdReservePk,
+                debtLiquidityMint: pyusdMint,
+                elevationGroup: solPyusdGroupNo,
+                maxReservesAsCollateral: 1,
+            },
+            {
+                collateralReserves: new Set([pyusdReservePk]),
+                collateralLiquidityMints: new Set([pyusdMint]),
+                debtReserve: usdcReservePk,
+                debtLiquidityMint: usdcMint,
+                elevationGroup: pyusdUsdcGroupNo,
+                maxReservesAsCollateral: 1,
+            },
+        ];
+        for (let i = 0; i < numElevationGroups; i++) {
+            chai_1.assert.deepEqual(allElevationGroups[i], expectedElevationGroups[i]);
+        }
+        const solPyusd = kaminoMarket.getElevationGroupsForMintsCombination([solMint], pyusdMint);
+        chai_1.assert.equal(solPyusd.length, 1);
+        chai_1.assert.equal(solPyusd[0].elevationGroup, solPyusdGroupNo);
+        const jitosolSol = kaminoMarket.getElevationGroupsForMintsCombination([jitosolMint], solMint);
+        chai_1.assert.equal(jitosolSol.length, 1);
+        chai_1.assert.equal(jitosolSol[0].elevationGroup, jitosolSolGroupNo);
+        const pyusdUsdc = kaminoMarket.getElevationGroupsForMintsCombination([pyusdMint], usdcMint);
+        chai_1.assert.equal(pyusdUsdc.length, 1);
+        chai_1.assert.equal(pyusdUsdc[0].elevationGroup, pyusdUsdcGroupNo);
+        const usdcPyusd = kaminoMarket.getElevationGroupsForMintsCombination([usdcMint], pyusdMint);
+        chai_1.assert.equal(usdcPyusd.length, 0);
+        const jitosolPyUsd = kaminoMarket.getElevationGroupsForMintsCombination([jitosolMint], pyusdMint);
+        chai_1.assert.equal(jitosolPyUsd.length, 0);
+        const jitosolUsdc = kaminoMarket.getElevationGroupsForMintsCombination([jitosolMint], usdcMint);
+        chai_1.assert.equal(jitosolUsdc.length, 0);
+        const jitosolDebtSolColl = kaminoMarket.getElevationGroupsForMintsCombination([solMint], jitosolMint);
+        chai_1.assert.equal(jitosolDebtSolColl.length, 0);
+        const solCollateralGroups = kaminoMarket.getElevationGroupsForMintsCombination([solMint], undefined);
+        chai_1.assert.equal(solCollateralGroups.length, 1);
+    });
+    it('loan_elevation_group_eligibility', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        // Create group between SOL and JITOSOL, with SOL debt
+        // Create group between SOL and PyUSD, with PyUSD debt
+        // Create group between USDC and PyUSD, with USDC debt
+        const res = await Promise.all([
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'USDC'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'PYUSD'),
+        ]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const { reserve: usdcReservePk } = res[2];
+        const { reserve: pyusdReservePk } = res[3];
+        const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const solPyusdGroupNo = 2;
+        const pyusdUsdcGroupNo = 3;
+        const solUsdcGroupNo = 4;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        const solPyusdGroup = (0, setup_utils_1.makeElevationGroupConfig)(pyusdReservePk, solPyusdGroupNo); // SOL collateral, PyUSD debt,
+        const pyusdUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, pyusdUsdcGroupNo); // PyUSD collateral, USDC debt,
+        const solUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, solUsdcGroupNo); // SOL collateral, USDC debt,
+        await Promise.all([
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, pyusdReservePk, solPyusdGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, pyusdUsdcGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, solUsdcGroup),
+        ]);
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo, solPyusdGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, usdcReservePk, [pyusdUsdcGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, pyusdReservePk, [solPyusdGroupNo, pyusdUsdcGroupNo]),
+        ]);
+        await kaminoMarket.reload();
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+            ['USDC', '10'],
+            ['PYUSD', '10'],
+        ]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const slot = await env.c.rpc.getSlot().send();
+        const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        const eligibleGroups = await obligation.getElevationGroupsForObligation(kaminoMarket);
+        chai_1.assert.equal(eligibleGroups.length, 2);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, jitosolSolGroupNo), false);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, solPyusdGroupNo), true);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, pyusdUsdcGroupNo), false);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, solUsdcGroupNo), true);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, defaultElevationGroupNo), true);
+    });
+    it('deposit_or_borrow_and_switch_borrow_cap', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        // Create group between SOL and JITOSOL, with SOL debt
+        // Create group between SOL and PyUSD, with PyUSD debt
+        // Create group between USDC and PyUSD, with USDC debt
+        const res = await Promise.all([
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'USDC'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'PYUSD'),
+        ]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const { reserve: usdcReservePk } = res[2];
+        const { reserve: pyusdReservePk } = res[3];
+        // const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const solPyusdGroupNo = 2;
+        const pyusdUsdcGroupNo = 3;
+        const solUsdcGroupNo = 4;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        const solPyusdGroup = (0, setup_utils_1.makeElevationGroupConfig)(pyusdReservePk, solPyusdGroupNo); // SOL collateral, PyUSD debt,
+        const pyusdUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, pyusdUsdcGroupNo); // PyUSD collateral, USDC debt,
+        const solUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, solUsdcGroupNo); // SOL collateral, USDC debt,
+        await Promise.all([
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, pyusdReservePk, solPyusdGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, pyusdUsdcGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, solUsdcGroup),
+        ]);
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo, solPyusdGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, usdcReservePk, [pyusdUsdcGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, pyusdReservePk, [solPyusdGroupNo, pyusdUsdcGroupNo]),
+        ]);
+        await (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, solReservePk, [0, 1_500_000_000]); // 1.5 SOL
+        await kaminoMarket.reload();
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['PYUSD', '10']]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'PYUSD', new decimal_js_1.default(10), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+            ['USDC', '10'],
+            ['PYUSD', '10'],
+        ]);
+        {
+            // No debt, No elevation group provided, defaults to 0
+            await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 0);
+        }
+        {
+            // No debt, Go to 0 explicitly, but it gets ignored
+            await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID), false, true, 0);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 0);
+        }
+        {
+            // No debt, Go to 2
+            await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID), false, true, 2);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 2);
+        }
+        {
+            // No debt, Go to 4
+            await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID), false, true, 4);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 4);
+        }
+        {
+            // No debt, Back to 0
+            await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID), false, true, 0);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 0);
+        }
+        {
+            // With debt, Stay at 0
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'PYUSD', new decimal_js_1.default(0.1));
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 0);
+        }
+        {
+            // With debt, Go to 2
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'PYUSD', new decimal_js_1.default(0.1), undefined, (0, kit_1.none)(), true, undefined, 2);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 2);
+        }
+        {
+            // With debt, Go to back to 0
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'PYUSD', new decimal_js_1.default(0.1), undefined, (0, kit_1.none)(), true, undefined, 0);
+            const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+            chai_1.assert.equal(obligation.state.elevationGroup, 0);
+        }
+    });
+    it('get borrow caps', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        // Create group between SOL and JITOSOL, with SOL debt
+        // Create group between SOL and PyUSD, with PyUSD debt
+        // Create group between USDC and PyUSD, with USDC debt
+        const res = await Promise.all([
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'USDC'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'PYUSD'),
+        ]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const { reserve: usdcReservePk } = res[2];
+        const { reserve: pyusdReservePk } = res[3];
+        // const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const solPyusdGroupNo = 2;
+        const pyusdUsdcGroupNo = 3;
+        const solUsdcGroupNo = 4;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        const solPyusdGroup = (0, setup_utils_1.makeElevationGroupConfig)(pyusdReservePk, solPyusdGroupNo); // SOL collateral, PyUSD debt,
+        const pyusdUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, pyusdUsdcGroupNo); // PyUSD collateral, USDC debt,
+        const solUsdcGroup = (0, setup_utils_1.makeElevationGroupConfig)(usdcReservePk, solUsdcGroupNo); // SOL collateral, USDC debt,
+        await Promise.all([
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, pyusdReservePk, solPyusdGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, pyusdUsdcGroup),
+            (0, setup_operations_1.updateMarketElevationGroup)(env, market, usdcReservePk, solUsdcGroup),
+        ]);
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo, solPyusdGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, usdcReservePk, [pyusdUsdcGroupNo, solUsdcGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, pyusdReservePk, [solPyusdGroupNo, pyusdUsdcGroupNo]),
+        ]);
+        await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, 2_000_000_000); // 2.0 SOL
+        await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, 1_500_000_000); // 1.5 SOL
+        await (0, setup_operations_1.updateReserveUtilizationCap)(env, kaminoMarket, solReservePk, 80);
+        await (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [500_000_000]); // 0.5 SOL
+        await (0, setup_operations_1.updateReserveDebtNetWithdrawalCap)(env, kaminoMarket, solReservePk, 1_500_000_000, 500); // 1.5 SOL every 500 seconds
+        await kaminoMarket.reload();
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['SOL', '10']]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'SOL', new decimal_js_1.default('10'), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+            ['USDC', '10'],
+            ['PYUSD', '10'],
+        ]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'JITOSOL', new decimal_js_1.default('5'), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default('1'));
+        await kaminoMarket.reload();
+        const solReserve = kaminoMarket.getReserveByAddress(solReservePk);
+        const solBorrowCaps = solReserve.getBorrowCapForReserve(kaminoMarket);
+        const expectedBorrowCaps = {
+            utilizationCap: new decimal_js_1.default(0.8), // 80%
+            utilizationCurrentValue: new decimal_js_1.default(0.1), // 10%
+            netWithdrawalCap: new decimal_js_1.default(1500000000),
+            netWithdrawalCurrentValue: new decimal_js_1.default(1000000000),
+            netWithdrawalLastUpdateTs: new decimal_js_1.default(0),
+            netWithdrawalIntervalDurationSeconds: new decimal_js_1.default(500),
+            globalDebtCap: new decimal_js_1.default(2000000000),
+            globalTotalBorrowed: new decimal_js_1.default(1000000000),
+            debtOutsideEmodeCap: new decimal_js_1.default(1500000000),
+            borrowedOutsideEmode: new decimal_js_1.default(1000000000),
+            debtAgainstCollateralReserveCaps: [
+                {
+                    collateralReserve: jitosolReservePk,
+                    elevationGroup: 1,
+                    maxDebt: new decimal_js_1.default(500000000),
+                    currentValue: new decimal_js_1.default(0),
+                },
+            ],
+        };
+        (0, chai_1.assert)(solBorrowCaps.utilizationCap.equals(expectedBorrowCaps.utilizationCap));
+        (0, assert_1.assertFuzzyEq)(solBorrowCaps.utilizationCurrentValue, expectedBorrowCaps.utilizationCurrentValue);
+        (0, chai_1.assert)(solBorrowCaps.netWithdrawalCap.equals(expectedBorrowCaps.netWithdrawalCap));
+        (0, chai_1.assert)(solBorrowCaps.netWithdrawalCurrentValue.equals(expectedBorrowCaps.netWithdrawalCurrentValue));
+        // assert(solBorrowCaps.netWithdrawalLastUpdateTs.equals(expectedBorrowCaps.netWithdrawalLastUpdateTs));
+        (0, chai_1.assert)(solBorrowCaps.netWithdrawalIntervalDurationSeconds.equals(expectedBorrowCaps.netWithdrawalIntervalDurationSeconds));
+        (0, chai_1.assert)(solBorrowCaps.globalDebtCap.equals(expectedBorrowCaps.globalDebtCap));
+        (0, assert_1.assertFuzzyEq)(solBorrowCaps.globalTotalBorrowed, expectedBorrowCaps.globalTotalBorrowed);
+        (0, chai_1.assert)(solBorrowCaps.debtOutsideEmodeCap.equals(expectedBorrowCaps.debtOutsideEmodeCap));
+        (0, chai_1.assert)(solBorrowCaps.borrowedOutsideEmode.equals(expectedBorrowCaps.borrowedOutsideEmode));
+        for (let i = 0; i < solBorrowCaps.debtAgainstCollateralReserveCaps.length; i++) {
+            const actual = solBorrowCaps.debtAgainstCollateralReserveCaps[i];
+            const expected = expectedBorrowCaps.debtAgainstCollateralReserveCaps[i];
+            (0, chai_1.assert)(actual.collateralReserve === expected.collateralReserve);
+            (0, chai_1.assert)(actual.elevationGroup === expected.elevationGroup);
+            (0, chai_1.assert)(actual.maxDebt.equals(expected.maxDebt));
+            (0, chai_1.assert)(actual.currentValue.equals(expected.currentValue));
+        }
+    });
+    it('get_liquidity_available_given_caps', async () => {
+        // TODO: check for `is_borrowing_disabled` in smart contracts
+        // TODO: check for `check_elevation_group_borrowing_enabled` in smart contracts
+        // TODO: check for `check_non_elevation_group_borrowing_enabled` in smart contracts
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            marketConfig: {
+                elevationGroups: [
+                    { maxLtv: 90, liquidationLtv: 95 },
+                    { maxLtv: 90, liquidationLtv: 95 },
+                ],
+            },
+            reserves: [
+                [
+                    'SOL',
+                    '10',
+                    {
+                        elevationGroups: [
+                            { id: 1, isDebt: true, borrowLimitAgainstThisCollateralInElevationGroup: '0' },
+                            { id: 2, isDebt: true, borrowLimitAgainstThisCollateralInElevationGroup: '0' },
+                        ],
+                    },
+                ],
+                ['JITOSOL', '100', { elevationGroups: [{ id: 1, borrowLimitAgainstThisCollateralInElevationGroup: '0' }] }],
+                ['MSOL', '100', { elevationGroups: [{ id: 2, borrowLimitAgainstThisCollateralInElevationGroup: '0' }] }],
+            ],
+            loan: {
+                deposits: [['JITOSOL', '5']],
+                borrows: [],
+            },
+        });
+        const solReservePk = kaminoMarket.getReserveBySymbol('SOL').address;
+        const jitosolReservePk = kaminoMarket.getReserveBySymbol('JITOSOL').address;
+        const msolReservePk = kaminoMarket.getReserveBySymbol('MSOL').address;
+        const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const msolSolGroupNo = 2;
+        // Settings we will test
+        // - liquidity available
+        // - global debt limit
+        // - outside elevation mode debt limit
+        // - inside elevation mode debt limit
+        // - net withdrawal cap
+        // - utilization cap
+        // - borrow to remove some liquidity
+        await kaminoMarket.reload();
+        let rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+        const sol = (x) => (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(x), rsrv.state.liquidity.mintDecimals.toNumber());
+        const revSol = (x) => (0, src_1.lamportsToNumberDecimal)(x, rsrv.state.liquidity.mintDecimals.toNumber());
+        const groups = [defaultElevationGroupNo, jitosolSolGroupNo, msolSolGroupNo];
+        {
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(10.0001));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(0)); // emodes still have 0 debt caps
+            (0, assert_1.assertFuzzyEq)(res[2], sol(0)); // emodes still have 0 debt caps
+        }
+        {
+            await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, sol(2).toNumber()); // 2.0 SOL
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(2));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(0)); // emodes still have 0 debt caps
+            (0, assert_1.assertFuzzyEq)(res[2], sol(0)); // emodes still have 0 debt caps
+            // Raise it back to much higher
+            await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, sol(100000).toNumber()); // 2.0 SOL
+        }
+        {
+            // await updateReserveBorrowLimit(env, kaminoMarket, solReservePk, sol(2).toNumber()); // 2.0 SOL
+            await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, sol(1.5).toNumber()); // 1.5 SOL
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(1.5));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(0)); // emodes still have 0 debt caps
+            (0, assert_1.assertFuzzyEq)(res[2], sol(0)); // emodes still have 0 debt caps
+            // Raise it back to much higher
+            await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, sol(100000).toNumber()); // 1.5 SOL
+        }
+        {
+            await (0, setup_operations_1.updateReserveUtilizationCap)(env, kaminoMarket, solReservePk, 65);
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(6.500065));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(0)); // emodes still have 0 debt caps
+            (0, assert_1.assertFuzzyEq)(res[2], sol(0)); // emodes still have 0 debt caps
+            // Raise it back to much higher
+            await (0, setup_operations_1.updateReserveUtilizationCap)(env, kaminoMarket, solReservePk, 100);
+        }
+        {
+            await (0, setup_operations_1.updateReserveDebtNetWithdrawalCap)(env, kaminoMarket, solReservePk, sol(3.5).toNumber(), 500); // 3.5 SOL every 500 seconds
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(3.5));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(0)); // emodes still have 0 debt caps
+            (0, assert_1.assertFuzzyEq)(res[2], sol(0)); // emodes still have 0 debt caps
+            // Raise it back to much higher
+            await (0, setup_operations_1.updateReserveDebtNetWithdrawalCap)(env, kaminoMarket, solReservePk, sol(100000).toNumber(), 500); // 3.5 SOL every 500 seconds
+        }
+        {
+            await (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [
+                sol(9.3).toNumber(),
+                0,
+            ]);
+            await (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, msolReservePk, [
+                0,
+                sol(9.7).toNumber(),
+            ]);
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(10.0001));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(9.3));
+            (0, assert_1.assertFuzzyEq)(res[2], sol(9.7));
+        }
+        {
+            // Borrow 1 SOL, to remove some available liquidity
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, borrower.owner, 'SOL', new decimal_js_1.default(1));
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(9.0001));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(9.0001));
+            (0, assert_1.assertFuzzyEq)(res[2], sol(9.0001));
+        }
+        {
+            // Borrow 0.5 SOL, to remove some available liquidity
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, borrower.owner, 'SOL', new decimal_js_1.default(0.5));
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(8.5001));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(8.5001));
+            (0, assert_1.assertFuzzyEq)(res[2], sol(8.5001));
+        }
+        {
+            await (0, setup_utils_1.borrow)(env, kaminoMarket, borrower.owner, 'SOL', new decimal_js_1.default(0.5));
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(8.0001));
+            (0, assert_1.assertFuzzyEq)(res[1], sol(8.0001));
+            (0, assert_1.assertFuzzyEq)(res[2], sol(8.0001));
+        }
+        // Now add the caps back, one after the other
+        {
+            // These have to be set together because borrow_limit cannot be < borrow_limit_outside_elevation_group
+            await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 1.5 SOL
+            await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 2.0 SOL
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(revSol(res[0]), 5.0, 0.00001); // 10 available - 2 borrowed = total debt = 2, max debt = 7 => max more borrowable 5
+            (0, assert_1.assertFuzzyEq)(revSol(res[1]), 5.0, 0.00001);
+            (0, assert_1.assertFuzzyEq)(revSol(res[2]), 5.0, 0.00001);
+        }
+        {
+            // These have to be set together because borrow_limit cannot be < borrow_limit_outside_elevation_group
+            await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 1.5 SOL
+            await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 2.0 SOL
+            await (0, setup_operations_1.updateReserveUtilizationCap)(env, kaminoMarket, solReservePk, 65);
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(revSol(res[0]), 4.5, 0.0001);
+            (0, assert_1.assertFuzzyEq)(revSol(res[1]), 4.5, 0.0001);
+            (0, assert_1.assertFuzzyEq)(revSol(res[2]), 4.5, 0.0001);
+        }
+        {
+            // These have to be set together because borrow_limit cannot be < borrow_limit_outside_elevation_group
+            await (0, setup_operations_1.updateReserveBorrowLimitOutsideEmode)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 1.5 SOL
+            await (0, setup_operations_1.updateReserveBorrowLimit)(env, kaminoMarket, solReservePk, sol(7).toNumber()); // 2.0 SOL
+            await (0, setup_operations_1.updateReserveUtilizationCap)(env, kaminoMarket, solReservePk, 65);
+            await (0, setup_operations_1.updateReserveDebtNetWithdrawalCap)(env, kaminoMarket, solReservePk, sol(3.5).toNumber(), 500); // 3.5 SOL every 500 seconds
+            await kaminoMarket.reload();
+            rsrv = kaminoMarket.getReserveByAddress(solReservePk);
+            const res = await rsrv.getLiquidityAvailableForDebtReserveGivenCaps(kaminoMarket, groups, [
+                solReservePk,
+                jitosolReservePk,
+                msolReservePk,
+            ]);
+            chai_1.assert.equal(res.length, groups.length);
+            (0, assert_1.assertFuzzyEq)(res[0], sol(1.5)); // max net daily 3.5, 2 already borroed => 1.5 remaining
+            (0, assert_1.assertFuzzyEq)(res[1], sol(1.5));
+            (0, assert_1.assertFuzzyEq)(res[2], sol(1.5));
+        }
+    });
+    it('is_loan_eligible_for_elevation_group_ltv_part', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        const res = await Promise.all([(0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'), (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL')]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        await Promise.all([(0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup)]); // 90% ltv, 95% liq ltv
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveLtv)(env, kaminoMarket, jitosolReservePk, 70),
+            (0, setup_operations_1.updateReserveLiquidationLtv)(env, kaminoMarket, jitosolReservePk, 80),
+            (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [10_000_000_000]), // 10 SOL
+        ]);
+        await kaminoMarket.reload();
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['SOL', '10']]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'SOL', new decimal_js_1.default(10), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+        ]);
+        const slot = await env.c.rpc.getSlot().send();
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'JITOSOL', new decimal_js_1.default(5), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        let obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, defaultElevationGroupNo), true);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, jitosolSolGroupNo), true);
+        await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1), undefined, (0, kit_1.none)(), true, undefined, jitosolSolGroupNo);
+        obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        chai_1.assert.equal(obligation.state.elevationGroup, jitosolSolGroupNo);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, defaultElevationGroupNo), true);
+        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), new decimal_js_1.default(0.2));
+        // Now borrow more to go to 75% LTV
+        await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(2.75), undefined, (0, kit_1.none)(), true, undefined, jitosolSolGroupNo);
+        obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        chai_1.assert.equal(obligation.state.elevationGroup, jitosolSolGroupNo);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, jitosolSolGroupNo), true);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, defaultElevationGroupNo), false);
+        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), new decimal_js_1.default(0.75));
+        // Now repay to go below 70% LTV
+        await (0, setup_utils_1.repay)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(0.26));
+        obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        chai_1.assert.equal(obligation.state.elevationGroup, jitosolSolGroupNo);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, jitosolSolGroupNo), true);
+        chai_1.assert.equal(obligation.isLoanEligibleForElevationGroup(kaminoMarket, slot, defaultElevationGroupNo), true);
+        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), new decimal_js_1.default(0.6979));
+    });
+    it('get_borrow_power_simple', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        const res = await Promise.all([(0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'), (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL')]);
+        const { reserve: solReservePk, mint: solMint } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const jitosolSolGroupNo = 1;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        await Promise.all([(0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup)]); // 90% ltv, 95% liq ltv
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveLtv)(env, kaminoMarket, jitosolReservePk, 70),
+            (0, setup_operations_1.updateReserveLiquidationLtv)(env, kaminoMarket, jitosolReservePk, 80),
+            (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [10_000_000_000]), // 10 SOL
+        ]);
+        await kaminoMarket.reload();
+        const solReserve = kaminoMarket.getReserveByAddress(solReservePk);
+        const jitosolReserve = kaminoMarket.getReserveByAddress(jitosolReservePk);
+        console.log('SOL Price', solReserve.tokenOraclePrice.price);
+        console.log('JITOSOL Price', jitosolReserve.tokenOraclePrice.price);
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['SOL', '10']]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'SOL', new decimal_js_1.default(10), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+        ]);
+        const slot = await env.c.rpc.getSlot().send();
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'JITOSOL', new decimal_js_1.default(5), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        const borrowPowerInCrossMode = obligation.getBorrowPower(kaminoMarket, solMint, slot, 0);
+        const borrowPowerInIsolatedMode = obligation.getBorrowPower(kaminoMarket, solMint, slot, 1);
+        console.log('Borrow Power in Cross Mode', borrowPowerInCrossMode); // Expected 70% of 5 SOL = 3.5 SOL
+        console.log('Borrow Power in Isolated Mode', borrowPowerInIsolatedMode); // Expected 90% of 5 SOL = 4.5 SOL
+        const decimalsSol = solReserve.getMintFactor();
+        (0, assert_1.assertFuzzyEq)(borrowPowerInCrossMode.div(decimalsSol), new decimal_js_1.default(3.5));
+        (0, assert_1.assertFuzzyEq)(borrowPowerInIsolatedMode.div(decimalsSol), new decimal_js_1.default(4.5));
+    });
+    // Test to test function `getMaxLoanLtvGivenElevationGroup`
+    it('get_max_loan_ltv_given_elevation_group', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        const res = await Promise.all([(0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'), (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL')]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const jitosolSolGroupNo = 1;
+        const jitosolSolGroup = (0, setup_utils_1.makeElevationGroupConfig)(solReservePk, jitosolSolGroupNo); // JITOSOL collateral, SOL debt,
+        await Promise.all([(0, setup_operations_1.updateMarketElevationGroup)(env, market, solReservePk, jitosolSolGroup)]); // 90% ltv, 95% liq ltv
+        await Promise.all([
+            (0, setup_operations_1.updateReserveElevationGroups)(env, solReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveElevationGroups)(env, jitosolReservePk, [jitosolSolGroupNo]),
+            (0, setup_operations_1.updateReserveLtv)(env, kaminoMarket, jitosolReservePk, 70),
+            (0, setup_operations_1.updateReserveLiquidationLtv)(env, kaminoMarket, jitosolReservePk, 80),
+            (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [10_000_000_000]), // 10 SOL
+        ]);
+        await kaminoMarket.reload();
+        const solReserve = kaminoMarket.getReserveByAddress(solReservePk);
+        const jitosolReserve = kaminoMarket.getReserveByAddress(jitosolReservePk);
+        console.log('SOL Price', solReserve.tokenOraclePrice.price);
+        console.log('JITOSOL Price', jitosolReserve.tokenOraclePrice.price);
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['SOL', '10']]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'SOL', new decimal_js_1.default(10), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+        ]);
+        const slot = await env.c.rpc.getSlot().send();
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'JITOSOL', new decimal_js_1.default(5), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        const maxLtvInElevationGroup0 = obligation.getMaxLoanLtvGivenElevationGroup(kaminoMarket, 0, slot);
+        const maxLtvInElevationGroup2 = obligation.getMaxLoanLtvGivenElevationGroup(kaminoMarket, 1, slot);
+        console.log('Max LTV in Elevation Group 0', maxLtvInElevationGroup0); // Expected 90%
+        console.log('Max LTV in Elevation Group 1', maxLtvInElevationGroup2); // Expected 70%
+        (0, assert_1.assertFuzzyEq)(maxLtvInElevationGroup0, new decimal_js_1.default(0.7));
+        (0, assert_1.assertFuzzyEq)(maxLtvInElevationGroup2, new decimal_js_1.default(0.9));
+    });
+    it('get simulated stats with elevation group change on actions with same reserves', async () => {
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            marketConfig: {
+                elevationGroups: [
+                    {
+                        maxLtv: 90,
+                        liquidationLtv: 95,
+                    },
+                ],
+            },
+            reserves: [
+                [
+                    'SOL',
+                    '10',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 1,
+                                isDebt: true,
+                            },
+                        ],
+                        borrowFactorPct: 200,
+                    },
+                ],
+                [
+                    'JITOSOL',
+                    '0',
+                    {
+                        loanToValuePct: 70,
+                        liquidationThreshold: 80,
+                        elevationGroups: [
+                            {
+                                id: 1,
+                                borrowLimitAgainstThisCollateralInElevationGroup: '10',
+                            },
+                        ],
+                    },
+                ],
+            ],
+            loan: {
+                deposits: [['JITOSOL', '5']],
+                borrows: [['SOL', '1']],
+                additionalBalances: [
+                    ['SOL', '10'],
+                    ['JITOSOL', '5'],
+                ],
+            },
+        });
+        const defaultElevationGroupNo = 0;
+        const jitosolSolGroupNo = 1;
+        const solReserve = kaminoMarket.getReserveBySymbol('SOL');
+        const jitosolReserve = kaminoMarket.getReserveBySymbol('JITOSOL');
+        const jitosolDecimals = jitosolReserve.state.liquidity.mintDecimals.toNumber();
+        const solDecimals = solReserve.state.liquidity.mintDecimals.toNumber();
+        const obligation = (await kaminoMarket.getObligationByWallet(borrower.owner.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        const initialLtv = obligation.refreshedStats.loanToValue;
+        const slot = await env.c.rpc.getSlot().send();
+        // (1 * 2)/5 = 0.4 because SOL has borrow factor of 200%
+        chai_1.assert.equal(obligation.state.elevationGroup, defaultElevationGroupNo);
+        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), new decimal_js_1.default(0.4));
+        {
+            // Simulate depositing more collateral, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'deposit',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // (1 * 2) / (5 + 1) = 0.3333333333333333
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.333333333));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate depositing more collateral, explicitly override to same elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'deposit',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                elevationGroupOverride: defaultElevationGroupNo,
+                slot,
+            });
+            // (1 * 2) / 6 = 0.3333333333333333
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.333333333));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate depositing more collateral, go to elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'deposit',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                elevationGroupOverride: jitosolSolGroupNo,
+                slot,
+            });
+            // 1 / 6 = 0.16666666666666666 because borrow factor here becomes 1 in elevation group
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.16666666666666666));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate borrowing, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'borrow',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // ((1 + 1) * 2)/5  = 0.8
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.8));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate borrowing, explicitly choose elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'borrow',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: defaultElevationGroupNo,
+            });
+            // ((1 + 1) * 2)/5  = 0.8
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.8));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate borrowing, go to elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'borrow',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: jitosolSolGroupNo,
+            });
+            // ((1 + 1) * 1)/5 = 0.4, here borrow factor is 1
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.4));
+        }
+        {
+            // Simulate repay, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repay',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // ((1 - 0.5) * 2)/5 = 0.2
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.2));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate repay, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repay',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: defaultElevationGroupNo,
+            });
+            // ((1 - 0.5) * 2)/5 = 0.2
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.2));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate repay, go to elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repay',
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: jitosolSolGroupNo,
+            });
+            // ((1 - 0.5) * 1)/5 = 0.1
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.1));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate withdraw some collateral, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'withdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // (1 * 2) / (5 - 1)  = 0.5
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.5));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate withdraw some collateral, explicitly choose elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'withdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: defaultElevationGroupNo,
+            });
+            // (1 * 2) / (5 - 1)  = 0.5
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.5));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate withdraw some collateral, explicitly choose elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                action: 'withdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: jitosolSolGroupNo,
+            });
+            // (1 * 1) / (5 - 1) = 0.25
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.25));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv); // elevation group upgrade improves LTV
+        }
+        {
+            // Simulate deposit and borrow, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'depositAndBorrow',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // ((1 + 1) * 2) / (5 + 1) = 0.6666666666666666
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.6666666666666666));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate deposit and borrow, explicitly choose elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'depositAndBorrow',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: defaultElevationGroupNo,
+            });
+            // ((1 + 1) * 2) / (5 + 1) = 0.6666666666666666
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.6666666666666666));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+        {
+            // Simulate deposit and borrow, explicitly choose elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), solDecimals),
+                action: 'depositAndBorrow',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: jitosolSolGroupNo,
+            });
+            // ((1 + 1) * 1) / (5 + 1) = 0.3333333333333333
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.3333333333333333));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate withdraw and repay, default stay in elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repayAndWithdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // ((1 - 0.5) * 2) / (5 - 1)  = 0.25
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.25));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate withdraw and repay, explicitly choose elevation group 0
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repayAndWithdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: defaultElevationGroupNo,
+            });
+            // ((1 - 0.5) * 2) / (5 - 1)  = 0.25
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.25));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate withdraw and repay, explicitly choose elevation group 1
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1), jitosolDecimals),
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(0.5), solDecimals),
+                action: 'repayAndWithdraw',
+                mintCollateral: jitosolReserve.getLiquidityMint(),
+                mintDebt: solReserve.getLiquidityMint(),
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+                elevationGroupOverride: jitosolSolGroupNo,
+            });
+            // ((1 - 0.5) * 1) / (5 - 1) = 0.125
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.125));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+    });
+    it('get_simulated_stats_with_elevation_group_change_on_actions_with_new_reserves', async () => {
+        const market = await (0, setup_operations_1.createMarket)(env);
+        const kaminoMarket = (await src_1.KaminoMarket.load(env.c.rpc, market, src_1.DEFAULT_RECENT_SLOT_DURATION_MS, src_1.PROGRAM_ID));
+        const res = await Promise.all([
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'SOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'JITOSOL'),
+            (0, setup_utils_1.addReserveToMarket)(env, market, 'USDC'),
+        ]);
+        const { reserve: solReservePk } = res[0];
+        const { reserve: jitosolReservePk } = res[1];
+        const { reserve: usdcReservePk, mint: usdcMint } = res[2];
+        const defaultElevationGroupNo = 0;
+        await Promise.all([
+            (0, setup_operations_1.updateReserveLtv)(env, kaminoMarket, jitosolReservePk, 70),
+            (0, setup_operations_1.updateReserveLiquidationLtv)(env, kaminoMarket, jitosolReservePk, 80),
+            (0, setup_operations_1.updateReserveBorrowLimitsAgainstCollInElevationGroup)(env, kaminoMarket, jitosolReservePk, [10_000_000_000]), // 10 SOL
+            (0, setup_operations_1.updateReserveBorrowFactor)(env, kaminoMarket, solReservePk, 200),
+            (0, setup_operations_1.updateReserveBorrowFactor)(env, kaminoMarket, usdcReservePk, 150),
+        ]);
+        await kaminoMarket.reload();
+        const usdcReserve = kaminoMarket.getReserveByAddress(usdcReservePk);
+        const usdcDecimals = usdcReserve.state.liquidity.mintDecimals.toNumber();
+        const whale = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['USDC', '10'],
+        ]);
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, whale, 'SOL', new decimal_js_1.default(10), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        const user = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '10'],
+            ['JITOSOL', '10'],
+            ['USDC', '10'],
+        ]);
+        // User deposits 5 JITOSOL and borrows 1 SOL
+        await (0, setup_utils_1.deposit)(env, kaminoMarket, user, 'JITOSOL', new decimal_js_1.default(5), undefined, new src_1.VanillaObligation(src_1.PROGRAM_ID));
+        await (0, setup_utils_1.borrow)(env, kaminoMarket, user, 'SOL', new decimal_js_1.default(1));
+        const obligation = (await kaminoMarket.getObligationByWallet(user.address, new src_1.VanillaObligation(src_1.PROGRAM_ID)));
+        const initialLtv = obligation.refreshedStats.loanToValue;
+        const slot = await env.c.rpc.getSlot().send();
+        // SOL Price 27.555
+        // JITOSOL Price 27.555
+        // USDC Price 1.00028333
+        // (1 * 27.555 * 2)/(5 * 27.555) = 0.39999999999999997 because SOL has borrow factor of 200%
+        chai_1.assert.equal(obligation.state.elevationGroup, defaultElevationGroupNo);
+        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), new decimal_js_1.default(0.4));
+        {
+            // Simulate depositing more new collateral
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountCollateral: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(10), usdcDecimals),
+                action: 'deposit',
+                mintCollateral: usdcMint,
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // (1 * 20 * 2)/(5 * 20 + 10 * 1) = 0.36363636363636363636
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default('0.36363636363636363636'));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue < initialLtv);
+        }
+        {
+            // Simulate borrowing more of new debt
+            const simulatedStats = obligation.getSimulatedObligationStats({
+                amountDebt: (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(10), usdcDecimals),
+                action: 'borrow',
+                mintDebt: usdcMint,
+                market: kaminoMarket,
+                reserves: kaminoMarket.reserves,
+                slot,
+            });
+            // (1 * 20 * 2 + 10 * 1 * 1.5)/(5 * 20) = 0.55
+            (0, assert_1.assertFuzzyEq)(simulatedStats.stats.loanToValue, new decimal_js_1.default(0.55));
+            (0, chai_1.assert)(simulatedStats.stats.loanToValue > initialLtv);
+        }
+    });
+    it('deposit_with_leverage_emode_possible_no_borrow_power_against_coll_elev_group', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const depositToken = collToken;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        const slippagePct = 0.01;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [
+                    collToken,
+                    '1000.05',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 1,
+                                borrowLimitAgainstThisCollateralInElevationGroup: '0',
+                            },
+                        ],
+                    },
+                ],
+                [
+                    debtToken,
+                    '1000.05',
+                    {
+                        elevationGroups: [
+                            {
+                                id: 1,
+                                isDebt: true,
+                            },
+                        ],
+                    },
+                ],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '10']],
+            },
+            marketConfig: {
+                elevationGroups: [
+                    {
+                        maxLtv: 80,
+                        liquidationLtv: 85,
+                    },
+                ],
+            },
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, depositToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+        console.log('leverage: ', leverage);
+        console.log('ltv: ', ltv.toNumber());
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+    });
+});
+//# sourceMappingURL=emode.test.js.map