@kamino-finance/klend-sdk 5.15.2 → 5.15.3

package/dist/tests/tests/leverage.test.js

@@ -0,0 +1,1276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const setup_utils_1 = require("./runner/setup_utils");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const assert = __importStar(require("assert"));
+const src_1 = require("../src");
+const lib_1 = require("../src/lib");
+const leverage_utils_1 = require("./runner/leverage_utils");
+const assert_1 = require("./runner/assert");
+const utils_1 = require("../src/classes/utils");
+const setup_operations_1 = require("./runner/setup_operations");
+const types_1 = require("../src/@codegen/klend/types");
+const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
+const bn_js_1 = __importDefault(require("bn.js"));
+const tx_1 = require("./runner/tx");
+const consts_1 = require("../src/utils/consts");
+// TODO: test with sol and wrapped sol
+// - [x] test when the one of the tokens is 0 entirely
+// - [x] test when either of the tokens is SOL and borrow/deposit is the other one, basically all 4 permutations
+// - test when the user already has a wrapped sol account
+// - test with farms
+describe('Leverage SDK tests', function () {
+    it('basics: swap', async function () {
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                ['MSOL', '10'],
+                ['USDC', '10'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    ['MSOL', '10'],
+                    ['USDC', '10'],
+                ],
+            },
+        });
+        {
+            const usdcBalance = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, 'USDC');
+            const msolBalance = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, 'MSOL');
+            assert.equal(msolBalance, 10);
+            assert.equal(usdcBalance, 10);
+        }
+        // Swap 5 msol to 20 usdc
+        await (0, setup_utils_1.swapLocal)(env, new decimal_js_1.default(5), new decimal_js_1.default(20), kaminoMarket.getReserveBySymbol('MSOL').getLiquidityMint(), kaminoMarket.getReserveBySymbol('USDC').getLiquidityMint(), borrower.owner);
+        {
+            const usdcBalance = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, 'USDC');
+            const msolBalance = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, 'MSOL');
+            assert.equal(msolBalance, 5);
+            assert.equal(usdcBalance, 30);
+        }
+    });
+    it('basics: swap_from_and_into_SOL', async function () {
+        const { env, kaminoMarket, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                ['SOL', '0'],
+                ['USDC', '0'],
+            ],
+            isScopeOracleSetup: true,
+        });
+        const borrower = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            ['SOL', '20'],
+            ['USDC', '20'],
+        ], scope, null, true);
+        {
+            const usdcBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'USDC');
+            const solBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'SOL', true);
+            console.log('SOL BALANCE', solBalance);
+            assert.equal(solBalance, 20);
+            assert.equal(usdcBalance, 20);
+        }
+        // Swap 5 sol to 20 usdc
+        const usdcMint = kaminoMarket.getReserveBySymbol('USDC').getLiquidityMint();
+        await (0, setup_utils_1.swapLocal)(env, new decimal_js_1.default(5), new decimal_js_1.default(20), consts_1.WRAPPED_SOL_MINT, usdcMint, borrower);
+        {
+            const solBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'SOL', true);
+            const usdcBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'USDC');
+            assert.equal(solBalance, 15);
+            assert.equal(usdcBalance, 40);
+        }
+        console.log('Swapping back into SOL');
+        // Swap 1 usdc to 1 sol
+        await (0, setup_utils_1.swapLocal)(env, new decimal_js_1.default(1), new decimal_js_1.default(1), usdcMint, consts_1.WRAPPED_SOL_MINT, borrower);
+        {
+            const solBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'SOL', true);
+            const usdcBalance = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, 'USDC');
+            assert.equal(solBalance, 16);
+            assert.equal(usdcBalance, 39);
+        }
+    });
+    it('deposit_first_time_with_leverage_debt_token_simple_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = debtToken;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '10'],
+                    [debtToken, '10'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        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);
+    });
+    it('deposit_first_time_with_leverage_debt_token_simple_no_balance_other_token_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = debtToken;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[debtToken, '10']],
+            },
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 0.01, (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);
+    });
+    it('deposit_first_time_with_leverage_debt_token_simple_no_balance_other_token_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const inputToken = debtToken;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[debtToken, '10']],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        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);
+    });
+    it('deposit_first_time_with_leverage_coll_token_simple_no_balance_other_token_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = 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'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '10']],
+            },
+        });
+        console.log('Depositing with leverage ===');
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        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());
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceBeforeDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+    });
+    it('deposit_first_time_with_leverage_coll_token_simple_no_balance_other_token_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const inputToken = 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, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '20']],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        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());
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceBeforeDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+    });
+    it('deposit_first_time_with_leverage_coll_token_simple_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const inputToken = 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'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '10'],
+                    [debtToken, '10'],
+                ],
+            },
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        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, targetLeverage.toNumber(), 0.001);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit - depositAmount.toNumber(), 0.1);
+    });
+    it('deposit_first_time_with_leverage_debt_token_simple_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const inputToken = debtToken;
+        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'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '10'],
+                    [debtToken, '10'],
+                ],
+            },
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        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, targetLeverage.toNumber(), 0.001);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            depositAmount,
+        }));
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmount.toNumber());
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit, 0.1);
+    });
+    it('deposit_first_time_with_leverage_coll_token_simple', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = collToken;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '10'],
+                    [debtToken, '10'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        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);
+    });
+    // TODO marius assert net value
+    it('deposit_first_time_with_leverage_debt_token_deposit_again_same_leverage', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = debtToken;
+        const getPrice = (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b);
+        const slippagePct = 0.01;
+        const [depositAmountFirst, depositAmountSecond] = [new decimal_js_1.default(5), new decimal_js_1.default(3)];
+        const targetLeverage = new decimal_js_1.default(3);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmountFirst, targetLeverage, slippagePct, getPrice, undefined);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, _ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmountSecond, new decimal_js_1.default(leverage.toString()), slippagePct, getPrice, undefined);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            console.log('obligation', obligation.refreshedStats);
+            console.log('obligation leverage', obligation.refreshedStats.leverage);
+            const [leverage, _ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+            (0, assert_1.assertFuzzyEq)(leverage, targetLeverage.toNumber(), 0.01);
+        }
+        const collBalanceAfterSecondDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterSecondDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances After deposit', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterSecondDeposit,
+            debtBalanceAfterSecondDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmountFirst.toNumber());
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterSecondDeposit, collBalanceBeforeDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterSecondDeposit, debtBalanceBeforeDeposit - depositAmountFirst.toNumber() - depositAmountSecond.toNumber());
+    });
+    it('deposit_first_time_with_leverage_coll_token_deposit_again_same_leverage', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = collToken;
+        const depositAmount = new decimal_js_1.default(5);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, new decimal_js_1.default(3), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue, totalBorrow, totalDeposit] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+            obligation.refreshedStats.userTotalBorrow,
+            obligation.refreshedStats.userTotalDeposit,
+        ];
+        const collTokenMint = kaminoMarket.getExistingReserveBySymbol(collToken).getLiquidityMint();
+        const usdcMint = kaminoMarket.getExistingReserveBySymbol('USDC').getLiquidityMint();
+        const collPrice = await (0, leverage_utils_1.getPriceMock)(kaminoMarket, collTokenMint, usdcMint);
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        console.log('First time: totalBorrow: ', totalBorrow);
+        console.log('First time: totalDeposit: ', totalDeposit);
+        console.log('First time: netCalculated: ', depositAmount.mul(collPrice));
+        console.log('First time: collPrice: ', collPrice);
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        (0, assert_1.assertFuzzyEq)(netValue, depositAmount.mul(collPrice), 0.1);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(leverage.toString()), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        }
+    });
+    // TODO test with more coll types, decimal variations
+    it('deposit_first_time_with_leverage_coll_token_then_withdraw_simple_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+        });
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 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, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, new decimal_js_1.default(1), slippagePct, false, (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, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        }
+    });
+    it('deposit_first_time_with_leverage_coll_token_zero_balance_other_then_withdraw_simple_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        const withdrawAmount = new decimal_js_1.default(1);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '20']],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, withdrawAmount, slippagePct, false, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        }
+        const collBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterWithdraw,
+            debtBalanceAfterWithdraw,
+            withdrawAmount,
+            diff: collBalanceAfterWithdraw - withdrawAmount.toNumber(),
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceBeforeDeposit, collBalanceAfterDeposit + depositAmount.toNumber(), 0.5);
+        (0, assert_1.assertFuzzyEq)(debtBalanceBeforeDeposit, debtBalanceAfterDeposit, 0.001);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceAfterWithdraw - withdrawAmount.toNumber(), 0.1);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceAfterWithdraw, 0.001);
+    });
+    it('deposit_first_time_with_leverage_debt_token_then_withdraw_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const [inputToken, withdrawToken] = [debtToken, debtToken];
+        const slippagePct = 0.01;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        const withdrawAmount = new decimal_js_1.default(1);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmount.toNumber());
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, withdrawAmount, slippagePct, false, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        const collBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        }
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterWithdraw,
+            debtBalanceAfterWithdraw,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterWithdraw, collBalanceAfterDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterWithdraw, debtBalanceAfterDeposit + withdrawAmount.toNumber(), 0.01);
+    });
+    it('short: deposit_first_time_with_leverage_debt_token_then_withdraw_non_sol', async function () {
+        const [collToken, debtToken] = ['USDC', 'SOL'];
+        const [inputToken, withdrawToken] = [debtToken, debtToken];
+        const slippagePct = 0.01;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        const withdrawAmount = new decimal_js_1.default(1);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[debtToken, '20']],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            depositAmount,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmount.toNumber(), 0.5);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, withdrawAmount, slippagePct, false, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        }
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterWithdraw,
+            debtBalanceAfterWithdraw,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterWithdraw, collBalanceAfterDeposit);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterWithdraw, debtBalanceAfterDeposit + withdrawAmount.toNumber(), 0.01);
+    });
+    it('deposit_first_time_with_leverage_coll_token_then_close_position', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        const closePosition = true;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit - depositAmount.toNumber());
+        (0, assert_1.assertFuzzyEq)(debtBalanceBeforeDeposit, debtBalanceAfterDeposit);
+        (0, assert_1.assertFuzzyEq)(leverage, targetLeverage.toNumber(), 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, new decimal_js_1.default(1), slippagePct, closePosition, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            assert.ok(obligation === undefined);
+        }
+        const collBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterWithdraw,
+            debtBalanceAfterWithdraw,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceBeforeDeposit, collBalanceAfterWithdraw, 0.2);
+        (0, assert_1.assertFuzzyEq)(debtBalanceBeforeDeposit, debtBalanceAfterWithdraw, 0.2);
+    });
+    it('deposit_first_time_with_leverage_coll_token_sol_then_close_position', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        const closePosition = true;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '20']],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', leverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            depositAmount,
+            diff: collBalanceBeforeDeposit - depositAmount.toNumber(),
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit - depositAmount.toNumber(), 0.5);
+        (0, assert_1.assertFuzzyEq)(debtBalanceBeforeDeposit, debtBalanceAfterDeposit);
+        (0, assert_1.assertFuzzyEq)(leverage, targetLeverage.toNumber(), 0.001);
+        console.log('Withdrawing with leverage ===', withdrawToken);
+        await (0, leverage_utils_1.withdrawLeverageTestAdapter)(env, borrower.owner, kaminoMarket, withdrawToken, collToken, debtToken, new decimal_js_1.default(1), slippagePct, closePosition, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            assert.ok(obligation === undefined);
+        }
+        const collBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterWithdraw = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterWithdraw,
+            debtBalanceAfterWithdraw,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceBeforeDeposit, collBalanceAfterWithdraw, 0.03);
+        // TODO we could improve the accuracy here
+        (0, assert_1.assertFuzzyEq)(debtBalanceBeforeDeposit, debtBalanceAfterWithdraw, 0.2);
+    });
+    it('deposit_first_time_with_leverage_debt_token_adjust_up_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const [inputToken, withdrawToken] = [debtToken, debtToken];
+        const slippagePct = 0.01;
+        const targetLeverage = new decimal_js_1.default(2);
+        const depositAmount = new decimal_js_1.default(5);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [initialLeverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', initialLeverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        (0, assert_1.assertFuzzyEq)(initialLeverage, targetLeverage, 0.001);
+        assert.equal(collBalanceAfterDeposit, collBalanceBeforeDeposit);
+        assert.equal(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmount.toNumber());
+        console.log('Adjusting with leverage up ===', withdrawToken);
+        await (0, leverage_utils_1.adjustLeverageTestAdapter)(env, borrower.owner, kaminoMarket, collToken, debtToken, slippagePct, obligation.getDeposits()[0].amount, obligation.getBorrows()[0].amount, initialLeverage.add(1), (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, initialLeverage.add(1), 0.001);
+        }
+        const collBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterLeverage,
+            debtBalanceAfterLeverage,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceAfterLeverage);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceAfterLeverage);
+    });
+    it('deposit_first_time_with_leverage_debt_token_adjust_down_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const [inputToken, withdrawToken] = [debtToken, debtToken];
+        const slippagePct = 0.01;
+        const targetLeverage = new decimal_js_1.default(3);
+        const depositAmount = new decimal_js_1.default(5);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        const debtTokenMint = kaminoMarket.getExistingReserveBySymbol(debtToken).getLiquidityMint();
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        const usdcMint = kaminoMarket.getExistingReserveBySymbol('USDC').getLiquidityMint();
+        const debtPrice = await (0, leverage_utils_1.getPriceMock)(kaminoMarket, debtTokenMint, usdcMint);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances After deposit', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        assert.equal(collBalanceAfterDeposit, collBalanceBeforeDeposit);
+        assert.equal(debtBalanceAfterDeposit, debtBalanceBeforeDeposit - depositAmount.toNumber());
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [initialLeverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', initialLeverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        console.log('First time: depositAmount.toNumber() * debtPrice: ', depositAmount.toNumber() * debtPrice);
+        (0, assert_1.assertFuzzyEq)(initialLeverage, targetLeverage.toNumber(), 0.001);
+        (0, assert_1.assertFuzzyEq)(netValue, depositAmount.toNumber() * debtPrice, 0.1);
+        console.log('Adjusting with leverage down ===', withdrawToken);
+        await (0, leverage_utils_1.adjustLeverageTestAdapter)(env, borrower.owner, kaminoMarket, collToken, debtToken, slippagePct, obligation.getDeposits()[0].amount, obligation.getBorrows()[0].amount, initialLeverage.sub(1), (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        {
+            const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+            const [leverage, ltv, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('Second time: netValue: ', netValue);
+            console.log('Second time: depositAmount.toNumber() * debtPrice: ', depositAmount.toNumber() * debtPrice);
+            (0, assert_1.assertFuzzyEq)(leverage, initialLeverage.sub(1), 0.001);
+            (0, assert_1.assertFuzzyEq)(netValue, depositAmount.toNumber() * debtPrice, 0.1);
+        }
+        const collBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterLeverage,
+            debtBalanceAfterLeverage,
+        }));
+        assert.equal(collBalanceAfterDeposit, collBalanceAfterLeverage);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceAfterLeverage);
+    });
+    it('deposit_first_time_with_leverage_coll_token_adjust_up_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        const targetLeverage = new decimal_js_1.default(2);
+        const depositAmount = new decimal_js_1.default(5);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '20']],
+            },
+            isScopeOracleSetup: true,
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [initialLeverage, ltv, firstTimeNetValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', initialLeverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', firstTimeNetValue);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            diff: collBalanceBeforeDeposit - depositAmount.toNumber(),
+        }));
+        (0, assert_1.assertFuzzyEq)(initialLeverage, targetLeverage, 0.001);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit - depositAmount.toNumber(), 0.1);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit);
+        console.log('Adjusting with leverage up ===', withdrawToken);
+        await (0, leverage_utils_1.adjustLeverageTestAdapter)(env, borrower.owner, kaminoMarket, collToken, debtToken, slippagePct, obligation.getDeposits()[0].amount, obligation.getBorrows()[0].amount, initialLeverage.add(1), (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const obligationReloaded = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [secondTimeLeverage, secondTimeLtv, secondTimeNetValue] = [
+            obligationReloaded.refreshedStats.leverage,
+            obligationReloaded.loanToValue(),
+            obligationReloaded.refreshedStats.netAccountValue,
+        ];
+        console.log('Second time leverage: ', secondTimeLeverage);
+        console.log('Second time ltv: ', secondTimeLtv.toNumber());
+        console.log('Second time: netValue: ', secondTimeNetValue);
+        console.log('Second time: netValueDiffs: ', firstTimeNetValue, secondTimeNetValue);
+        (0, assert_1.assertFuzzyEq)(secondTimeLeverage, initialLeverage.add(1), 0.001);
+        (0, assert_1.assertFuzzyEq)(firstTimeNetValue, secondTimeNetValue, 0.02);
+        const collBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterLeverage,
+            debtBalanceAfterLeverage,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceAfterLeverage);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceAfterLeverage);
+    });
+    it('deposit_first_time_with_leverage_coll_token_adjust_down_sol', async function () {
+        const [collToken, debtToken] = ['SOL', 'USDC'];
+        const [inputToken, withdrawToken] = [collToken, collToken];
+        const slippagePct = 0.01;
+        const targetLeverage = new decimal_js_1.default(2);
+        const depositAmount = new decimal_js_1.default(5);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [[collToken, '20']],
+            },
+        });
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Depositing with leverage ===', inputToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), undefined);
+        await kaminoMarket.reload();
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [initialLeverage, ltv, netValue] = [
+            obligation.refreshedStats.leverage,
+            obligation.loanToValue(),
+            obligation.refreshedStats.netAccountValue,
+        ];
+        console.log('First time: leverage: ', initialLeverage);
+        console.log('First time: ltv: ', ltv.toNumber());
+        console.log('First time: netValue: ', netValue);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            diff: collBalanceBeforeDeposit - depositAmount.toNumber(),
+        }));
+        (0, assert_1.assertFuzzyEq)(initialLeverage, targetLeverage, 0.001);
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceBeforeDeposit - depositAmount.toNumber(), 0.1);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceBeforeDeposit);
+        console.log('Adjusting with leverage down ===', withdrawToken);
+        await (0, leverage_utils_1.adjustLeverageTestAdapter)(env, borrower.owner, kaminoMarket, collToken, debtToken, slippagePct, obligation.getDeposits()[0].amount, obligation.getBorrows()[0].amount, initialLeverage.sub(1), (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, netValue] = [
+                obligation.refreshedStats.leverage,
+                obligation.loanToValue(),
+                obligation.refreshedStats.netAccountValue,
+            ];
+            console.log('Second time leverage: ', leverage);
+            console.log('Second time ltv: ', ltv.toNumber());
+            console.log('First time: netValue: ', netValue);
+            (0, assert_1.assertFuzzyEq)(leverage, initialLeverage.sub(1), 0.001);
+        }
+        const collBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, collToken);
+        const debtBalanceAfterLeverage = await (0, setup_utils_1.balance)(env, borrower.owner.address, kaminoMarket, debtToken);
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            debtBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceAfterDeposit,
+            collBalanceAfterLeverage,
+            debtBalanceAfterLeverage,
+        }));
+        (0, assert_1.assertFuzzyEq)(collBalanceAfterDeposit, collBalanceAfterLeverage);
+        (0, assert_1.assertFuzzyEq)(debtBalanceAfterDeposit, debtBalanceAfterLeverage);
+    });
+    it('emode_deposit_first_time_with_leverage_coll_token_simple_no_balance_other_token_non_sol', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = collToken;
+        const depositAmount = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(8);
+        const slippagePct = 0.01;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, scope } = await (0, setup_utils_1.setupTestMarket)({
+            marketConfig: { elevationGroups: [{ maxLtv: 90, liquidationLtv: 95 }] },
+            reserves: [
+                [collToken, '1000.05', { elevationGroups: [{ id: 1 }] }],
+                [debtToken, '1000.05', { elevationGroups: [{ id: 1, isDebt: true }] }],
+            ],
+            isScopeOracleSetup: true,
+        });
+        const collReserve = kaminoMarket.getReserveBySymbol(collToken);
+        await (0, setup_operations_1.updateReserveSingleValue)(env, collReserve, new types_1.UpdateConfigMode.UpdateBorrowLimitsInElevationGroupAgainstThisReserve(), new Array(32).fill(new bn_js_1.default(lib_1.U64_MAX)));
+        console.log('Creating user ===');
+        const borrower = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
+            [collToken, '10'],
+            [debtToken, '0'],
+        ]);
+        console.log('Depositing with leverage ===');
+        const collBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, collToken);
+        const debtBalanceBeforeDeposit = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, debtToken);
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower, kaminoMarket, inputToken, collToken, debtToken, depositAmount, targetLeverage, slippagePct, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const collBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, collToken);
+        const debtBalanceAfterDeposit = await (0, setup_utils_1.balance)(env, borrower.address, kaminoMarket, debtToken);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.address))[0];
+        const [leverage, ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+        console.log('leverage: ', leverage);
+        console.log('ltv: ', ltv.toNumber());
+        console.log('Balances', (0, lib_1.toJson)({
+            collBalanceBeforeDeposit,
+            collBalanceAfterDeposit,
+            debtBalanceBeforeDeposit,
+            debtBalanceAfterDeposit,
+        }));
+        (0, assert_1.assertFuzzyEq)(leverage, targetLeverage.toNumber(), 0.006);
+    });
+    it('deposit_first_time_with_leverage_debt_token_check_max_borrowable', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = debtToken;
+        const getPrice = (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b);
+        const slippagePct = 0.01;
+        const depositAmountFirst = new decimal_js_1.default(5);
+        const targetLeverage = new decimal_js_1.default(3);
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '20'],
+                    [debtToken, '20'],
+                ],
+            },
+        });
+        const maxBorrowableNoObligaton = await kaminoMarket.getMaxLeverageBorrowableAmount(kaminoMarket.getReserveBySymbol(collToken), kaminoMarket.getReserveBySymbol(debtToken), await env.c.rpc.getSlot().send(), false);
+        console.log('Max borrowable no obligation ===', maxBorrowableNoObligaton);
+        (0, assert_1.assertFuzzyEq)(maxBorrowableNoObligaton, (0, kliquidity_sdk_1.collToLamportsDecimal)(new decimal_js_1.default(1000.15), // + MIN_INITIAL_DEPOSIT
+        kaminoMarket.getReserveBySymbol(debtToken).state.liquidity.mintDecimals.toNumber()));
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, depositAmountFirst, targetLeverage, slippagePct, getPrice, undefined);
+        const obligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const [leverage, _ltv] = [obligation.refreshedStats.leverage, obligation.loanToValue()];
+        (0, assert_1.assertFuzzyEq)(leverage, 3, 0.001);
+        const maxBorrowableWithObligation = await kaminoMarket.getMaxLeverageBorrowableAmount(kaminoMarket.getReserveBySymbol(collToken), kaminoMarket.getReserveBySymbol(debtToken), await env.c.rpc.getSlot().send(), false, obligation);
+        console.log('Max borrowable with obligation ===', maxBorrowableWithObligation);
+        (0, assert_1.assertFuzzyEq)((0, utils_1.lamportsToNumberDecimal)(maxBorrowableWithObligation, kaminoMarket.getReserveBySymbol(debtToken).state.liquidity.mintDecimals.toNumber()), new decimal_js_1.default(1.24), 0.01);
+    });
+    it('getAllUserObligationsForReserve_test', async function () {
+        const [collToken, debtToken] = ['MSOL', 'USDC'];
+        const inputToken = debtToken;
+        console.log('Setting up market ===');
+        const { env, kaminoMarket, borrower, scope } = await (0, setup_utils_1.setupTestMarket)({
+            reserves: [
+                [collToken, '1000.05'],
+                [debtToken, '1000.05'],
+            ],
+            loan: {
+                deposits: [],
+                borrows: [],
+                additionalBalances: [
+                    [collToken, '40'],
+                    [debtToken, '10'],
+                ],
+            },
+            isScopeOracleSetup: true,
+        });
+        console.log('Depositing with leverage ===');
+        await (0, leverage_utils_1.depositLeverageTestAdapter)(env, borrower.owner, kaminoMarket, inputToken, collToken, debtToken, new decimal_js_1.default(5), new decimal_js_1.default(3), 0.01, (a, b) => (0, leverage_utils_1.getPriceMock)(kaminoMarket, a, b), scope);
+        const multiplyObligation = (await kaminoMarket.getUserObligationsByTag(src_1.MultiplyObligation.tag, borrower.owner.address))[0];
+        const kaminoAction = await lib_1.KaminoAction.buildDepositTxns(kaminoMarket, new bn_js_1.default(50), kaminoMarket.getReserveBySymbol(collToken)?.getLiquidityMint(), borrower.owner, new lib_1.VanillaObligation(lib_1.PROGRAM_ID), env.useV2Ixs, { scope: scope, scopeFeed: env.testCase });
+        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, lib_1.KaminoAction.actionToIxs(kaminoAction), [], [], 'deposit');
+        const vanillaObligation = await kaminoMarket.getObligationByWallet(borrower.owner.address, new lib_1.VanillaObligation(lib_1.PROGRAM_ID));
+        const obligationsForCollMint = await kaminoMarket.getAllUserObligationsForReserve(borrower.owner.address, kaminoMarket.getReserveBySymbol(collToken)?.address);
+        assert.equal(obligationsForCollMint.length, 2);
+        // assert one of them is multiply and the other one is the vanilla
+        assert.ok((obligationsForCollMint[0].obligationAddress === vanillaObligation?.obligationAddress ||
+            obligationsForCollMint[1].obligationAddress === vanillaObligation?.obligationAddress) &&
+            (obligationsForCollMint[0].obligationAddress === multiplyObligation?.obligationAddress ||
+                obligationsForCollMint[1].obligationAddress === multiplyObligation?.obligationAddress));
+        const obligationsForDebtMint = await kaminoMarket.getAllUserObligationsForReserve(borrower.owner.address, kaminoMarket.getReserveBySymbol(debtToken)?.address);
+        assert.equal(obligationsForDebtMint.length, 1);
+        assert.ok(obligationsForDebtMint[0].obligationAddress === multiplyObligation?.obligationAddress);
+    });
+});
+//# sourceMappingURL=leverage.test.js.map