@kamino-finance/klend-sdk 5.15.2 → 5.15.3

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

@@ -0,0 +1,602 @@
+"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