@curvefi/llamalend-api 1.1.10 → 2.0.0

package/src/lendMarkets/fetch/fetchFactoryData.ts

@@ -0,0 +1,113 @@
+import { Call } from "@curvefi/ethcall";
+import { createCall, handleMultiCallResponse } from "../../utils.js";
+import { IMarketDataAPI } from "../../interfaces.js";
+import { _getMarketsData } from "../../external-api.js";
+import type { Llamalend } from "../../llamalend.js";
+
+export const getFactoryMarketDataV1 = async (llamalend: Llamalend) => {
+    const factoryAlias = 'one_way_factory';
+
+    if (!llamalend.constants.ALIASES[factoryAlias] || llamalend.constants.ALIASES[factoryAlias] === llamalend.constants.ZERO_ADDRESS) {
+        throw new Error(`Factory v1 is not available for network ${llamalend.constants.NETWORK_NAME}`);
+    }
+
+    const factoryAddress = llamalend.constants.ALIASES[factoryAlias];
+    const factory = llamalend.contracts[factoryAddress];
+    const factoryContract = factory.contract;
+    const markets_count = await factoryContract.market_count();
+    const callsMap = ['names', 'amms', 'controllers', 'borrowed_tokens', 'collateral_tokens', 'monetary_policies', 'vaults', 'gauges']
+
+    const calls: Call[] = [];
+    for (let i = 0; i < markets_count; i++) {
+        callsMap.forEach((item) => {
+            calls.push(createCall(factory, item, [i]))
+        })
+    }
+    const res = (await llamalend.multicallProvider.all(calls) as string[]).map((addr) => addr.toLowerCase());
+
+    return handleMultiCallResponse(callsMap, res)
+};
+
+export const getFactoryMarketDataByAPI = async (llamalend: Llamalend) => {
+    const apiData = (await _getMarketsData(llamalend.constants.NETWORK_NAME)).lendingVaultData;
+
+    const result: Record<string, string[]> = {
+        names: [],
+        amms: [],
+        controllers: [],
+        borrowed_tokens: [],
+        collateral_tokens: [],
+        monetary_policies: [],
+        vaults: [],
+        gauges: [],
+    };
+
+    apiData.forEach((market: IMarketDataAPI) => {
+        result.names.push(market.name);
+        result.amms.push(market.ammAddress.toLowerCase());
+        result.controllers.push(market.controllerAddress.toLowerCase());
+        result.borrowed_tokens.push(market.assets.borrowed.address.toLowerCase());
+        result.collateral_tokens.push(market.assets.collateral.address.toLowerCase());
+        result.monetary_policies.push(market.monetaryPolicyAddress.toLowerCase());
+        result.vaults.push(market.address.toLowerCase());
+        result.gauges.push(market.gaugeAddress?.toLowerCase() || llamalend.constants.ZERO_ADDRESS);
+    });
+
+    return result;
+};
+
+export const getFactoryMarketDataV2 = async (llamalend: Llamalend) => {
+    const factoryAlias = 'one_way_factory_v2';
+
+    if (!llamalend.constants.ALIASES[factoryAlias] || llamalend.constants.ALIASES[factoryAlias] === llamalend.constants.ZERO_ADDRESS) {
+        throw new Error(`Factory v2 is not available for network ${llamalend.constants.NETWORK_NAME}`);
+    }
+
+    const factoryAddress = llamalend.constants.ALIASES[factoryAlias];
+    const factory = llamalend.contracts[factoryAddress];
+    const factoryContract = factory.contract;
+    const markets_count = await factoryContract.market_count();
+
+    const calls: Call[] = [];
+
+    for (let i = 0; i < markets_count; i++) {
+        calls.push(createCall(factory, 'markets', [i]));
+        calls.push(createCall(factory, 'names', [i]));
+    }
+
+    const res = await llamalend.multicallProvider.all(calls);
+
+    const names: string[] = [];
+    const vaults: string[] = [];
+    const controllers: string[] = [];
+    const amms: string[] = [];
+    const collateral_tokens: string[] = [];
+    const borrowed_tokens: string[] = [];
+    const monetary_policies: string[] = [];
+    const gauges: string[] = [];
+
+    for (let i = 0; i < markets_count; i++) {
+        const marketData = res[i * 2] as any;
+        const name = res[(i * 2) + 1] as string;
+
+        vaults.push(marketData[0].toLowerCase());
+        controllers.push(marketData[1].toLowerCase());
+        amms.push(marketData[2].toLowerCase());
+        collateral_tokens.push(marketData[3].toLowerCase());
+        borrowed_tokens.push(marketData[4].toLowerCase());
+        monetary_policies.push(marketData[6].toLowerCase());
+        names.push(name);
+        gauges.push(llamalend.constants.ZERO_ADDRESS);
+    }
+
+    return {
+        names,
+        amms,
+        controllers,
+        borrowed_tokens,
+        collateral_tokens,
+        monetary_policies,
+        vaults,
+        gauges,
+    };
+};

package/src/lendMarkets/fetch/fetchLendMarkets.ts

@@ -0,0 +1,108 @@
+import type { Llamalend } from "../../llamalend.js";
+import type { ICoin, IDict } from "../../interfaces.js";
+import { getFactoryMarketDataV1, getFactoryMarketDataV2, getFactoryMarketDataByAPI } from "./fetchFactoryData.js";
+
+import LlammaABI from '../../constants/abis/Llamma.json' with {type: 'json'};
+import ControllerABI from '../../constants/abis/Controller.json' with {type: 'json'};
+import MonetaryPolicyABI from '../../constants/abis/MonetaryPolicy.json' with {type: 'json'};
+import VaultABI from '../../constants/abis/Vault.json' with {type: 'json'};
+import GaugeABI from '../../constants/abis/GaugeV5.json' with {type: 'json'};
+import SidechainGaugeABI from '../../constants/abis/SidechainGauge.json' with {type: 'json'};
+
+const registerMarkets = (
+    llamalend: Llamalend,
+    names: string[],
+    amms: string[],
+    controllers: string[],
+    borrowed_tokens: string[],
+    collateral_tokens: string[],
+    monetary_policies: string[],
+    vaults: string[],
+    gauges: string[],
+    COIN_DATA: IDict<ICoin>,
+    version: 'v1' | 'v2'
+) => {
+    amms.forEach((amm: string, index: number) => {
+        llamalend.setContract(amms[index], LlammaABI);
+        llamalend.setContract(controllers[index], ControllerABI);
+        llamalend.setContract(monetary_policies[index], MonetaryPolicyABI);
+        llamalend.setContract(vaults[index], VaultABI);
+        if (gauges[index]) {
+            llamalend.setContract(gauges[index], llamalend.chainId === 1 ? GaugeABI : SidechainGaugeABI);
+        }
+        COIN_DATA[vaults[index]] = {
+            address: vaults[index],
+            decimals: 18,
+            name: "Curve Vault for " + COIN_DATA[borrowed_tokens[index]].name,
+            symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol,
+        };
+        COIN_DATA[gauges[index]] = {
+            address: gauges[index],
+            decimals: 18,
+            name: "curve.finance " + COIN_DATA[borrowed_tokens[index]].name + " Gauge Deposit",
+            symbol: "cv" + COIN_DATA[borrowed_tokens[index]].symbol + "-gauge",
+        };
+        llamalend.constants.DECIMALS[vaults[index]] = 18;
+        llamalend.constants.DECIMALS[gauges[index]] = 18;
+
+        const marketData = {
+            name: names[index],
+            version: version,
+            addresses: {
+                amm: amms[index],
+                controller: controllers[index],
+                borrowed_token: borrowed_tokens[index],
+                collateral_token: collateral_tokens[index],
+                monetary_policy: monetary_policies[index],
+                vault: vaults[index],
+                gauge: gauges[index],
+            },
+            borrowed_token: COIN_DATA[borrowed_tokens[index]],
+            collateral_token: COIN_DATA[collateral_tokens[index]],
+        };
+
+        if (version === 'v2') {
+            llamalend.constants.ONE_WAY_MARKETS_V2[`one-way-market-v2-${index}`] = marketData;
+        } else {
+            llamalend.constants.ONE_WAY_MARKETS[`one-way-market-${index}`] = marketData;
+        }
+    });
+};
+
+export const fetchOneWayMarketsByBlockchain = async (llamalend: Llamalend, version: 'v1' | 'v2' = 'v1') => {
+    const factoryData = version === 'v2'
+        ? await getFactoryMarketDataV2(llamalend)
+        : await getFactoryMarketDataV1(llamalend);
+
+    const { names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges } = factoryData;
+    const COIN_DATA = await llamalend.getCoins(collateral_tokens, borrowed_tokens);
+    for (const c in COIN_DATA) {
+        llamalend.constants.DECIMALS[c] = COIN_DATA[c].decimals;
+    }
+
+    registerMarkets(llamalend, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, version);
+
+    if (version === 'v2') {
+        llamalend.constants.ONE_WAY_MARKETS_V2 = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
+    } else {
+        llamalend.constants.ONE_WAY_MARKETS = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
+    }
+
+    await llamalend.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens, version);
+};
+
+export const fetchOneWayMarketsByAPI = async (llamalend: Llamalend, version: 'v1' | 'v2' = 'v1') => {
+    const { names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges } = await getFactoryMarketDataByAPI(llamalend);
+    const COIN_DATA = await llamalend.getCoins(collateral_tokens, borrowed_tokens, true);
+    for (const c in COIN_DATA) {
+        llamalend.constants.DECIMALS[c] = COIN_DATA[c].decimals;
+    }
+
+    registerMarkets(llamalend, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, version);
+
+    if (version === 'v2') {
+        llamalend.constants.ONE_WAY_MARKETS_V2 = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
+    } else {
+        llamalend.constants.ONE_WAY_MARKETS = await llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
+    }
+};

package/src/lendMarkets/interfaces/common/amm.ts

@@ -0,0 +1,11 @@
+import {TAmount} from "../../../interfaces";
+
+export interface IAmm {
+    maxSwappable: (i: number, j: number) => Promise<string>;
+    swapExpected: (i: number, j: number, amount: TAmount) => Promise<string>;
+    swapRequired: (i: number, j: number, outAmount: TAmount) => Promise<string>;
+    swapPriceImpact: (i: number, j: number, amount: TAmount) => Promise<string>;
+    swapIsApproved: (i: number, amount: TAmount) => Promise<boolean>;
+    swapApprove: (i: number, amount: TAmount) => Promise<string[]>;
+    swap: (i: number, j: number, amount: TAmount, slippage?: number) => Promise<string>;
+}

package/src/lendMarkets/interfaces/common/index.ts

@@ -0,0 +1,5 @@
+export * from './userPosition';
+export * from './wallet';
+export * from './amm';
+export * from './prices'
+export * from './vault';

package/src/lendMarkets/interfaces/common/prices.ts

@@ -0,0 +1,13 @@
+export interface IPrices {
+    A: () => Promise<string>;
+    basePrice: () => Promise<string>;
+    oraclePrice: () => Promise<string>;
+    oraclePriceBand: () => Promise<number>;
+    price: () => Promise<string>;
+    calcTickPrice: (n: number) => Promise<string>;
+    calcBandPrices: (n: number) => Promise<[string, string]>;
+    calcRangePct: (range: number) => Promise<string>;
+    getPrices: (_n2: bigint, _n1: bigint) => Promise<[string,string]>;
+    calcPrices: (_n2: bigint, _n1: bigint) => Promise<[string, string]>;
+    checkRange: (range: number) => void;
+}

package/src/lendMarkets/interfaces/common/userPosition.ts

@@ -0,0 +1,24 @@
+import {IDict} from "../../../interfaces";
+
+export interface IUserPosition {
+    userLoanExists: (address?: string) => Promise<boolean>,
+    userStateBigInt: (address?: string) => Promise<{ _collateral: bigint, _borrowed: bigint, _debt: bigint, _N: bigint }>,
+    userBandsBigInt:(address: string) => Promise<bigint[]>,
+    userState: (address?: string) => Promise<{ collateral: string, borrowed: string, debt: string, N: string }>,
+    userHealth: (full?: boolean, address?: string) => Promise<string>,
+    userBands: (address?: string) => Promise<number[]>,
+    userRange: (address?: string) => Promise<number>,
+    userPrices: (address?: string) => Promise<string[]>,
+    userLoss: (userAddress?: string) => Promise<{ 
+        deposited_collateral: string, 
+        current_collateral_estimation: string, 
+        loss: string, 
+        loss_pct: string 
+    }>,
+    userBandsBalances: (address?: string) => Promise<IDict<{ collateral: string, borrowed: string }>>,
+    currentLeverage: (userAddress?: string) => Promise<string>,
+    currentPnL: (userAddress?: string) => Promise<Record<string, string>>,
+    userBoost: (address?: string) => Promise<string>,
+    forceUpdateUserState: (newTx: string, userAddress?: string) => Promise<void>,
+    getCurrentLeverageParams: (userAddress: string) => Promise<{ stateCollateral: string, totalDepositFromUser: string }>,
+}

package/src/lendMarkets/interfaces/common/vault.ts

@@ -0,0 +1,48 @@
+import {IReward, TAmount, TGas} from "../../../interfaces";
+
+export interface IVault {
+    maxDeposit: (address?: string) => Promise<string>,
+    previewDeposit: (amount: TAmount) => Promise<string>,
+    depositIsApproved: (borrowed: TAmount) => Promise<boolean>
+    depositApprove: (borrowed: TAmount) => Promise<string[]>
+    deposit: (amount: TAmount) => Promise<string>,
+    maxMint: (address?: string) => Promise<string>,
+    previewMint: (amount: TAmount) => Promise<string>,
+    mintIsApproved: (borrowed: TAmount) => Promise<boolean>
+    mintApprove: (borrowed: TAmount) => Promise<string[]>
+    mint: (amount: TAmount) => Promise<string>,
+    maxWithdraw: (address?: string) => Promise<string>,
+    previewWithdraw: (amount: TAmount) => Promise<string>,
+    withdraw: (amount: TAmount) => Promise<string>,
+    maxRedeem: (address?: string) => Promise<string>,
+    previewRedeem: (amount: TAmount) => Promise<string>,
+    redeem: (amount: TAmount) => Promise<string>,
+    convertToShares: (assets: TAmount) => Promise<string>,
+    convertToAssets: (shares: TAmount) => Promise<string>,
+    stakeIsApproved: (vaultShares: number | string) => Promise<boolean>,
+    stakeApprove: (vaultShares: number | string) => Promise<string[]>,
+    stake: (vaultShares: number | string) => Promise<string>,
+    unstake: (vaultShares: number | string) => Promise<string>,
+    rewardsOnly: () => boolean,
+    totalLiquidity: () => Promise<string>,
+    crvApr: (useApi?: boolean) => Promise<[baseApy: number, boostedApy: number]>,
+    claimableCrv: (address?: string) => Promise<string>,
+    claimCrv: () => Promise<string>,
+    rewardTokens: (useApi?: boolean) => Promise<{token: string, symbol: string, decimals: number}[]>,
+    rewardsApr: (useApi?: boolean) => Promise<IReward[]>,
+    claimableRewards: (address?: string) => Promise<{token: string, symbol: string, amount: string}[]>,
+    claimRewards: () => Promise<string>,
+    estimateGas: {
+        depositApprove: (amount: TAmount) => Promise<TGas>,
+        deposit: (amount: TAmount) => Promise<TGas>,
+        mintApprove: (amount: TAmount) => Promise<TGas>,
+        mint: (amount: TAmount) => Promise<TGas>,
+        withdraw: (amount: TAmount) => Promise<TGas>,
+        redeem: (amount: TAmount) => Promise<TGas>,
+        stakeApprove: (vaultShares: number | string) => Promise<TGas>,
+        stake: (vaultShares: number | string) => Promise<TGas>,
+        unstake: (vaultShares: number | string) => Promise<TGas>,
+        claimCrv: () => Promise<TGas>,
+        claimRewards: () => Promise<TGas>,
+    }
+}

package/src/lendMarkets/interfaces/common/wallet.ts

@@ -0,0 +1,3 @@
+export interface IWallet {
+    balances: (address?: string) => Promise<{ collateral: string, borrowed: string, vaultShares: string, gauge: string }>,
+}

package/src/lendMarkets/interfaces/v1/index.ts

@@ -0,0 +1,4 @@
+export * from './statsV1';
+export * from '../common/vault';
+export * from './loanV1';
+export * from './leverageV1';

package/src/lendMarkets/interfaces/v1/leverageV1.ts

@@ -0,0 +1,84 @@
+import {TAmount, TGas, IDict} from "../../../interfaces";
+
+export interface ILeverageV1 {
+    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/src/lendMarkets/interfaces/v1/loanV1.ts

@@ -0,0 +1,77 @@
+import {TAmount, TGas, IPartialFrac} from "../../../interfaces";
+
+export interface ILoanV1 {
+    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/src/lendMarkets/interfaces/v1/statsV1.ts

@@ -0,0 +1,21 @@
+import {TAmount} from "../../../interfaces";
+
+export interface IStatsV1 {
+    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/src/lendMarkets/interfaces/v2/index.ts

@@ -0,0 +1,3 @@
+export * from './statsV2';
+export * from './loanV2';
+export * from './leverageV2';

package/src/lendMarkets/interfaces/v2/leverageV2.ts

@@ -0,0 +1,84 @@
+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>;
+    };
+}