@curvefi/llamalend-api 1.1.10 → 2.0.0

package/lib/lendMarkets/interfaces/v2/leverageV2.d.ts

@@ -0,0 +1,90 @@
+import { TAmount, TGas, IDict } from "../../../interfaces";
+export interface ILeverageV2 {
+    hasLeverage: () => boolean;
+    maxLeverage: (N: number) => Promise<string>;
+    createLoanMaxRecv: (userCollateral: TAmount, userBorrowed: TAmount, range: number) => Promise<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        maxLeverage: string;
+        avgPrice: string;
+    }>;
+    createLoanMaxRecvAllRanges: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<IDict<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        maxLeverage: string;
+        avgPrice: string;
+    }>>;
+    createLoanExpectedCollateral: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number) => Promise<{
+        totalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromDebt: string;
+        leverage: string;
+        avgPrice: string;
+    }>;
+    createLoanPriceImpact: (userBorrowed: TAmount, debt: TAmount) => Promise<string>;
+    createLoanMaxRange: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount) => Promise<number>;
+    createLoanBands: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number) => Promise<[number, number]>;
+    createLoanBandsAllRanges: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount) => Promise<IDict<[number, number] | null>>;
+    createLoanPrices: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number) => Promise<string[]>;
+    createLoanPricesAllRanges: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount) => Promise<IDict<[string, string] | null>>;
+    createLoanHealth: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, full?: boolean) => Promise<string>;
+    createLoanIsApproved: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<boolean>;
+    createLoanApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<string[]>;
+    createLoanRouteImage: (userBorrowed: TAmount, debt: TAmount) => Promise<string>;
+    createLoan: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, slippage?: number) => Promise<string>;
+    borrowMoreMaxRecv: (userCollateral: TAmount, userBorrowed: TAmount, address?: string) => Promise<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        avgPrice: string;
+    }>;
+    borrowMoreExpectedCollateral: (userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, slippage?: number, address?: string) => Promise<{
+        totalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromDebt: string;
+        avgPrice: string;
+    }>;
+    borrowMorePriceImpact: (userBorrowed: TAmount, dDebt: TAmount, address?: string) => Promise<string>;
+    borrowMoreBands: (userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, address?: string) => Promise<[number, number]>;
+    borrowMorePrices: (userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, address?: string) => Promise<string[]>;
+    borrowMoreHealth: (userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, full?: boolean, address?: string) => Promise<string>;
+    borrowMoreIsApproved: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<boolean>;
+    borrowMoreApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<string[]>;
+    borrowMoreRouteImage: (userBorrowed: TAmount, debt: TAmount) => Promise<string>;
+    borrowMore: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number) => Promise<string>;
+    repayExpectedBorrowed: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number) => Promise<{
+        totalBorrowed: string;
+        borrowedFromStateCollateral: string;
+        borrowedFromUserCollateral: string;
+        userBorrowed: string;
+        avgPrice: string;
+    }>;
+    repayPriceImpact: (stateCollateral: TAmount, userCollateral: TAmount) => Promise<string>;
+    repayIsFull: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string) => Promise<boolean>;
+    repayIsAvailable: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string) => Promise<boolean>;
+    repayBands: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string) => Promise<[number, number]>;
+    repayPrices: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string) => Promise<string[]>;
+    repayHealth: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, full?: boolean, address?: string) => Promise<string>;
+    repayIsApproved: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<boolean>;
+    repayApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<string[]>;
+    repayRouteImage: (stateCollateral: TAmount, userCollateral: TAmount) => Promise<string>;
+    repay: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number) => Promise<string>;
+    estimateGas: {
+        createLoanApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<TGas>;
+        createLoan: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, slippage?: number) => Promise<number>;
+        borrowMoreApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<TGas>;
+        borrowMore: (userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number) => Promise<number>;
+        repayApprove: (userCollateral: TAmount, userBorrowed: TAmount) => Promise<TGas>;
+        repay: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number) => Promise<number>;
+    };
+}

package/lib/lendMarkets/interfaces/v2/leverageV2.js

@@ -0,0 +1 @@
+export {};

package/lib/lendMarkets/interfaces/v2/loanV2.d.ts

@@ -0,0 +1,73 @@
+import { TAmount, TGas, IPartialFrac } from "../../../interfaces";
+export interface ILoanV2 {
+    createLoanMaxRecv: (collateral: TAmount, range: number) => Promise<string>;
+    createLoanMaxRecvAllRanges: (collateral: TAmount) => Promise<{
+        [index: number]: string;
+    }>;
+    getMaxRange: (collateral: TAmount, debt: TAmount) => Promise<number>;
+    createLoanBands: (collateral: TAmount, debt: TAmount, range: number) => Promise<[number, number]>;
+    createLoanBandsAllRanges: (collateral: TAmount, debt: TAmount) => Promise<{
+        [index: number]: [number, number] | null;
+    }>;
+    createLoanPrices: (collateral: TAmount, debt: TAmount, range: number) => Promise<string[]>;
+    createLoanPricesAllRanges: (collateral: TAmount, debt: TAmount) => Promise<{
+        [index: number]: [string, string] | null;
+    }>;
+    createLoanHealth: (collateral: TAmount, debt: TAmount, range: number, full?: boolean) => Promise<string>;
+    createLoanIsApproved: (collateral: TAmount) => Promise<boolean>;
+    createLoanApprove: (collateral: TAmount) => Promise<string[]>;
+    createLoan: (collateral: TAmount, debt: TAmount, range: number) => Promise<string>;
+    borrowMoreMaxRecv: (collateralAmount: TAmount) => Promise<string>;
+    borrowMoreBands: (collateral: TAmount, debt: TAmount) => Promise<[number, number]>;
+    borrowMorePrices: (collateral: TAmount, debt: TAmount) => Promise<string[]>;
+    borrowMoreHealth: (collateral: TAmount, debt: TAmount, full?: boolean, address?: string) => Promise<string>;
+    borrowMoreIsApproved: (collateral: TAmount) => Promise<boolean>;
+    borrowMoreApprove: (collateral: TAmount) => Promise<string[]>;
+    borrowMore: (collateral: TAmount, debt: TAmount) => Promise<string>;
+    borrowMoreFutureLeverage: (collateral: TAmount, debt: TAmount, userAddress?: string) => Promise<string>;
+    addCollateralBands: (collateral: TAmount, address?: string) => Promise<[number, number]>;
+    addCollateralPrices: (collateral: TAmount, address?: string) => Promise<string[]>;
+    addCollateralHealth: (collateral: TAmount, full?: boolean, address?: string) => Promise<string>;
+    addCollateralIsApproved: (collateral: TAmount) => Promise<boolean>;
+    addCollateralApprove: (collateral: TAmount) => Promise<string[]>;
+    addCollateral: (collateral: TAmount, address?: string) => Promise<string>;
+    addCollateralFutureLeverage: (collateral: TAmount, userAddress?: string) => Promise<string>;
+    maxRemovable: () => Promise<string>;
+    removeCollateralBands: (collateral: TAmount) => Promise<[number, number]>;
+    removeCollateralPrices: (collateral: TAmount) => Promise<string[]>;
+    removeCollateralHealth: (collateral: TAmount, full?: boolean, address?: string) => Promise<string>;
+    removeCollateral: (collateral: TAmount) => Promise<string>;
+    removeCollateralFutureLeverage: (collateral: TAmount, userAddress?: string) => Promise<string>;
+    repayBands: (debt: TAmount, address?: string) => Promise<[number, number]>;
+    repayPrices: (debt: TAmount, address?: string) => Promise<string[]>;
+    repayIsApproved: (debt: TAmount) => Promise<boolean>;
+    repayApprove: (debt: TAmount) => Promise<string[]>;
+    repayHealth: (debt: TAmount, full?: boolean, address?: string) => Promise<string>;
+    repay: (debt: TAmount, address?: string) => Promise<string>;
+    repayFutureLeverage: (debt: TAmount, userAddress?: string) => Promise<string>;
+    fullRepayIsApproved: (address?: string) => Promise<boolean>;
+    fullRepayApprove: (address?: string) => Promise<string[]>;
+    fullRepay: (address?: string) => Promise<string>;
+    tokensToLiquidate: (address?: string) => Promise<string>;
+    calcPartialFrac: (amount: TAmount, address?: string) => Promise<IPartialFrac>;
+    liquidateIsApproved: (address?: string) => Promise<boolean>;
+    liquidateApprove: (address?: string) => Promise<string[]>;
+    liquidate: (address: string, slippage?: number) => Promise<string>;
+    selfLiquidateIsApproved: () => Promise<boolean>;
+    selfLiquidateApprove: () => Promise<string[]>;
+    selfLiquidate: (slippage?: number) => Promise<string>;
+    partialSelfLiquidateIsApproved: (partialFrac: IPartialFrac) => Promise<boolean>;
+    partialSelfLiquidateApprove: (partialFrac: IPartialFrac) => Promise<string[]>;
+    partialSelfLiquidate: (partialFrac: IPartialFrac, slippage?: number) => Promise<string>;
+    estimateGas: {
+        createLoan: (collateral: TAmount, debt: TAmount, range: number) => Promise<TGas>;
+        borrowMore: (collateral: TAmount, debt: TAmount) => Promise<TGas>;
+        addCollateral: (collateral: TAmount, address?: string) => Promise<TGas>;
+        removeCollateral: (collateral: TAmount) => Promise<TGas>;
+        repay: (debt: TAmount, address?: string) => Promise<TGas>;
+        fullRepay: (address?: string) => Promise<TGas>;
+        liquidate: (address: string, slippage?: number) => Promise<TGas>;
+        selfLiquidate: (slippage?: number) => Promise<TGas>;
+        partialSelfLiquidate: (partialFrac: IPartialFrac, slippage?: number) => Promise<TGas>;
+    };
+}

package/lib/lendMarkets/interfaces/v2/loanV2.js

@@ -0,0 +1 @@
+export {};

package/lib/lendMarkets/interfaces/v2/statsV2.d.ts

@@ -0,0 +1,49 @@
+import { TAmount } from "../../../interfaces";
+export interface IStatsV2 {
+    parameters: () => Promise<{
+        fee: string;
+        admin_fee: string;
+        liquidation_discount: string;
+        loan_discount: string;
+        base_price: string;
+        A: string;
+    }>;
+    rates: (isGetter?: boolean, useAPI?: boolean) => Promise<{
+        borrowApr: string;
+        lendApr: string;
+        borrowApy: string;
+        lendApy: string;
+    }>;
+    futureRates: (dReserves: TAmount, dDebt: TAmount) => Promise<{
+        borrowApr: string;
+        lendApr: string;
+        borrowApy: string;
+        lendApy: string;
+    }>;
+    balances: () => Promise<[string, string]>;
+    bandsInfo: () => Promise<{
+        activeBand: number;
+        maxBand: number;
+        minBand: number;
+        liquidationBand: number | null;
+    }>;
+    bandBalances: (n: number) => Promise<{
+        borrowed: string;
+        collateral: string;
+    }>;
+    bandsBalances: () => Promise<{
+        [index: number]: {
+            borrowed: string;
+            collateral: string;
+        };
+    }>;
+    totalDebt: (isGetter?: boolean, useAPI?: boolean) => Promise<string>;
+    ammBalances: (isGetter?: boolean, useAPI?: boolean) => Promise<{
+        borrowed: string;
+        collateral: string;
+    }>;
+    capAndAvailable: (isGetter?: boolean, useAPI?: boolean) => Promise<{
+        cap: string;
+        available: string;
+    }>;
+}

package/lib/lendMarkets/interfaces/v2/statsV2.js

@@ -0,0 +1 @@
+export {};

package/lib/lendMarkets/lendMarketConstructor.js

@@ -1,7 +1,7 @@
 import { LendMarketTemplate } from "./LendMarketTemplate.js";
 export const getLendMarket = function (lendMarketId) {
     if (!(lendMarketId in this.lendMarkets)) {
-        const marketData = this.constants.ONE_WAY_MARKETS[lendMarketId];
+        const marketData = this.constants.ONE_WAY_MARKETS[lendMarketId] || this.constants.ONE_WAY_MARKETS_V2[lendMarketId];
         if (!marketData)
             throw new Error(`Lend market with id ${lendMarketId} not found`);
         this.lendMarkets[lendMarketId] = new LendMarketTemplate(lendMarketId, marketData, this);

package/lib/lendMarkets/modules/common/amm.d.ts

@@ -0,0 +1,19 @@
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { TGas } from "../../../interfaces";
+import { IAmm } from "../../interfaces/common";
+export declare class AmmModule implements IAmm {
+    private market;
+    private llamalend;
+    constructor(market: LendMarketTemplate);
+    maxSwappable(i: number, j: number): Promise<string>;
+    private _swapExpected;
+    swapExpected(i: number, j: number, amount: number | string): Promise<string>;
+    swapRequired(i: number, j: number, outAmount: number | string): Promise<string>;
+    swapPriceImpact(i: number, j: number, amount: number | string): Promise<string>;
+    swapIsApproved(i: number, amount: number | string): Promise<boolean>;
+    private swapApproveEstimateGas;
+    swapApprove(i: number, amount: number | string): Promise<string[]>;
+    private _swap;
+    swapEstimateGas(i: number, j: number, amount: number | string, slippage?: number): Promise<TGas>;
+    swap(i: number, j: number, amount: number | string, slippage?: number): Promise<string>;
+}

package/lib/lendMarkets/modules/common/amm.js

@@ -0,0 +1,137 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { _cutZeros, _mulBy1_3, BN, DIGas, ensureAllowance, ensureAllowanceEstimateGas, formatUnits, fromBN, hasAllowance, MAX_ALLOWANCE, parseUnits, smartNumber, toBN, } from "../../../utils";
+import BigNumber from "bignumber.js";
+export class AmmModule {
+    constructor(market) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    maxSwappable(i, j) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                throw Error("Wrong index");
+            const inDecimals = this.market.coinDecimals[i];
+            const contract = this.llamalend.contracts[this.market.addresses.amm].contract;
+            const [_inAmount, _outAmount] = yield contract.get_dxdy(i, j, MAX_ALLOWANCE, this.llamalend.constantOptions);
+            if (_outAmount === BigInt(0))
+                return "0";
+            return formatUnits(_inAmount, inDecimals);
+        });
+    }
+    _swapExpected(i, j, _amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.llamalend.contracts[this.market.addresses.amm].contract.get_dy(i, j, _amount, this.llamalend.constantOptions);
+        });
+    }
+    swapExpected(i, j, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                throw Error("Wrong index");
+            const [inDecimals, outDecimals] = this.market.coinDecimals;
+            const _amount = parseUnits(amount, inDecimals);
+            const _expected = yield this._swapExpected(i, j, _amount);
+            return formatUnits(_expected, outDecimals);
+        });
+    }
+    swapRequired(i, j, outAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                throw Error("Wrong index");
+            const [inDecimals, outDecimals] = this.market.coinDecimals;
+            const _amount = parseUnits(outAmount, outDecimals);
+            const _expected = yield this.llamalend.contracts[this.market.addresses.amm].contract.get_dx(i, j, _amount, this.llamalend.constantOptions);
+            return formatUnits(_expected, inDecimals);
+        });
+    }
+    swapPriceImpact(i, j, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                throw Error("Wrong index");
+            const [inDecimals, outDecimals] = this.market.coinDecimals;
+            const _amount = parseUnits(amount, inDecimals);
+            const _output = yield this._swapExpected(i, j, _amount);
+            // Find k for which x * k = 10^15 or y * k = 10^15: k = max(10^15 / x, 10^15 / y)
+            // For coins with d (decimals) <= 15: k = min(k, 0.2), and x0 = min(x * k, 10^d)
+            // x0 = min(x * min(max(10^15 / x, 10^15 / y), 0.2), 10^d), if x0 == 0 then priceImpact = 0
+            const target = BN(Math.pow(10, 15));
+            const amountIntBN = BN(amount).times(Math.pow(10, inDecimals));
+            const outputIntBN = toBN(_output, 0);
+            const k = BigNumber.min(BigNumber.max(target.div(amountIntBN), target.div(outputIntBN)), 0.2);
+            const smallAmountIntBN = BigNumber.min(amountIntBN.times(k), BN(Math.pow(10, inDecimals)));
+            if (smallAmountIntBN.toFixed(0) === '0')
+                return '0';
+            const _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inDecimals)), inDecimals);
+            const _smallOutput = yield this._swapExpected(i, j, _smallAmount);
+            const amountBN = BN(amount);
+            const outputBN = toBN(_output, outDecimals);
+            const smallAmountBN = toBN(_smallAmount, inDecimals);
+            const smallOutputBN = toBN(_smallOutput, outDecimals);
+            const rateBN = outputBN.div(amountBN);
+            const smallRateBN = smallOutputBN.div(smallAmountBN);
+            if (rateBN.gt(smallRateBN))
+                return "0";
+            const slippageBN = BN(1).minus(rateBN.div(smallRateBN)).times(100);
+            return _cutZeros(slippageBN.toFixed(6));
+        });
+    }
+    swapIsApproved(i, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (i !== 0 && i !== 1)
+                throw Error("Wrong index");
+            return yield hasAllowance.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.llamalend.signerAddress, this.market.addresses.amm);
+        });
+    }
+    swapApproveEstimateGas(i, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (i !== 0 && i !== 1)
+                throw Error("Wrong index");
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.market.addresses.amm);
+        });
+    }
+    swapApprove(i, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (i !== 0 && i !== 1)
+                throw Error("Wrong index");
+            return yield ensureAllowance.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.market.addresses.amm);
+        });
+    }
+    _swap(i, j, amount, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                throw Error("Wrong index");
+            const [inDecimals, outDecimals] = [this.market.coinDecimals[i], this.market.coinDecimals[j]];
+            const _amount = parseUnits(amount, inDecimals);
+            const _expected = yield this._swapExpected(i, j, _amount);
+            const minRecvAmountBN = toBN(_expected, outDecimals).times(100 - slippage).div(100);
+            const _minRecvAmount = fromBN(minRecvAmountBN, outDecimals);
+            const contract = this.llamalend.contracts[this.market.addresses.amm].contract;
+            const gas = yield contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, this.llamalend.constantOptions);
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.exchange(i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    swapEstimateGas(i_1, j_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (i, j, amount, slippage = 0.1) {
+            if (!(yield this.swapIsApproved(i, amount)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._swap(i, j, amount, slippage, true);
+        });
+    }
+    swap(i_1, j_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (i, j, amount, slippage = 0.1) {
+            yield this.swapApprove(i, amount);
+            return yield this._swap(i, j, amount, slippage, false);
+        });
+    }
+}

package/lib/lendMarkets/modules/common/index.d.ts

@@ -0,0 +1,9 @@
+export { UserPositionModule } from './userPosition.js';
+export { WalletModule } from './wallet.js';
+export { PricesModule } from './prices.js';
+export { AmmModule } from './amm.js';
+export { VaultModule } from './vault.js';
+export { StatsBaseModule } from './statsBase.js';
+export { LoanBaseModule } from './loanBase.js';
+export { LeverageZapV1BaseModule } from './leverageZapV1Base.js';
+export { LeverageZapV2BaseModule } from './leverageZapV2Base.js';

package/lib/lendMarkets/modules/common/index.js

@@ -0,0 +1,9 @@
+export { UserPositionModule } from './userPosition.js';
+export { WalletModule } from './wallet.js';
+export { PricesModule } from './prices.js';
+export { AmmModule } from './amm.js';
+export { VaultModule } from './vault.js';
+export { StatsBaseModule } from './statsBase.js';
+export { LoanBaseModule } from './loanBase.js';
+export { LeverageZapV1BaseModule } from './leverageZapV1Base.js';
+export { LeverageZapV2BaseModule } from './leverageZapV2Base.js';

package/lib/lendMarkets/modules/common/leverageZapV1Base.d.ts

@@ -0,0 +1,118 @@
+import memoize from "memoizee";
+import { TAmount, TGas, IDict } from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { Llamalend } from "../../../llamalend";
+/**
+ * LeverageZapV2 module for LendMarketTemplate
+ */
+export declare class LeverageZapV1BaseModule {
+    protected market: LendMarketTemplate;
+    protected llamalend: Llamalend;
+    constructor(market: LendMarketTemplate);
+    private _getMarketId;
+    hasLeverage: () => boolean;
+    private _checkLeverageZap;
+    private _get_k_effective_BN;
+    maxLeverage(N: number): Promise<string>;
+    leverageCreateLoanMaxRecv(userCollateral: TAmount, userBorrowed: TAmount, range: number): Promise<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        maxLeverage: string;
+        avgPrice: string;
+    }>;
+    leverageCreateLoanMaxRecvAllRanges: ((userCollateral: TAmount, userBorrowed: TAmount) => Promise<IDict<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        maxLeverage: string;
+        avgPrice: string;
+    }>>) & memoize.Memoized<(userCollateral: TAmount, userBorrowed: TAmount) => Promise<IDict<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        maxLeverage: string;
+        avgPrice: string;
+    }>>>;
+    private _setSwapDataToCache;
+    private _getSwapDataFromCache;
+    private _leverageExpectedCollateral;
+    leverageCreateLoanExpectedCollateral(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number): Promise<{
+        totalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromDebt: string;
+        leverage: string;
+        avgPrice: string;
+    }>;
+    leverageCreateLoanPriceImpact(userBorrowed: TAmount, debt: TAmount): Promise<string>;
+    leverageCreateLoanMaxRange(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount): Promise<number>;
+    private _leverageCalcN1;
+    private _leverageCalcN1AllRanges;
+    private _leverageBands;
+    private _leverageCreateLoanBandsAllRanges;
+    leverageCreateLoanBands(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number): Promise<[number, number]>;
+    leverageCreateLoanBandsAllRanges(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount): Promise<IDict<[number, number] | null>>;
+    leverageCreateLoanPrices(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number): Promise<string[]>;
+    leverageCreateLoanPricesAllRanges(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount): Promise<IDict<[string, string] | null>>;
+    private _leverageHealth;
+    leverageCreateLoanHealth(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, full?: boolean): Promise<string>;
+    leverageCreateLoanIsApproved(userCollateral: TAmount, userBorrowed: TAmount): Promise<boolean>;
+    leverageCreateLoanApproveEstimateGas(userCollateral: TAmount, userBorrowed: TAmount): Promise<TGas>;
+    leverageCreateLoanApprove(userCollateral: TAmount, userBorrowed: TAmount): Promise<string[]>;
+    leverageCreateLoanRouteImage(userBorrowed: TAmount, debt: TAmount): Promise<string>;
+    private _leverageCreateLoan;
+    leverageCreateLoanEstimateGas(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, slippage?: number): Promise<number>;
+    leverageCreateLoan(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, range: number, slippage?: number): Promise<string>;
+    leverageBorrowMoreMaxRecv(userCollateral: TAmount, userBorrowed: TAmount, address?: string): Promise<{
+        maxDebt: string;
+        maxTotalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromMaxDebt: string;
+        avgPrice: string;
+    }>;
+    leverageBorrowMoreExpectedCollateral(userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, slippage?: number, address?: string): Promise<{
+        totalCollateral: string;
+        userCollateral: string;
+        collateralFromUserBorrowed: string;
+        collateralFromDebt: string;
+        avgPrice: string;
+    }>;
+    leverageBorrowMorePriceImpact(userBorrowed: TAmount, dDebt: TAmount): Promise<string>;
+    leverageBorrowMoreBands(userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, address?: string): Promise<[number, number]>;
+    leverageBorrowMorePrices(userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, address?: string): Promise<string[]>;
+    leverageBorrowMoreHealth(userCollateral: TAmount, userBorrowed: TAmount, dDebt: TAmount, full?: boolean, address?: string): Promise<string>;
+    leverageBorrowMoreRouteImage(userBorrowed: TAmount, debt: TAmount): Promise<string>;
+    private _leverageBorrowMore;
+    leverageBorrowMoreEstimateGas(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number): Promise<number>;
+    leverageBorrowMore(userCollateral: TAmount, userBorrowed: TAmount, debt: TAmount, slippage?: number): Promise<string>;
+    private _leverageRepayExpectedBorrowed;
+    leverageRepayExpectedBorrowed: (stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number) => Promise<{
+        totalBorrowed: string;
+        borrowedFromStateCollateral: string;
+        borrowedFromUserCollateral: string;
+        userBorrowed: string;
+        avgPrice: string;
+    }>;
+    leverageRepayPriceImpact(stateCollateral: TAmount, userCollateral: TAmount): Promise<string>;
+    leverageRepayIsFull(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string): Promise<boolean>;
+    leverageRepayIsAvailable(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string): Promise<boolean>;
+    private _leverageRepayBands;
+    leverageRepayBands(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string): Promise<[number, number]>;
+    leverageRepayPrices(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, address?: string): Promise<string[]>;
+    leverageRepayHealth(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, full?: boolean, address?: string): Promise<string>;
+    leverageRepayIsApproved(userCollateral: TAmount, userBorrowed: TAmount): Promise<boolean>;
+    leverageRepayApproveEstimateGas(userCollateral: TAmount, userBorrowed: TAmount): Promise<TGas>;
+    leverageRepayApprove(userCollateral: TAmount, userBorrowed: TAmount): Promise<string[]>;
+    leverageRepayRouteImage(stateCollateral: TAmount, userCollateral: TAmount): Promise<string>;
+    private _leverageRepay;
+    leverageRepayEstimateGas(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number): Promise<number>;
+    leverageRepay(stateCollateral: TAmount, userCollateral: TAmount, userBorrowed: TAmount, slippage?: number): Promise<string>;
+}