@kamino-finance/klend-sdk 5.15.3 → 6.0.0

package/dist/tests/tests/obligation_orders.test.js

@@ -1,602 +0,0 @@
-"use strict";
-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 chai_1 = require("chai");
-const src_1 = require("../src");
-const decimal_js_1 = __importDefault(require("decimal.js"));
-const assert_1 = require("./runner/assert");
-const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
-const setup_operations_1 = require("./runner/setup_operations");
-const types_1 = require("../src/@codegen/klend/types");
-const obligationOrder_1 = require("../src/classes/obligationOrder");
-const fraction_1 = require("../src/classes/fraction");
-const custom_1 = require("../src/@codegen/klend/errors/custom");
-const tx_1 = require("./runner/tx");
-describe('obligation_order', function () {
-    it('can_be_created_updated_cancelled_on_obligation', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['SOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // No orders by default:
-        (0, chai_1.expect)(obligation.getActiveOrders()).deep.eq([]);
-        // Create orders[1]:
-        const order1 = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(fraction_1.Fraction.fromPercent(24).toDecimal()), new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(49)), fraction_1.Fraction.fromBps(10).toDecimal());
-        const createOrder1Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order1.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrder1Ixn], [], [], 'CreateOrder[1]');
-        // Reload obligation and assert that just orders[1] is there:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, chai_1.expect)(obligation.getOrders()).deep.eq([null, order1]);
-        // Create orders[0]:
-        const order0 = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(fraction_1.Fraction.fromPercent(24).toDecimal()), new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(49)), fraction_1.Fraction.fromBps(10).toDecimal());
-        const createOrder0Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order0.atIndex(0));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrder0Ixn], [], [], 'CreateOrder[0]');
-        // Reload obligation and assert that 2 orders are there:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, chai_1.expect)(obligation.getOrders()).deep.eq([order0, order1]);
-        // Update orders[1] (overwrite, really):
-        const updatedOrder1 = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(fraction_1.Fraction.fromPercent(24).toDecimal()), new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(49)), fraction_1.Fraction.fromBps(10).toDecimal());
-        const updateOrder1Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, updatedOrder1.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [updateOrder1Ixn], [], [], 'UpdateOrder[1]');
-        // Reload obligation and assert that orders[1] is updated:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, chai_1.expect)(obligation.getOrders()).deep.eq([order0, updatedOrder1]);
-        // Cancel orders[0] (overwrite with null state, really):
-        const cancelOrder0Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, obligationOrder_1.ObligationOrderAtIndex.empty(0));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [cancelOrder0Ixn], [], [], 'UpdateOrder[1]');
-        // Reload obligation and assert that we only have orders[1] there:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, chai_1.expect)(obligation.getOrders()).deep.eq([null, updatedOrder1]);
-    });
-    it('can_use_sdk_methods_to_evaluate_orders_on_single_obligation', async function () {
-        const { kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000', { liquidationThreshold: 80 }],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['SOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        const sol = kaminoMarket.getReserveMintBySymbol('SOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        const obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // Note: above we created the obligation on-chain because it was easiest to just use the existing helper. The orders
-        // we test below are only created in memory (i.e. not set on obligation) but it does not matter to their logic.
-        // LTV < X condition met, can consume entire amount-based order
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(0.26), new obligationOrder_1.DeleverageDebtAmount(40_000000), // less than debt amount (50 USDC)
-            fraction_1.Fraction.fromBps(50).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(40_000000), // limited by order size
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_010_000000), // 2 SOL + 0.5% bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(50).toDecimal(),
-            });
-        }
-        // LTV < X condition met, can consume entire debt amount
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(0.99), new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(60000000)), // more than debt amount (50 USDC)
-            fraction_1.Fraction.fromBps(300).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // limited by debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_575_000000), // 2 SOL + 3% bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(300).toDecimal(),
-            });
-        }
-        // LTV < X condition not met
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(0.21), new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(40000000)), fraction_1.Fraction.fromBps(50).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).eq(undefined);
-        }
-        // LTV > X condition met, can consume "repay all" order
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.24), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(100).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // entire debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_525_000000), // 2 SOL + 1% bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(100).toDecimal(),
-            });
-        }
-        // price ratio < X condition met, can consume "repay all" order
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioBelow(0.051), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(100).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // entire debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_525_000000), // 2 SOL + 1% bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(100).toDecimal(),
-            });
-        }
-        // price ratio > X condition not met
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioAbove(0.051), new obligationOrder_1.DeleverageDebtAmount(30_000000), fraction_1.Fraction.fromBps(100).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).eq(undefined);
-        }
-        // LTV > X condition barely-met, gets ~minimum bonus
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.24), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(10).toDecimal(), // min bonus 0.1%
-            fraction_1.Fraction.fromBps(100).toDecimal() // max bonus 1%
-            );
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // entire debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_502_901786), // 2 SOL + ~0.1% bonus (a true minimum would be 2_502_500000, but we are slightly above threshold)
-                },
-                bonusRate: new decimal_js_1.default('0.00116071428571428573844793412967695595788'), // the ~0.1% mentioned above
-            });
-        }
-        // price ratio < X condition exceeded by huge margin, gets ~maximum bonus
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioBelow(69), // in our SOL = $20 set-up, the USDC/SOL price ratio is 0.05, far lower than 69
-            new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(10).toDecimal(), // min bonus 0.1%
-            fraction_1.Fraction.fromBps(100).toDecimal() // max bonus 1%
-            );
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // entire debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_524_983696), // 2 SOL + ~1% bonus (a true maximum would be 2_525_000000, but SOL price didn't go all the way to 0 [yet])
-                },
-                bonusRate: new decimal_js_1.default('0.009993478260869565425422360497357796861171'), // the ~1% mentioned above
-            });
-        }
-        // LTV > X condition exceeded by considerable margin, gets appropriately interpolated bonus
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.1), // our set-up does LTV=25%, with liquidation at 80%. We are here: 10% -- 25% ---------- 80% (15%/70% = ~0.2 of the way to liquidation)
-            new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(200).toDecimal(), // min bonus 2%
-            fraction_1.Fraction.fromBps(700).toDecimal() // max bonus 7%.
-            );
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: usdc,
-                    amount: new decimal_js_1.default(50_000000), // entire debt amount (50 USDC)
-                },
-                withdraw: {
-                    mint: sol,
-                    amount: new decimal_js_1.default(2_576_785714), // This is 2.5 SOL + ~3% bonus (since we go ~0.2 of the way from min bonus 2% to max bonus 7%)
-                },
-                bonusRate: new decimal_js_1.default('0.03071428571428571455335733629356452313783'), // the ~3% mentioned above
-            });
-        }
-    });
-    it('can_use_sdk_methods_to_evaluate_orders_on_multi_obligation', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000', { loanToValuePct: 81 }],
-                ['USDC', '1000', { loanToValuePct: 81 }],
-                ['JITOSOL', '1000', { loanToValuePct: 81 }],
-                ['MSOL', '1000', { loanToValuePct: 81 }],
-            ],
-            loan: {
-                deposits: [
-                    ['SOL', '3'],
-                    ['JITOSOL', '11'],
-                ], // 280 USD
-                borrows: [
-                    ['USDC', '12'],
-                    ['MSOL', '5'],
-                ], // 112 USD -> 40% LTV
-            },
-        });
-        const jitosol = kaminoMarket.getReserveMintBySymbol('JITOSOL');
-        const msol = kaminoMarket.getReserveMintBySymbol('MSOL');
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // Note: above we created the obligation on-chain because it was easiest to just use the existing helper. The orders
-        // we test below are only created in memory (i.e. not set on obligation) but it does not matter to their logic.
-        // LTV < X condition met, finds max available execution based on borrow and deposit market values
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(0.400000001), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(100).toDecimal());
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: msol, // there is more MSOL debt value than USDC, so this one gives max possible execution of the order
-                    amount: new decimal_js_1.default(5_000000), // all 5 MSOL can be repaid
-                },
-                withdraw: {
-                    mint: jitosol, // picking SOL would only allow repaying ~3 MSOL (because there is 3 SOL deposit available), hence JITOSOL is better
-                    amount: new decimal_js_1.default(5_050000), // 5 JITOSOL + 1% bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(100).toDecimal(),
-            });
-        }
-        // Let's modify the obligation itself to show another interesting case of computation; it now becomes:
-        // deposits: [['SOL', '3'], ['JITOSOL', '4']], // 140 USD
-        // borrows: [['USDC', '12'], ['MSOL', '5']], // 112 USD -> 80% LTV
-        await (0, setup_utils_1.withdraw)(env, kaminoMarket, undefined, borrower.owner, 'JITOSOL', new decimal_js_1.default(7));
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // LTV > X condition met, finds max available execution taking into account limited deposits
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.01), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(0).toDecimal() // no bonus for easier computation
-            );
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: msol, // there is more MSOL debt value than USDC, so this one gives max possible execution of the order
-                    amount: new decimal_js_1.default(4_000000), // only 4 MSOL (out of 5) can be repaid, because of not enough collateral of any individual token
-                },
-                withdraw: {
-                    mint: jitosol, // picking SOL would only allow repaying ~3 MSOL (because there is 3 SOL deposit available), hence 4 JITOSOL is better
-                    amount: new decimal_js_1.default(4_000000), // all 4 JITOSOL
-                },
-                bonusRate: new decimal_js_1.default(0),
-            });
-        }
-        // LTV > X condition met, finds max available execution taking into account limited deposits AND the funds needed for bonus
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.01), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(1000).toDecimal() // large 10% bonus, to show the implications of its existence in "limited deposit" conditions
-            );
-            (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-                repay: {
-                    mint: msol, // there is more MSOL debt value than USDC, so this one gives max possible execution of the order
-                    amount: new decimal_js_1.default(3_636364), // less than 4 MSOL, because of bonus that needs to be included in the withdrawn value
-                },
-                withdraw: {
-                    mint: jitosol, // picking SOL would only allow repaying ~3 MSOL (because there is 3 SOL deposit available), hence 4 JITOSOL is better
-                    amount: new decimal_js_1.default(4_000000), // all 4 JITOSOL - this includes bonus
-                },
-                bonusRate: fraction_1.Fraction.fromBps(1000).toDecimal(),
-            });
-        }
-        // price ratio condition not valid with this obligation
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioBelow(20.01), new obligationOrder_1.DeleverageAllDebt(), fraction_1.Fraction.fromBps(100).toDecimal());
-            chai_1.assert.throws(() => order.findMaxAvailableExecution(kaminoMarket, obligation), Error, 'exactly one borrow expected, but multiple found');
-        }
-        // deleverage by amount not valid with this obligation
-        {
-            const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.01), new obligationOrder_1.DeleverageDebtAmount(30_000000), fraction_1.Fraction.fromBps(100).toDecimal());
-            chai_1.assert.throws(() => order.findMaxAvailableExecution(kaminoMarket, obligation), Error, 'exactly one borrow expected, but multiple found');
-        }
-    });
-    it('sdk_finds_max_available_execution_among_non_0_minimum_liquidation_ltv_deposits', async function () {
-        const { kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000', { loanToValuePct: 80, liquidationThreshold: 85 }], // NON-lowest liquidation LTV, cannot choose this one
-                ['USDC', '1000', { loanToValuePct: 70, liquidationThreshold: 80 }], // lowest liquidation LTV, ok to choose
-                ['JITOSOL', '1000', { loanToValuePct: 75, liquidationThreshold: 80 }], // lowest liquidation LTV, ok to choose (non-lowest max-LTV is not a problem)
-                ['PYUSD', '1000', { loanToValuePct: 0, liquidationThreshold: 0 }], // 0-LTV, NOT liquidatable
-                ['MSOL', '1000', { loanToValuePct: 60, liquidationThreshold: 70 }], // (irrelevant LTVs, this is our debt)
-            ],
-            loan: {
-                deposits: [
-                    ['SOL', '10'], // $200 - this would cover the entire debt, but cannot be chosen (NON-lowest liquidation LTV)
-                    ['USDC', '10'], // $10 - this is ok to choose, but covers only $10 of debt
-                    ['JITOSOL', '1'], // $20 - this is ok to choose, and covers $20 of debt (better than $10), should be preferred!
-                    ['PYUSD', '100'], // $100 - this would cover the entire debt, but is not liquidatable (0-LTV)
-                ],
-                borrows: [
-                    ['MSOL', '4'], // $80
-                ],
-            },
-        });
-        const jitosol = kaminoMarket.getReserveMintBySymbol('JITOSOL');
-        const msol = kaminoMarket.getReserveMintBySymbol('MSOL');
-        const obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // Note: above we created the obligation on-chain because it was easiest to just use the existing helper. The orders
-        // we test below are only created in memory (i.e. not set on obligation) but it does not matter to their logic.
-        const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvAbove(0.01), new obligationOrder_1.DeleverageAllDebt(), new decimal_js_1.default(0));
-        (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-            repay: {
-                mint: msol,
-                amount: new decimal_js_1.default(1_000000),
-            },
-            withdraw: {
-                mint: jitosol,
-                amount: new decimal_js_1.default(1_000000),
-            },
-            bonusRate: new decimal_js_1.default(0),
-        });
-    });
-    it('sdk_methods_use_same_ltv_computations_as_klend_sc_to_evaluate_orders', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000', { loanToValuePct: 70, liquidationThreshold: 80 }],
-                ['USDC', '1000', { loanToValuePct: 70, liquidationThreshold: 90, borrowRateCurve: (0, src_1.newFlat)(0) }], // we are doing exact lamport asserts and don't want accrued interest to interfere
-                ['JITOSOL', '1000', { loanToValuePct: 0, liquidationThreshold: 0 }], // we want to show that 0-LTV assets are taken into account for LTV-related computations
-            ],
-            loan: {
-                deposits: [
-                    ['SOL', '10'],
-                    ['JITOSOL', '30'],
-                ], // 800 USD (of which 600 USD come from a 0-LTV asset)
-                borrows: [['USDC', '100']], // 100 USD -> 12.5% LTV (according to SC logic, even though `ObligationStats` would say 50% LTV)
-            },
-        });
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        const sol = kaminoMarket.getReserveMintBySymbol('SOL');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        // Sanity check of the `ObligationStats` logic vs `KaminoObligation` methods used by the obligation orders' logic:
-        (0, chai_1.expect)(obligation.refreshedStats.loanToValue.toNumber()).eq(0.5); // ignores JITOSOL asset!
-        (0, chai_1.expect)(obligation.refreshedStats.liquidationLtv.toNumber()).eq(0.8); // ignores JITOSOL asset!
-        // vs:
-        (0, chai_1.expect)(obligation.loanToValue().toNumber()).eq(0.125); // same as SC
-        (0, chai_1.expect)(obligation.liquidationLtv().toNumber()).eq(0.2); // same as SC
-        const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(0.15), // This is met under SC logic, but not under `ObligationStats` logic
-        new obligationOrder_1.DeleverageAllDebt(), new decimal_js_1.default(0), fraction_1.Fraction.fromPercent(10).toDecimal() // huge spread of bonus (0-10%), for easier computation
-        );
-        // First check the obligation orders' SDK helpers, in-memory:
-        (0, chai_1.expect)(order.findMaxAvailableExecution(kaminoMarket, obligation)).deep.eq({
-            repay: {
-                mint: usdc,
-                amount: new decimal_js_1.default(100_000000), // all 100 USDC
-            },
-            withdraw: {
-                mint: sol,
-                amount: new decimal_js_1.default(5_083333333), // 5 SOL + 1.66% bonus
-            },
-            bonusRate: new decimal_js_1.default('0.01666666666666666672449078253256023648037'), // current LTV = 12.5% is 1/6 of the way from threshold = 15% towards 0
-        });
-        // And then actually set that order on on-chain obligation and try to execute it by SC:
-        const createOrderIxn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrderIxn], [], [], 'CreateOrder[1]');
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['USDC', '500']]);
-        const partialExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, kliquidity_sdk_1.U64_MAX, // we just want all of it
-        '0', usdc, sol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialExecuteAction), [], [], 'Execute');
-        // Assert the debt and collateral have changed accordingly: (under `ObligationStats` logic, this order would not have its condition met at all)
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, chai_1.expect)(obligation.getDepositByMint(sol).amount.toNumber()).eq(10_000000000 - 5_083333333); // 5 SOL withdrawn + 1.66% bonus
-        (0, chai_1.expect)(obligation.getBorrowByMint(usdc)).eq(undefined); // all USDC repaid
-    });
-    it('can_be_executed_partially_or_fully_by_liquidation_when_condition_met_on_single_obligation', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['SOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        const sol = kaminoMarket.getReserveMintBySymbol('SOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        // Just a sanity check:
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), fraction_1.Fraction.fromPercent(25).toDecimal());
-        // Create orders[1]:
-        const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioBelow(new decimal_js_1.default(24)), // SOL/USDC price is 20
-        new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(45_000000)), // 45 USDC
-        fraction_1.Fraction.fromBps(300).toDecimal());
-        const createOrderIxn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrderIxn], [], [], 'CreateOrder[1]');
-        // Liquidate:
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['USDC', '100']]);
-        const partialExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, '40000000', // the order allows to repay 45 USDC, we go for 40 USDC
-        '0', usdc, sol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialExecuteAction), [], [], 'ExecutePartial');
-        // Assert the debt and collateral have changed accordingly, and the order was partially consumed:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(sol).amount, 10_000000000 - 2_000000000 * 1.03, 3); // 2 SOL withdrawn + 3% bonus
-        (0, assert_1.assertFuzzyEq)(obligation.getBorrowByMint(usdc).amount, 50_000000 - 40_000000, 3); // 40 USDC repaid
-        (0, assert_1.assertFuzzyEq)(obligation.getOrders()[1].opportunity.parameter(), 45_000000 - 40_000000); // 40 USDC consumed
-        // The order still isn't fully consumed, let's get it all now:
-        const fullExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, kliquidity_sdk_1.U64_MAX, // we just want all of it, no matter how large is the remaining order (it is 5 USDC)
-        '0', usdc, sol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(fullExecuteAction), [], [], 'ExecuteFull');
-        // Assert the debt and collateral have changed accordingly, and the order was fully consumed:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(sol).amount, 10_000000000 - 2_250000000 * 1.03, 3); // Total 2.25 SOL withdrawn + 3% bonus
-        (0, assert_1.assertFuzzyEq)(obligation.getBorrowByMint(usdc).amount, 50_000000 - 45_000000, 3); // Total 45 USDC repaid
-        (0, chai_1.expect)(obligation.getOrders()[1]).eq(null); // when consumed, it is removed
-    });
-    it('can_be_executed_partially_or_fully_by_liquidation_when_condition_met_on_multi_obligation', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['STSOL', '1000'],
-                ['MSOL', '1000'],
-                ['JITOSOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [
-                    ['MSOL', '10'],
-                    ['JITOSOL', '5'],
-                ], // 300 USD
-                borrows: [
-                    ['USDC', '10'],
-                    ['STSOL', '7'],
-                ], // 150 USD -> 50% LTV
-            },
-        });
-        const msol = kaminoMarket.getReserveMintBySymbol('MSOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        const stsol = kaminoMarket.getReserveMintBySymbol('STSOL');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        // Just a sanity check:
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), fraction_1.Fraction.fromPercent(50).toDecimal());
-        // Create orders[1]:
-        const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.UserLtvBelow(fraction_1.Fraction.fromPercent(51).toDecimal()), new obligationOrder_1.DeleverageAllDebt(), new decimal_js_1.default(0) // no bonus here, just for easier computations (other tests assert on bonus)
-        );
-        const createOrderIxn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrderIxn], [], [], 'CreateOrder[1]');
-        // Liquidate a bit:
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [
-            ['STSOL', '10'],
-            ['USDC', '100'],
-        ]);
-        const partialUsdcExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, '2000000', // the order allows to repay all debt, we go for 2 USDC (out of 10 USDC debt)
-        '0', usdc, msol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialUsdcExecuteAction), [], [], 'ExecutePartialUSDC');
-        // Assert the debt and collateral have changed accordingly, and the order is still present:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(msol).amount, 10_000000 - 100000, 1); // 0.1 MSOL withdrawn
-        (0, assert_1.assertFuzzyEq)(obligation.getBorrowByMint(usdc).amount, 10_000000 - 2_000000, 1); // 2 USDC repaid
-        (0, chai_1.expect)(obligation.getOrders()[1]).deep.eq(order); // the "repay all" order is unchanged, because there is still debt
-        // Another liquidate - let's get all of STSOL now:
-        const fullStsolExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, kliquidity_sdk_1.U64_MAX, // we just want all of it, no matter how much there is (there is 7 STSOL)
-        '0', stsol, msol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(fullStsolExecuteAction), [], [], 'ExecuteFullSTSOL');
-        // Assert the debt and collateral have changed accordingly, and the order is still present:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(msol).amount, 9_900000 - 7_000000, 1); // Another 7 MSOL withdraw
-        (0, chai_1.expect)(obligation.getBorrowByMint(stsol)).eq(undefined); // all STSOL repaid
-        (0, chai_1.expect)(obligation.getOrders()[1]).deep.eq(order); // the "repay all" order is unchanged, because there is still debt (the USDC was only partially repaid so far)
-        // Last liquidate - let's get all of USDC now:
-        const fullUsdcExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, kliquidity_sdk_1.U64_MAX, // we just want all of it, no matter how much there is (there is 8 USDC)
-        '0', usdc, msol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(fullUsdcExecuteAction), [], [], 'ExecuteFullUSDC');
-        // Assert the debt and collateral have changed accordingly, and the order is still present:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(msol).amount, 2_900000 - 400000, 3); // Another 0.4 MSOL withdraw
-        (0, chai_1.expect)(obligation.getBorrowByMint(usdc)).eq(undefined); // all USDC repaid
-        (0, chai_1.expect)(obligation.getOrders()[1]).eq(null); // now, with all debt gone, the "infinite" order gets removed
-    });
-    it('applies_configured_deposit_reserve_order_execution_protocol_fee', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000'],
-                ['JITOSOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['JITOSOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        const jitosol = kaminoMarket.getReserveMintBySymbol('JITOSOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        // Configure a 20% protocol fee (default 0!):
-        const jitosolReserve = kaminoMarket.getReserveByMint(jitosol);
-        await (0, setup_operations_1.updateReserveSingleValue)(env, jitosolReserve, new types_1.UpdateConfigMode.UpdateProtocolOrderExecutionFee(), 20);
-        // Just a sanity check:
-        let obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), fraction_1.Fraction.fromPercent(25).toDecimal());
-        // Create orders[1]:
-        const order = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioBelow(new decimal_js_1.default(24)), // SOL/USDC price is 20
-        new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(45_000000)), // 45 USDC
-        fraction_1.Fraction.fromBps(500).toDecimal());
-        const createOrderIxn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrderIxn], [], [], 'CreateOrder[1]');
-        // Liquidate:
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['USDC', '100']]);
-        const partialExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, '10000000', // the order allows to repay 45 USDC, we go for 10 USDC for easy calculation
-        '0', usdc, jitosol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialExecuteAction), [], [], 'ExecuteWithProtocolFee');
-        // Assert the debt and collateral have changed accordingly, and the order was partially consumed:
-        obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.getDepositByMint(jitosol).amount, 10_000000 - (500000 + 25000), 3); // 0.5 SOL withdrawn + 5% bonus
-        (0, assert_1.assertFuzzyEq)(obligation.getBorrowByMint(usdc).amount, 50_000000 - 10_000000, 4); // 10 USDC repaid
-        (0, assert_1.assertFuzzyEq)(obligation.getOrders()[1].opportunity.parameter(), 45_000000 - 10_000000); // 10 USDC consumed
-        // Also, assert on the liquidator's and protocol's resulting JITOSOL balance:
-        const liquidatorJitosolBalance = await (0, setup_utils_1.balance)(env, liquidator.address, kaminoMarket, 'JITOSOL');
-        const feeVaultJitosolBalance = await (0, setup_utils_1.balance)(env, jitosolReserve.state.liquidity.feeVault, kaminoMarket, 'JITOSOL');
-        (0, assert_1.assertFuzzyEq)(liquidatorJitosolBalance, 0.5 + 0.02, 3); // above we see that bonus was 0.025, but liquidator only got 0.02...
-        (0, assert_1.assertFuzzyEq)(feeVaultJitosolBalance, 0.005, 3); // ...because the remaining part (i.e. the configured 20% of it) went towards protocol fee
-    });
-    it('cannot_be_executed_when_condition_not_met', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['SOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        const sol = kaminoMarket.getReserveMintBySymbol('SOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        // Just a sanity check:
-        const obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), fraction_1.Fraction.fromPercent(25).toDecimal());
-        // Create orders[1]:
-        const order1 = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioAbove(new decimal_js_1.default(21)), // SOL/USDC price is 20
-        new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(45_000000)), // 45 USDC
-        fraction_1.Fraction.fromBps(300).toDecimal());
-        const createOrder1Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order1.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrder1Ixn], [], [], 'CreateOrder[1]');
-        // Liquidate:
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['USDC', '100']]);
-        const partialExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, '40000000', // the order allows to repay 45 USDC, we go for 40 USDC
-        '0', usdc, sol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        try {
-            await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialExecuteAction), [], [], 'FailedExecute');
-            chai_1.assert.fail('should not succeed');
-        }
-        catch (e) {
-            (0, chai_1.expect)(e.cause.context.code).eq(custom_1.ObligationHealthy.code);
-        }
-    });
-    it('cannot_be_executed_when_disabled_on_market', async function () {
-        const { env, kaminoMarket, borrower } = await (0, setup_utils_1.setupTestMarket)({
-            reserves: [
-                ['SOL', '1000'],
-                ['USDC', '1000'],
-            ],
-            loan: {
-                deposits: [['SOL', '10']], // 200 USD
-                borrows: [['USDC', '50']], // 25% LTV
-            },
-        });
-        const sol = kaminoMarket.getReserveMintBySymbol('SOL');
-        const usdc = kaminoMarket.getReserveMintBySymbol('USDC');
-        await (0, setup_operations_1.updateLendingMarketObligationOrderFlags)(env, kaminoMarket, true);
-        // Just a sanity check:
-        const obligation = await kaminoMarket.getUserVanillaObligation(borrower.owner.address);
-        (0, assert_1.assertFuzzyEq)(obligation.loanToValue(), fraction_1.Fraction.fromPercent(25).toDecimal());
-        // Create orders[1]:
-        const order1 = new obligationOrder_1.KaminoObligationOrder(new obligationOrder_1.DebtCollPriceRatioAbove(new decimal_js_1.default(19)), // SOL/USDC price is 20
-        new obligationOrder_1.DeleverageDebtAmount(new decimal_js_1.default(45_000000)), // 45 USDC
-        fraction_1.Fraction.fromBps(300).toDecimal());
-        const createOrder1Ixn = src_1.KaminoAction.buildSetObligationOrderIxn(borrower.owner, kaminoMarket, obligation, order1.atIndex(1));
-        await (0, tx_1.sendAndConfirmTx)(env.c, borrower.owner, [createOrder1Ixn], [], [], 'CreateOrder[1]');
-        // Liquidate:
-        const liquidator = await (0, setup_utils_1.newUser)(env, kaminoMarket, [['USDC', '100']]);
-        const partialExecuteAction = await src_1.KaminoAction.buildLiquidateTxns(kaminoMarket, '40000000', // the order allows to repay 45 USDC, we go for 40 USDC
-        '0', usdc, sol, liquidator, borrower.owner.address, obligation, env.useV2Ixs);
-        try {
-            await (0, tx_1.sendAndConfirmTx)(env.c, liquidator, src_1.KaminoAction.actionToIxs(partialExecuteAction), [], [], 'FailedExecute');
-            chai_1.assert.fail('should not succeed');
-        }
-        catch (e) {
-            (0, chai_1.expect)(e.cause.context.code).deep.eq(custom_1.ObligationHealthy.code);
-        }
-    });
-});
-//# sourceMappingURL=obligation_orders.test.js.map