@curvefi/llamalend-api 1.1.10 → 2.0.0

package/lib/lendMarkets/fetch/fetchFactoryData.d.ts

@@ -0,0 +1,13 @@
+import type { Llamalend } from "../../llamalend.js";
+export declare const getFactoryMarketDataV1: (llamalend: Llamalend) => Promise<Record<string, any>>;
+export declare const getFactoryMarketDataByAPI: (llamalend: Llamalend) => Promise<Record<string, string[]>>;
+export declare const getFactoryMarketDataV2: (llamalend: Llamalend) => Promise<{
+    names: string[];
+    amms: string[];
+    controllers: string[];
+    borrowed_tokens: string[];
+    collateral_tokens: string[];
+    monetary_policies: string[];
+    vaults: string[];
+    gauges: string[];
+}>;

package/lib/lendMarkets/fetch/fetchFactoryData.js

@@ -0,0 +1,101 @@
+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 { createCall, handleMultiCallResponse } from "../../utils.js";
+import { _getMarketsData } from "../../external-api.js";
+export const getFactoryMarketDataV1 = (llamalend) => __awaiter(void 0, void 0, void 0, function* () {
+    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 = yield factoryContract.market_count();
+    const callsMap = ['names', 'amms', 'controllers', 'borrowed_tokens', 'collateral_tokens', 'monetary_policies', 'vaults', 'gauges'];
+    const calls = [];
+    for (let i = 0; i < markets_count; i++) {
+        callsMap.forEach((item) => {
+            calls.push(createCall(factory, item, [i]));
+        });
+    }
+    const res = (yield llamalend.multicallProvider.all(calls)).map((addr) => addr.toLowerCase());
+    return handleMultiCallResponse(callsMap, res);
+});
+export const getFactoryMarketDataByAPI = (llamalend) => __awaiter(void 0, void 0, void 0, function* () {
+    const apiData = (yield _getMarketsData(llamalend.constants.NETWORK_NAME)).lendingVaultData;
+    const result = {
+        names: [],
+        amms: [],
+        controllers: [],
+        borrowed_tokens: [],
+        collateral_tokens: [],
+        monetary_policies: [],
+        vaults: [],
+        gauges: [],
+    };
+    apiData.forEach((market) => {
+        var _a;
+        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(((_a = market.gaugeAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || llamalend.constants.ZERO_ADDRESS);
+    });
+    return result;
+});
+export const getFactoryMarketDataV2 = (llamalend) => __awaiter(void 0, void 0, void 0, function* () {
+    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 = yield factoryContract.market_count();
+    const calls = [];
+    for (let i = 0; i < markets_count; i++) {
+        calls.push(createCall(factory, 'markets', [i]));
+        calls.push(createCall(factory, 'names', [i]));
+    }
+    const res = yield llamalend.multicallProvider.all(calls);
+    const names = [];
+    const vaults = [];
+    const controllers = [];
+    const amms = [];
+    const collateral_tokens = [];
+    const borrowed_tokens = [];
+    const monetary_policies = [];
+    const gauges = [];
+    for (let i = 0; i < markets_count; i++) {
+        const marketData = res[i * 2];
+        const name = res[(i * 2) + 1];
+        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/lib/lendMarkets/fetch/fetchLendMarkets.d.ts

@@ -0,0 +1,3 @@
+import type { Llamalend } from "../../llamalend.js";
+export declare const fetchOneWayMarketsByBlockchain: (llamalend: Llamalend, version?: "v1" | "v2") => Promise<void>;
+export declare const fetchOneWayMarketsByAPI: (llamalend: Llamalend, version?: "v1" | "v2") => Promise<void>;

package/lib/lendMarkets/fetch/fetchLendMarkets.js

@@ -0,0 +1,94 @@
+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 { 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, names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges, COIN_DATA, version) => {
+    amms.forEach((amm, index) => {
+        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 = (llamalend_1, ...args_1) => __awaiter(void 0, [llamalend_1, ...args_1], void 0, function* (llamalend, version = 'v1') {
+    const factoryData = version === 'v2'
+        ? yield getFactoryMarketDataV2(llamalend)
+        : yield getFactoryMarketDataV1(llamalend);
+    const { names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges } = factoryData;
+    const COIN_DATA = yield 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 = yield llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
+    }
+    else {
+        llamalend.constants.ONE_WAY_MARKETS = yield llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
+    }
+    yield llamalend.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens, version);
+});
+export const fetchOneWayMarketsByAPI = (llamalend_1, ...args_1) => __awaiter(void 0, [llamalend_1, ...args_1], void 0, function* (llamalend, version = 'v1') {
+    const { names, amms, controllers, borrowed_tokens, collateral_tokens, monetary_policies, vaults, gauges } = yield getFactoryMarketDataByAPI(llamalend);
+    const COIN_DATA = yield 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 = yield llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS_V2);
+    }
+    else {
+        llamalend.constants.ONE_WAY_MARKETS = yield llamalend._filterHiddenMarkets(llamalend.constants.ONE_WAY_MARKETS);
+    }
+});

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

@@ -0,0 +1,10 @@
+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/lib/lendMarkets/interfaces/common/amm.js

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

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

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

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

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

package/lib/lendMarkets/interfaces/common/prices.d.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/lib/lendMarkets/interfaces/common/prices.js

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

package/lib/lendMarkets/interfaces/common/userPosition.d.ts

@@ -0,0 +1,39 @@
+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/lib/lendMarkets/interfaces/common/userPosition.js

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

package/lib/lendMarkets/interfaces/common/vault.d.ts

@@ -0,0 +1,55 @@
+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/lib/lendMarkets/interfaces/common/vault.js

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

package/lib/lendMarkets/interfaces/common/wallet.d.ts

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

package/lib/lendMarkets/interfaces/common/wallet.js

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

package/lib/lendMarkets/interfaces/v1/index.d.ts

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

package/lib/lendMarkets/interfaces/v1/index.js

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

package/lib/lendMarkets/interfaces/v1/leverageV1.d.ts

@@ -0,0 +1,90 @@
+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/lib/lendMarkets/interfaces/v1/leverageV1.js

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

package/lib/lendMarkets/interfaces/v1/loanV1.d.ts

@@ -0,0 +1,73 @@
+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/lib/lendMarkets/interfaces/v1/loanV1.js

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

package/lib/lendMarkets/interfaces/v1/statsV1.d.ts

@@ -0,0 +1,49 @@
+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/lib/lendMarkets/interfaces/v1/statsV1.js

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

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

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

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

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