@curvefi/llamalend-api 1.0.2

package/test/general.test.ts

@@ -0,0 +1,216 @@
+import { assert } from "chai";
+import llamalend from "../src/index.js";
+import { getOneWayMarket, OneWayMarketTemplate } from "../src/markets/index.js";
+import { BN } from "../src/utils.js";
+
+
+const ONE_WAY_MARKETS = ['one-way-market-0'];
+
+const generalTest = (id: string) => {
+    describe(`${id} oneWayMarket general test`, function () {
+        let oneWayMarket: OneWayMarketTemplate;
+
+        before(async function () {
+            oneWayMarket = getOneWayMarket(id);
+            const maxDeposit = Number(await oneWayMarket.vault.maxDeposit()) * 0.99;
+            await oneWayMarket.vault.deposit(maxDeposit);
+        });
+
+        it('Create loan', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+
+            assert.equal(Number(initialState.collateral), 0);
+            assert.equal(Number(initialState.borrowed), 0);
+            assert.equal(Number(initialState.debt), 0);
+            assert.isAbove(Number(initialBalances.collateral), 0);
+
+            const collateralAmount = 0.5;
+            const N = 5;
+            const maxRecv = await oneWayMarket.createLoanMaxRecv(collateralAmount, N);
+            const debtAmount = (Number(maxRecv) / 2).toFixed(18);
+            const createLoanPrices = await oneWayMarket.createLoanPrices(collateralAmount, debtAmount, N);
+            const createLoanFullHealth = await oneWayMarket.createLoanHealth(collateralAmount, debtAmount, N);
+            const createLoanHealth = await oneWayMarket.createLoanHealth(collateralAmount, debtAmount, N, false);
+
+            await oneWayMarket.createLoan(collateralAmount, debtAmount, N);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.approximately(Number(createLoanPrices[0]), Number(userPrices[0]), 1e-2, 'price 0');
+            assert.approximately(Number(createLoanPrices[1]), Number(userPrices[1]), 1e-2, 'price 1');
+            assert.approximately(Number(createLoanFullHealth), Number(fullHealth), 0.1, 'full health');
+            assert.approximately(Number(createLoanHealth), Number(health), 1e-4, 'health');
+            assert.equal(Number(balances.collateral), Number(initialBalances.collateral) - Number(collateralAmount), 'wallet collateral');
+            assert.approximately(Number(balances.borrowed), BN(initialBalances.borrowed).plus(Number(debtAmount)).toNumber(), 1e-12, 'wallet borrowed');
+            assert.equal(Number(state.collateral), Number(collateralAmount), 'state collateral');
+            assert.equal(Number(state.debt), Number(debtAmount), 'state debt');
+        });
+
+        it('Borrow more', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists);
+            assert.isAbove(Number(initialBalances.collateral), 0);
+
+            const collateralAmount = 0.5;
+            const maxRecv = await oneWayMarket.borrowMoreMaxRecv(collateralAmount);
+            const debtAmount = (Number(maxRecv) / 2).toFixed(18);
+            const borrowMorePrices = await oneWayMarket.borrowMorePrices(collateralAmount, debtAmount);
+            const borrowMoreFullHealth = await oneWayMarket.borrowMoreHealth(collateralAmount, debtAmount);
+            const borrowMoreHealth = await oneWayMarket.borrowMoreHealth(collateralAmount, debtAmount, false);
+
+            await oneWayMarket.borrowMore(collateralAmount, debtAmount);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.approximately(Number(borrowMorePrices[0]), Number(userPrices[0]), 1e-2, 'price 0');
+            assert.approximately(Number(borrowMorePrices[1]), Number(userPrices[1]), 1e-2, 'price 1');
+            assert.approximately(Number(borrowMoreFullHealth), Number(fullHealth), 1e-2, 'full health');
+            assert.approximately(Number(borrowMoreHealth), Number(health), 1e-4, 'health');
+            assert.equal(Number(balances.collateral), Number(initialBalances.collateral) - Number(collateralAmount), 'wallet collateral');
+            assert.equal(balances.borrowed, BN(initialBalances.borrowed).plus(BN(debtAmount)).toString(), 'wallet borrowed');
+            assert.equal(Number(state.collateral), Number(initialState.collateral) + Number(collateralAmount), 'state collateral');
+            assert.approximately(Number(state.debt), Number(initialState.debt) + Number(debtAmount), 1e-4, 'state debt');
+        });
+
+        it('Add collateral', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists);
+            assert.isAbove(Number(initialBalances.collateral), 0);
+
+            const collateralAmount = 1;
+            const addCollateralPrices = await oneWayMarket.addCollateralPrices(collateralAmount);
+            const addCollateralFullHealth = await oneWayMarket.addCollateralHealth(collateralAmount);
+            const addCollateralHealth = await oneWayMarket.addCollateralHealth(collateralAmount, false);
+
+            await oneWayMarket.addCollateral(collateralAmount);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.approximately(Number(addCollateralPrices[0]), Number(userPrices[0]), 1e-2, 'price 0');
+            assert.approximately(Number(addCollateralPrices[1]), Number(userPrices[1]), 1e-2, 'price 1');
+            assert.approximately(Number(addCollateralFullHealth), Number(fullHealth), 1e-2, 'full health');
+            assert.approximately(Number(addCollateralHealth), Number(health), 1e-4, 'health');
+            assert.equal(Number(balances.collateral), Number(initialBalances.collateral) - Number(collateralAmount), 'wallet collateral');
+            assert.equal(Number(balances.borrowed), Number(initialBalances.borrowed), 'wallet borrowed');
+            assert.equal(Number(state.collateral), Number(initialState.collateral) + Number(collateralAmount), 'state collateral');
+            assert.approximately(Number(initialState.debt), Number(state.debt), 1e-4, 'state debt');
+        });
+
+        it('Remove collateral', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists);
+            assert.isAbove(Number(initialState.collateral), 0);
+
+            const maxRemovable = await oneWayMarket.maxRemovable();
+            const collateralAmount = (Number(maxRemovable) / 2).toFixed(oneWayMarket.collateral_token.decimals);
+            const removeCollateralPrices = await oneWayMarket.removeCollateralPrices(collateralAmount);
+            const removeCollateralFullHealth = await oneWayMarket.removeCollateralHealth(collateralAmount);
+            const removeCollateralHealth = await oneWayMarket.removeCollateralHealth(collateralAmount, false);
+
+            await oneWayMarket.removeCollateral(collateralAmount);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.approximately(Number(removeCollateralPrices[0]), Number(userPrices[0]), 1e-2, 'price 0');
+            assert.approximately(Number(removeCollateralPrices[1]), Number(userPrices[1]), 1e-2, 'price 1');
+            assert.approximately(Number(removeCollateralFullHealth), Number(fullHealth), 1e-2, 'full health');
+            assert.approximately(Number(removeCollateralHealth), Number(health), 1e-4, 'health');
+            assert.equal(Number(balances.collateral), Number(initialBalances.collateral) + Number(collateralAmount), 'wallet collateral');
+            assert.equal(Number(balances.borrowed), Number(initialBalances.borrowed), 'wallet borrowed');
+            assert.equal(state.collateral, BN(initialState.collateral).minus(BN(collateralAmount)).toString(), 'state collateral');
+            assert.approximately(Number(initialState.debt), Number(state.debt), 1e-4, 'state debt');
+        });
+
+        it('Partial repay', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+            const debtAmount = (Number(initialState.debt) / 4).toFixed(18);
+
+            assert.isTrue(loanExists);
+            assert.isAtLeast(Number(initialBalances.borrowed), Number(debtAmount));
+
+            const repayPrices = await oneWayMarket.repayPrices(debtAmount);
+            const repayFullHealth = await oneWayMarket.repayHealth(debtAmount);
+            const repayHealth = await oneWayMarket.repayHealth(debtAmount, false);
+
+            await oneWayMarket.repay(debtAmount);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.approximately(Number(repayPrices[0]), Number(userPrices[0]), 1e-2, 'price 0');
+            assert.approximately(Number(repayPrices[1]), Number(userPrices[1]), 1e-2, 'price 1');
+            assert.approximately(Number(repayFullHealth), Number(fullHealth), 1e-2, 'full health');
+            assert.approximately(Number(repayHealth), Number(health), 1e-4, 'health');
+            assert.equal(Number(balances.collateral), Number(initialBalances.collateral), 'wallet collateral');
+            assert.equal(balances.borrowed, BN(initialBalances.borrowed).minus(BN(debtAmount)).toString(), 'wallet borrowed');
+            assert.equal(Number(state.collateral), Number(initialState.collateral), 'state collateral');
+            assert.equal(Number(state.borrowed), Number(initialState.borrowed), 'state borrowed');
+            assert.approximately(Number(state.debt), Number(initialState.debt) - Number(debtAmount), 1e-4, 'state debt');
+        });
+
+        it('Full repay', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists);
+            assert.isAtLeast(Number(initialBalances.borrowed), Number(initialState.debt));
+
+            await oneWayMarket.fullRepay();
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+
+
+            assert.approximately(Number(balances.collateral), Number(initialBalances.collateral) + Number(initialState.collateral), 10**(-oneWayMarket.collateral_token.decimals), 'wallet collateral');
+            assert.approximately(Number(balances.borrowed), Number(initialBalances.borrowed) - Number(initialState.debt), 1e-3, 'wallet borrowed');
+            assert.equal(Number(state.collateral), 0, 'state collateral');
+            assert.equal(Number(state.borrowed), 0, 'state borrowed');
+            assert.equal(Number(state.debt), 0, 'state debt');
+        });
+    })
+}
+
+describe('General test', async function () {
+    this.timeout(120000);
+
+    before(async function () {
+        await llamalend.init('JsonRpc', {},{ gasPrice: 0 });
+        await llamalend.oneWayfactory.fetchMarkets();
+    });
+
+    for (const oneWayMarketId of ONE_WAY_MARKETS) {
+        generalTest(oneWayMarketId);
+    }
+})

package/test/leverageBorrowMore.test.ts

@@ -0,0 +1,245 @@
+import { assert } from "chai";
+import llamalend from "../src/index.js";
+import { getOneWayMarket, OneWayMarketTemplate } from "../src/markets/index.js";
+import { BN } from "../src/utils.js";
+
+
+const ONE_WAY_MARKETS = ['one-way-market-9'];
+
+const generalTest = (id: string) => {
+    describe(`${id} leverage borrowMore test`, function () {
+        let oneWayMarket: OneWayMarketTemplate;
+
+        before(async function () {
+            oneWayMarket = getOneWayMarket(id);
+            if (Number(await oneWayMarket.vault.totalLiquidity()) === 0) {
+                const maxDeposit = Number(await oneWayMarket.vault.maxDeposit()) * 0.7;
+                await oneWayMarket.vault.deposit(maxDeposit);
+            }
+            if (!(await oneWayMarket.userLoanExists())) {
+                const collateralAmount = 0.02;
+                const borrowedAmount = 1000;
+                const N = 10;
+                const { maxDebt } = await oneWayMarket.leverage.createLoanMaxRecv(collateralAmount, borrowedAmount, N);
+                const debtAmount = (Number(maxDebt) / 2).toFixed(oneWayMarket.borrowed_token.decimals);
+
+                await oneWayMarket.leverage.createLoanExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+                await oneWayMarket.leverage.createLoan(collateralAmount, borrowedAmount, debtAmount, N, 1);
+            }
+        });
+
+        it('Leverage borrowMore collateral only, debt too high', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0.02;
+            const borrowedAmount = 0;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) * 1.004).toFixed(oneWayMarket.borrowed_token.decimals);
+
+            try {
+                await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+                await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+                throw Error("Did not revert");
+            } catch (e) {
+                // @ts-ignore
+                assert.notEqual(e.message, "Did not revert", e.message);
+                // @ts-ignore
+                assert.isTrue(e.message.startsWith('execution reverted: "Debt too high"'), e.message);
+            }
+        });
+
+        it('Leverage borrowMore borrowed only, debt too high', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0;
+            const borrowedAmount = 1000;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) * 1.004).toFixed(oneWayMarket.borrowed_token.decimals);
+
+            try {
+                await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+                await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+                throw Error("Did not revert");
+            } catch (e) {
+                // @ts-ignore
+                assert.notEqual(e.message, "Did not revert", e.message);
+                // @ts-ignore
+                assert.isTrue(e.message.startsWith('execution reverted: "Debt too high"'), e.message);
+            }
+        });
+
+        it('Leverage borrowMore, debt too high', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0.02;
+            const borrowedAmount = 1000;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) * 1.004).toFixed(oneWayMarket.borrowed_token.decimals);
+
+            try {
+                await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+                await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+                throw Error("Did not revert");
+            } catch (e) {
+                // @ts-ignore
+                assert.notEqual(e.message, "Did not revert", e.message);
+                // @ts-ignore
+                assert.isTrue(e.message.startsWith('execution reverted: "Debt too high"'), e.message);
+            }
+        });
+
+        it('Leverage borrowMore collateral only', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0.02;
+            const borrowedAmount = 0;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) / 2).toFixed(oneWayMarket.borrowed_token.decimals);
+            const { totalCollateral } = await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+            const borrowMoreBands = await oneWayMarket.leverage.borrowMoreBands(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMorePrices = await oneWayMarket.leverage.borrowMorePrices(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreFullHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount, false);
+
+            await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userBands = await oneWayMarket.userBands();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.equal(Number(borrowMoreBands[0]), Number(userBands[0]), 'band 0');
+            assert.equal(Number(borrowMoreBands[1]), Number(userBands[1]), 'band 1');
+            assert.approximately(Number(borrowMorePrices[0]), Number(userPrices[0]), 1, 'price 0');
+            assert.approximately(Number(borrowMorePrices[1]), Number(userPrices[1]), 1, 'price 1');
+            assert.approximately(Number(borrowMoreFullHealth), Number(fullHealth), 1, 'full health');
+            assert.approximately(Number(borrowMoreHealth), Number(health), 0.3, 'health');
+            assert.equal(Number(balances.collateral), BN(initialBalances.collateral).minus(collateralAmount).toNumber(), 'wallet collateral');
+            assert.equal(Number(balances.borrowed), Number(initialBalances.borrowed) - borrowedAmount, 'wallet borrowed');
+            const collateralDiff = Number(state.collateral) - Number(initialState.collateral);
+            assert.isAtMost(Math.abs(collateralDiff - Number(totalCollateral)) / Number(totalCollateral), 0.01, 'state collateral');
+            const debtDiff = Number(state.debt) - Number(initialState.debt);
+            assert.isAtMost(Math.abs(debtDiff - Number(debtAmount)) / Number(debtAmount), 2e-6, 'state debt');
+        });
+
+        it('Leverage borrowMore borrowed only', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0;
+            const borrowedAmount = 1000;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) / 2).toFixed(oneWayMarket.borrowed_token.decimals);
+            const { totalCollateral } = await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+            const borrowMoreBands = await oneWayMarket.leverage.borrowMoreBands(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMorePrices = await oneWayMarket.leverage.borrowMorePrices(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreFullHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount, false);
+
+            await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userBands = await oneWayMarket.userBands();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.equal(Number(borrowMoreBands[0]), Number(userBands[0]), 'band 0');
+            assert.equal(Number(borrowMoreBands[1]), Number(userBands[1]), 'band 1');
+            assert.approximately(Number(borrowMorePrices[0]), Number(userPrices[0]), 1, 'price 0');
+            assert.approximately(Number(borrowMorePrices[1]), Number(userPrices[1]), 1, 'price 1');
+            assert.approximately(Number(borrowMoreFullHealth), Number(fullHealth), 1, 'full health');
+            assert.approximately(Number(borrowMoreHealth), Number(health), 0.3, 'health');
+            assert.equal(Number(balances.collateral), BN(initialBalances.collateral).minus(collateralAmount).toNumber(), 'wallet collateral');
+            assert.equal(Number(balances.borrowed), Number(initialBalances.borrowed) - borrowedAmount, 'wallet borrowed');
+            const collateralDiff = Number(state.collateral) - Number(initialState.collateral);
+            assert.isAtMost(Math.abs(collateralDiff - Number(totalCollateral)) / Number(totalCollateral), 0.01, 'state collateral');
+            const debtDiff = Number(state.debt) - Number(initialState.debt);
+            assert.isAtMost(Math.abs(debtDiff - Number(debtAmount)) / Number(debtAmount), 2e-6, 'state debt');
+        });
+
+        it('Leverage borrowMore', async function () {
+            const initialBalances = await oneWayMarket.wallet.balances();
+            const initialState = await oneWayMarket.userState();
+            const loanExists = await oneWayMarket.userLoanExists();
+
+            assert.isTrue(loanExists, "loanExists");
+            assert.isAbove(Number(initialBalances.collateral), 0, "collateral > 0");
+            assert.isAbove(Number(initialBalances.borrowed), 0, "borrowed > 0");
+
+            const collateralAmount = 0.02;
+            const borrowedAmount = 1000;
+            const { maxDebt } = await oneWayMarket.leverage.borrowMoreMaxRecv(collateralAmount, borrowedAmount);
+            const debtAmount = (Number(maxDebt) * 0.999).toFixed(oneWayMarket.borrowed_token.decimals);
+            const { totalCollateral } = await oneWayMarket.leverage.borrowMoreExpectedCollateral(collateralAmount, borrowedAmount, debtAmount, 1);
+            const borrowMoreBands = await oneWayMarket.leverage.borrowMoreBands(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMorePrices = await oneWayMarket.leverage.borrowMorePrices(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreFullHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount);
+            const borrowMoreHealth = await oneWayMarket.leverage.borrowMoreHealth(collateralAmount, borrowedAmount, debtAmount, false);
+
+            await oneWayMarket.leverage.borrowMore(collateralAmount, borrowedAmount, debtAmount,1);
+
+            const balances = await oneWayMarket.wallet.balances();
+            const state = await oneWayMarket.userState();
+            const userBands = await oneWayMarket.userBands();
+            const userPrices = await oneWayMarket.userPrices();
+            const fullHealth = await oneWayMarket.userHealth();
+            const health = await oneWayMarket.userHealth(false);
+
+            assert.equal(Number(borrowMoreBands[0]), Number(userBands[0]), 'band 0');
+            assert.equal(Number(borrowMoreBands[1]), Number(userBands[1]), 'band 1');
+            assert.approximately(Number(borrowMorePrices[0]), Number(userPrices[0]), 1, 'price 0');
+            assert.approximately(Number(borrowMorePrices[1]), Number(userPrices[1]), 1, 'price 1');
+            assert.approximately(Number(borrowMoreFullHealth), Number(fullHealth), 1, 'full health');
+            assert.approximately(Number(borrowMoreHealth), Number(health), 0.3, 'health');
+            assert.equal(Number(balances.collateral), BN(initialBalances.collateral).minus(collateralAmount).toNumber(), 'wallet collateral');
+            assert.equal(Number(balances.borrowed), Number(initialBalances.borrowed) - borrowedAmount, 'wallet borrowed');
+            const collateralDiff = Number(state.collateral) - Number(initialState.collateral);
+            assert.isAtMost(Math.abs(collateralDiff - Number(totalCollateral)) / Number(totalCollateral), 0.01, 'state collateral');
+            const debtDiff = Number(state.debt) - Number(initialState.debt);
+            assert.isAtMost(Math.abs(debtDiff - Number(debtAmount)) / Number(debtAmount), 2e-6, 'state debt');
+        });
+    })
+}
+
+describe('Leverage borrowMore test', async function () {
+    this.timeout(180000);
+
+    before(async function () {
+        await llamalend.init('JsonRpc', {},{ gasPrice: 0 });
+        await llamalend.oneWayfactory.fetchMarkets();
+    });
+
+    for (const oneWayMarketId of ONE_WAY_MARKETS) {
+        generalTest(oneWayMarketId);
+    }
+})