@gearbox-protocol/sdk 3.0.0-vfourabi.7 → 3.0.0-vfourabi.8

package/dist/esm/sdk/sdk-legacy/core/creditAccount.spec.js

@@ -0,0 +1,1777 @@
+import { describe, expect, it } from "@jest/globals";
+import { MIN_INT96, PERCENTAGE_FACTOR, PRICE_DECIMALS_POW, } from "../../constants";
+import { TokenData } from "../tokens/tokenData";
+import { toBN } from "../utils/formatter";
+import { PriceUtils } from "../utils/price";
+import { AssetUtils } from "./assets";
+import { CreditAccountData_Legacy } from "./creditAccount";
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase();
+const DAI = "0x6B175474E89094C44Da98b954EedeAC495271d0F".toLowerCase();
+const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase();
+const STETH = "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84".toLowerCase();
+const tokenDataList = {
+    [WETH]: new TokenData({
+        addr: WETH,
+        decimals: 18,
+        symbol: "WETH",
+        name: "",
+    }),
+    [DAI]: new TokenData({
+        addr: DAI,
+        decimals: 18,
+        symbol: "DAI",
+        name: "",
+    }),
+    [USDC]: new TokenData({
+        addr: USDC,
+        decimals: 6,
+        symbol: "USDC",
+        name: "",
+    }),
+    [STETH]: new TokenData({
+        addr: STETH,
+        decimals: 18,
+        symbol: "STETH",
+        name: "",
+    }),
+};
+const prices = {
+    [WETH]: toBN("1738.11830000", PRICE_DECIMALS_POW),
+    [DAI]: toBN("0.99941103", PRICE_DECIMALS_POW),
+    [USDC]: toBN("0.999", PRICE_DECIMALS_POW),
+    [STETH]: toBN("1703.87588096", PRICE_DECIMALS_POW),
+};
+const lpAPY = {
+    [STETH]: 38434,
+};
+const DAI_DECIMALS = 18;
+const WETH_DECIMALS = 18;
+const STETH_DECIMALS = 18;
+const USDC_DECIMALS = 6;
+const caWithoutLP = {
+    assets: [
+        {
+            balance: toBN("54780", DAI_DECIMALS),
+            token: DAI,
+        },
+        {
+            balance: toBN("3.5", WETH_DECIMALS),
+            token: WETH,
+        },
+    ],
+    totalValue: toBN("60860", DAI_DECIMALS),
+    debt: toBN("54780", DAI_DECIMALS),
+    borrowRate: 7712,
+    underlyingToken: DAI,
+    quotas: {
+        [WETH]: {
+            balance: toBN("173811.830000", WETH_DECIMALS),
+            token: DAI,
+        },
+    },
+    rates: {
+        [WETH]: {
+            rate: 38434n,
+            isActive: true,
+        },
+    },
+};
+const caWithLP = {
+    assets: [
+        {
+            balance: toBN("119.999999999999999997", STETH_DECIMALS),
+            token: STETH,
+        },
+        {
+            balance: toBN("3.5", WETH_DECIMALS),
+            token: WETH,
+        },
+    ],
+    totalValue: toBN("117.635897231615362429", WETH_DECIMALS),
+    debt: toBN("90.000000000000000000", WETH_DECIMALS),
+    borrowRate: 5736,
+    underlyingToken: WETH,
+    quotas: {
+        [STETH]: {
+            balance: toBN(String((1703.87588096 * 119.9999999999999) / 1738.1183), WETH_DECIMALS),
+            token: STETH,
+        },
+    },
+    rates: {
+        [STETH]: {
+            rate: 38434n,
+            isActive: true,
+        },
+    },
+};
+describe("CreditAccount CreditAccountData_Legacy.calcOverallAPY test", () => {
+    it("overall APY calculation for caWithoutLP is correct", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithoutLP.assets,
+            totalValue: caWithoutLP.totalValue,
+            debt: caWithoutLP.debt,
+            baseRateWithFee: caWithoutLP.borrowRate,
+            underlyingToken: caWithoutLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(-69484n);
+    });
+    it("overall APY calculation for caWithLP is correct", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: caWithLP.totalValue,
+            debt: caWithLP.debt,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(144919n);
+    });
+    it("overall APY is undefined when !lpAPY", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: caWithLP.totalValue,
+            debt: caWithLP.debt,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY: undefined,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(undefined);
+    });
+    it("overall APY is undefined when !totalValue", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: undefined,
+            debt: caWithLP.debt,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(undefined);
+    });
+    it("overall APY is undefined when !debt", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: caWithLP.totalValue,
+            debt: undefined,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(undefined);
+    });
+    it("overall APY is undefined when totalValue lte 0", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: 0n,
+            debt: undefined,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: {},
+            quotas: {},
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(undefined);
+    });
+    it("overall APY calculation for caWithLP with sufficient quota is correct", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: caWithLP.totalValue,
+            debt: caWithLP.debt,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: caWithLP.rates,
+            quotas: caWithLP.quotas,
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(-18680n);
+    });
+    it("overall APY calculation for caWithLP with insufficient quota is correct", () => {
+        const result = CreditAccountData_Legacy.calcOverallAPY({
+            caAssets: caWithLP.assets,
+            totalValue: caWithLP.totalValue,
+            debt: caWithLP.debt,
+            baseRateWithFee: caWithLP.borrowRate,
+            underlyingToken: caWithLP.underlyingToken,
+            quotaRates: caWithLP.rates,
+            quotas: {
+                [STETH]: {
+                    balance: 0n,
+                    token: STETH,
+                },
+            },
+            feeInterest: 0,
+            lpAPY,
+            prices,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(144919n);
+    });
+});
+describe("CreditAccount calcMaxDebtIncrease test", () => {
+    it("health max increase borrow is zero if hf < 1", () => {
+        const result = CreditAccountData_Legacy.calcMaxDebtIncrease(9999, BigInt("156522834253690396032546"), 9300);
+        expect(result.toString()).toEqual("0");
+    });
+    it("health max increase borrow is calculated correctly", () => {
+        const result = CreditAccountData_Legacy.calcMaxDebtIncrease(10244, BigInt("156522834253690396032546"), 9300);
+        expect(result.toString()).toEqual("54559387939857795188487");
+    });
+    it("health max increase borrow is calculated correctly (low hf, high debt)", () => {
+        const loweHf = 10244;
+        const result = CreditAccountData_Legacy.calcMaxDebtIncrease(loweHf, BigInt("54782991988791638611392"), 9300);
+        expect(result.toString()).toEqual("19095785778950228315970");
+    });
+});
+const liquidationThresholds = {
+    [USDC]: 9800n,
+    [DAI]: 9300n,
+    [WETH]: 8500n,
+    [STETH]: 8000n,
+};
+describe("CreditAccount calcMaxLendingDebt test", () => {
+    it("calcMaxLendingDebt for several collaterals with zero lt", () => {
+        const result = CreditAccountData_Legacy.calcMaxLendingDebt({
+            assets: [
+                {
+                    token: DAI,
+                    balance: toBN("1000", DAI_DECIMALS),
+                },
+                {
+                    token: WETH,
+                    balance: toBN("1", WETH_DECIMALS),
+                },
+            ],
+            liquidationThresholds: {
+                ...liquidationThresholds,
+                [DAI]: 0n,
+            },
+            underlyingToken: USDC,
+            prices: {
+                [DAI]: 1n,
+                [USDC]: 1n,
+                [WETH]: 1000n,
+            },
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(toBN("850", USDC_DECIMALS));
+    });
+    it("calcMaxLendingDebt for several collaterals with zero underlying price", () => {
+        const result = CreditAccountData_Legacy.calcMaxLendingDebt({
+            assets: [
+                {
+                    token: DAI,
+                    balance: toBN("1000", DAI_DECIMALS),
+                },
+                {
+                    token: WETH,
+                    balance: toBN("1", WETH_DECIMALS),
+                },
+            ],
+            liquidationThresholds: liquidationThresholds,
+            underlyingToken: USDC,
+            prices: {
+                [DAI]: 1n,
+                [WETH]: 1000n,
+            },
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(0n);
+    });
+    it("calcMaxLendingDebt for simplest case", () => {
+        const result = CreditAccountData_Legacy.calcMaxLendingDebt({
+            assets: [
+                {
+                    token: DAI,
+                    balance: toBN("1000", DAI_DECIMALS),
+                },
+            ],
+            liquidationThresholds,
+            underlyingToken: USDC,
+            prices: {
+                [DAI]: 1n,
+                [USDC]: 1n,
+            },
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(toBN("930", USDC_DECIMALS));
+    });
+    it("calcMaxLendingDebt for several collaterals", () => {
+        const result = CreditAccountData_Legacy.calcMaxLendingDebt({
+            assets: [
+                {
+                    token: DAI,
+                    balance: toBN("1000", DAI_DECIMALS),
+                },
+                {
+                    token: WETH,
+                    balance: toBN("1", WETH_DECIMALS),
+                },
+            ],
+            liquidationThresholds,
+            underlyingToken: USDC,
+            prices: {
+                [DAI]: 1n,
+                [USDC]: 1n,
+                [WETH]: 1000n,
+            },
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(toBN("1780", USDC_DECIMALS));
+    });
+    it("calcMaxLendingDebt for several collaterals with target HF", () => {
+        const result = CreditAccountData_Legacy.calcMaxLendingDebt({
+            assets: [
+                {
+                    token: DAI,
+                    balance: toBN("1000", DAI_DECIMALS),
+                },
+                {
+                    token: WETH,
+                    balance: toBN("1", WETH_DECIMALS),
+                },
+            ],
+            liquidationThresholds,
+            underlyingToken: USDC,
+            prices: {
+                [DAI]: 1n,
+                [USDC]: 1n,
+                [WETH]: 1000n,
+            },
+            targetHF: 12500n,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(toBN("1424", USDC_DECIMALS));
+    });
+});
+const defaultCA = {
+    assets: [
+        {
+            balance: toBN("156552", DAI_DECIMALS),
+            token: DAI,
+        },
+        {
+            balance: toBN("10", WETH_DECIMALS),
+            token: WETH,
+        },
+    ],
+    debt: toBN("156552", DAI_DECIMALS),
+    healthFactor: 10244,
+    underlyingToken: DAI,
+    underlyingDecimals: DAI_DECIMALS,
+    quotas: {
+        [WETH]: {
+            balance: toBN(String(1750 * 10), DAI_DECIMALS),
+            token: WETH,
+        },
+    },
+    quotasInfo: {
+        [WETH]: {
+            isActive: true,
+        },
+    },
+};
+describe("CreditAccount calcHealthFactor test", () => {
+    it("health factor is calculated correctly", () => {
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: defaultCA.assets,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(defaultCA.healthFactor);
+    });
+    it("health factor calculation has no division by zero error", () => {
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: [],
+            prices: {},
+            liquidationThresholds: {},
+            underlyingToken: "",
+            debt: 0n,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(65535);
+    });
+    it("health factor after add collateral is calculated  correctly", () => {
+        const collateral = {
+            balance: toBN("10", WETH_DECIMALS),
+            token: WETH,
+        };
+        const afterAdd = AssetUtils.sumAssets(defaultCA.assets, [collateral]);
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: afterAdd,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(11188);
+    });
+    it("health factor after decrease debt is calculated  correctly", () => {
+        const amountDecrease = toBN("10000", defaultCA.underlyingDecimals);
+        const debtDecrease = {
+            balance: amountDecrease,
+            token: defaultCA.underlyingToken,
+        };
+        const afterDecrease = AssetUtils.subAssets(defaultCA.assets, [
+            debtDecrease,
+        ]);
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: afterDecrease,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt - amountDecrease,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(10308);
+    });
+    it("health factor after increase debt is calculated  correctly", () => {
+        const amountIncrease = toBN("20000", defaultCA.underlyingDecimals);
+        const debtIncrease = {
+            balance: amountIncrease,
+            token: defaultCA.underlyingToken,
+        };
+        const afterIncrease = AssetUtils.sumAssets(defaultCA.assets, [
+            debtIncrease,
+        ]);
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: afterIncrease,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt + amountIncrease,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(10137);
+    });
+    it("health factor after swap is calculated  correctly", () => {
+        const swapAsset = {
+            balance: defaultCA.debt,
+            token: defaultCA.underlyingToken,
+        };
+        const underlyingPrice = prices[defaultCA.underlyingToken];
+        const wethPrice = prices[WETH];
+        const getAmount = PriceUtils.convertByPrice(PriceUtils.calcTotalPrice(underlyingPrice, defaultCA.debt, defaultCA.underlyingDecimals), { price: wethPrice, decimals: WETH_DECIMALS });
+        const getAsset = {
+            balance: getAmount,
+            token: WETH,
+        };
+        const afterSub = AssetUtils.subAssets(defaultCA.assets, [swapAsset]);
+        const afterSwap = AssetUtils.sumAssets(afterSub, [getAsset]);
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {},
+            quotasInfo: {},
+            assets: afterSwap,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(9444);
+    });
+    it("health factor with sufficient quotas is calculated correctly", () => {
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: defaultCA.quotas,
+            quotasInfo: defaultCA.quotasInfo,
+            assets: defaultCA.assets,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(defaultCA.healthFactor);
+    });
+    it("health factor with insufficient quotas is calculated correctly", () => {
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: {
+                [WETH]: {
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            quotasInfo: defaultCA.quotasInfo,
+            assets: defaultCA.assets,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(9300);
+    });
+    it("health factor with disabled quota is calculated correctly", () => {
+        const result = CreditAccountData_Legacy.calcHealthFactor({
+            quotas: defaultCA.quotas,
+            quotasInfo: {
+                [WETH]: {
+                    isActive: false,
+                },
+            },
+            assets: defaultCA.assets,
+            prices,
+            liquidationThresholds,
+            underlyingToken: defaultCA.underlyingToken,
+            debt: defaultCA.debt,
+            tokensList: tokenDataList,
+        });
+        expect(result).toEqual(9300);
+    });
+});
+const cmQuotas = {
+    [DAI]: {
+        token: DAI,
+        isActive: true,
+    },
+    [WETH]: {
+        token: WETH,
+        isActive: true,
+    },
+    [STETH]: {
+        token: STETH,
+        isActive: true,
+    },
+};
+const caQuota = {
+    [DAI]: {
+        quota: 5n * PERCENTAGE_FACTOR,
+    },
+    [WETH]: {
+        quota: 10n * PERCENTAGE_FACTOR,
+    },
+};
+const QUOTA_RESERVE = 100n;
+const DEFAULT_LT = {
+    [DAI]: PERCENTAGE_FACTOR,
+    [WETH]: PERCENTAGE_FACTOR,
+    [STETH]: PERCENTAGE_FACTOR,
+};
+const HUGE_MAX_DEBT = 20n * PERCENTAGE_FACTOR;
+describe("CreditAccount calcQuotaUpdate test", () => {
+    it("open account should buy quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {},
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 20n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+                [WETH]: {},
+            },
+            allowedToSpend: {},
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            {
+                balance: 20n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 20n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("add collateral should buy quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: {},
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("add collateral should add additional quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {},
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("add collateral shouldn't add additional quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [WETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [WETH]: {},
+            },
+            allowedToSpend: {},
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy additional quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy additional quota with respect to debt", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            calcModification: {
+                debt: 7n * PERCENTAGE_FACTOR,
+                type: "recommendedQuota",
+            },
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 2n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 7n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap shouldn't buy additional quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [WETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+                [DAI]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [WETH]: {},
+            },
+            allowedToSpend: { [DAI]: {} },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: DAI,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("shouldn't change quota if disallowed", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {},
+            allowedToSpend: {},
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("shouldn't change quota if it is disabled", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    isActive: false,
+                },
+                [WETH]: {
+                    token: WETH,
+                    isActive: false,
+                },
+                [STETH]: {
+                    token: STETH,
+                    isActive: false,
+                },
+            },
+            initialQuotas: caQuota,
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap shouldn't buy quota if no lt", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [STETH]: {
+                    quota: 5n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 5n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: {},
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy quota with respect to lt", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [STETH]: { quota: 5n * PERCENTAGE_FACTOR },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 20n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 5n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: {
+                ...DEFAULT_LT,
+                [STETH]: 5000n,
+            },
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: -5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap shouldn't buy quota with respect to lt", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [STETH]: { quota: 5n * PERCENTAGE_FACTOR },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 5n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: {
+                ...DEFAULT_LT,
+                [STETH]: 5000n,
+            },
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: -5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy additional quota after limit was increased", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: 10n * PERCENTAGE_FACTOR,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 10n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 20n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 20n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap should buy additional quota with respect to debt limit", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: 9n * PERCENTAGE_FACTOR,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 10n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 20n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 8n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 18n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap shouldn't buy additional quota if debt limit more then current quota", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: 5n * PERCENTAGE_FACTOR,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 10n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [DAI]: {
+                    amountInTarget: 20n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [DAI]: {},
+            },
+            allowedToSpend: {
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap on old accounts should work correctly", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 52345n,
+                },
+                [WETH]: {
+                    quota: 107458n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 101345n,
+                    balance: 0n,
+                    token: STETH,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 52345n,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("swap on old accounts should work correctly and respect maxQuotaIncrease", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: 6n * PERCENTAGE_FACTOR,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 52345n,
+                },
+                [WETH]: {
+                    quota: 107458n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 101345n,
+                    balance: 0n,
+                    token: STETH,
+                },
+                [WETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+            },
+            allowedToSpend: { [WETH]: {} },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 7n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 52345n,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 7n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+    it("should buy quota correctly when all assets listed in both buy and spend", () => {
+        const result = CreditAccountData_Legacy.calcQuotaUpdate({
+            maxDebt: HUGE_MAX_DEBT,
+            quotaReserve: QUOTA_RESERVE,
+            quotas: cmQuotas,
+            initialQuotas: {
+                ...caQuota,
+                [DAI]: {
+                    quota: 0n * PERCENTAGE_FACTOR,
+                },
+                [STETH]: {
+                    quota: 15n * PERCENTAGE_FACTOR,
+                },
+            },
+            assetsAfterUpdate: {
+                [STETH]: {
+                    amountInTarget: 0n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: STETH,
+                },
+                [DAI]: {
+                    amountInTarget: 10n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: DAI,
+                },
+                [WETH]: {
+                    amountInTarget: 5n * PERCENTAGE_FACTOR,
+                    balance: 0n,
+                    token: WETH,
+                },
+            },
+            allowedToObtain: {
+                [STETH]: {},
+                [DAI]: {},
+                [WETH]: {},
+            },
+            allowedToSpend: {
+                [STETH]: {},
+                [DAI]: {},
+                [WETH]: {},
+            },
+            liquidationThresholds: DEFAULT_LT,
+        });
+        expect(result.quotaIncrease).toEqual([
+            {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+        ]);
+        expect(result.quotaDecrease).toEqual([
+            {
+                balance: MIN_INT96,
+                token: STETH,
+            },
+            {
+                balance: -5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+        ]);
+        expect(result.desiredQuota).toEqual({
+            [DAI]: {
+                balance: 10n * PERCENTAGE_FACTOR,
+                token: DAI,
+            },
+            [WETH]: {
+                balance: 5n * PERCENTAGE_FACTOR,
+                token: WETH,
+            },
+            [STETH]: {
+                balance: 0n * PERCENTAGE_FACTOR,
+                token: STETH,
+            },
+        });
+    });
+});
+describe("CreditAccount calcAvgQuotaBorrowRate test", () => {
+    it("should calculate quota rate (same amounts, different rates)", () => {
+        const result = CreditAccountData_Legacy.calcQuotaBorrowRate({
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    balance: 10n,
+                },
+                [WETH]: {
+                    token: WETH,
+                    balance: 10n,
+                },
+                [STETH]: {
+                    token: STETH,
+                    balance: 10n,
+                },
+            },
+            quotaRates: {
+                [DAI]: {
+                    rate: 5n,
+                    isActive: true,
+                },
+                [WETH]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+                [STETH]: {
+                    rate: 15n,
+                    isActive: true,
+                },
+            },
+        });
+        expect(result).toEqual(300n);
+    });
+    it("should calculate quota rate (same rates, different amounts)", () => {
+        const result = CreditAccountData_Legacy.calcQuotaBorrowRate({
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    balance: 5n,
+                },
+                [WETH]: {
+                    token: WETH,
+                    balance: 10n,
+                },
+                [STETH]: {
+                    token: STETH,
+                    balance: 15n,
+                },
+            },
+            quotaRates: {
+                [DAI]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+                [WETH]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+                [STETH]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+            },
+        });
+        expect(result).toEqual(300n);
+    });
+    it("should calculate quota rate (disabled quota)", () => {
+        const result = CreditAccountData_Legacy.calcQuotaBorrowRate({
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    balance: 5n,
+                },
+                [WETH]: {
+                    token: WETH,
+                    balance: 10n,
+                },
+                [STETH]: {
+                    token: STETH,
+                    balance: 15n,
+                },
+            },
+            quotaRates: {
+                [DAI]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+                [WETH]: {
+                    rate: 10n,
+                    isActive: false,
+                },
+                [STETH]: {
+                    rate: 10n,
+                    isActive: true,
+                },
+            },
+        });
+        expect(result).toEqual(200n);
+    });
+});
+describe("CreditAccount calcQuotaBorrowRate test", () => {
+    it("should calculate quota borrow rate", () => {
+        const result = CreditAccountData_Legacy.calcQuotaBorrowRate({
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    balance: 10n,
+                },
+            },
+            quotaRates: {
+                [DAI]: {
+                    rate: 5n,
+                    isActive: true,
+                },
+            },
+        });
+        expect(result).toEqual(50n);
+    });
+    it("should calculate quota borrow rate when no balance", () => {
+        const result = CreditAccountData_Legacy.calcQuotaBorrowRate({
+            quotas: {
+                [DAI]: {
+                    token: DAI,
+                    balance: 1n,
+                },
+            },
+            quotaRates: {
+                [DAI]: {
+                    rate: 5n,
+                    isActive: true,
+                },
+            },
+        });
+        expect(result).toEqual(5n);
+    });
+});
+describe("CreditAccount calcRelativeBaseBorrowRate test", () => {
+    it("should calculate relative borrow rate", () => {
+        const result = CreditAccountData_Legacy.calcRelativeBaseBorrowRate({
+            debt: 200n,
+            baseRateWithFee: 250,
+            assetAmountInUnderlying: 200n,
+        });
+        expect(result).toEqual(10000000n);
+    });
+    it("should calculate relative borrow rate if position asset === 0", () => {
+        const result = CreditAccountData_Legacy.calcRelativeBaseBorrowRate({
+            debt: 200n,
+            baseRateWithFee: 250,
+            assetAmountInUnderlying: 1n,
+        });
+        expect(result).toEqual(50000n);
+    });
+    it("should calculate relative borrow rate if position === 0", () => {
+        const result = CreditAccountData_Legacy.calcRelativeBaseBorrowRate({
+            debt: 1n,
+            baseRateWithFee: 250,
+            assetAmountInUnderlying: 1n,
+        });
+        expect(result).toEqual(250n);
+    });
+});
+describe("CreditAccount getTimeToLiquidation test", () => {
+    it("should return 0 when HF < 1", () => {
+        const result = CreditAccountData_Legacy.getTimeToLiquidation({
+            healthFactor: 9000,
+            totalBorrowRate_debt: 250n,
+        });
+        expect(result).toEqual(null);
+    });
+    it("should return 0 when br_debt === 0", () => {
+        const result = CreditAccountData_Legacy.getTimeToLiquidation({
+            healthFactor: 9000,
+            totalBorrowRate_debt: 0n,
+        });
+        expect(result).toEqual(null);
+    });
+    it("should calculate time to liquidation correctly", () => {
+        const result = CreditAccountData_Legacy.getTimeToLiquidation({
+            healthFactor: 13750,
+            totalBorrowRate_debt: 20n * 10000n,
+        });
+        // 59_130_000
+        expect(result).toEqual(59130000n * 1000n);
+    });
+});
+//# sourceMappingURL=creditAccount.spec.js.map