@curvefi/llamalend-api 1.1.10 → 2.0.1

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

@@ -0,0 +1,85 @@
+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: {
+        createLoanApprove: (collateral: TAmount) => Promise<TGas>;
+        createLoan: (collateral: TAmount, debt: TAmount, range: number) => Promise<TGas>;
+        borrowMoreApprove: (collateral: TAmount) => Promise<TGas>;
+        borrowMore: (collateral: TAmount, debt: TAmount) => Promise<TGas>;
+        addCollateralApprove: (collateral: TAmount) => Promise<TGas>;
+        addCollateral: (collateral: TAmount, address?: string) => Promise<TGas>;
+        removeCollateral: (collateral: TAmount) => Promise<TGas>;
+        repayApprove: (debt: TAmount) => Promise<TGas>;
+        repay: (debt: TAmount, address?: string) => Promise<TGas>;
+        fullRepayApprove: (address?: string) => Promise<TGas>;
+        fullRepay: (address?: string) => Promise<TGas>;
+        liquidateApprove: (address?: string) => Promise<TGas>;
+        liquidate: (address: string, slippage?: number) => Promise<TGas>;
+        selfLiquidateApprove: () => Promise<TGas>;
+        selfLiquidate: (slippage?: number) => Promise<TGas>;
+        partialSelfLiquidateApprove: (partialFrac: IPartialFrac) => Promise<TGas>;
+        partialSelfLiquidate: (partialFrac: IPartialFrac, slippage?: number) => Promise<TGas>;
+    };
+}

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

@@ -0,0 +1,21 @@
+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/src/lendMarkets/lendMarketConstructor.ts

@@ -3,7 +3,7 @@ import type { Llamalend } from "../llamalend.js";
 
 export const getLendMarket = function (this: Llamalend, lendMarketId: string): LendMarketTemplate {
     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/src/lendMarkets/modules/common/amm.ts

@@ -0,0 +1,132 @@
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import {
+    _cutZeros, _mulBy1_3,
+    BN, DIGas, ensureAllowance, ensureAllowanceEstimateGas,
+    formatUnits, fromBN,
+    hasAllowance, MAX_ALLOWANCE, parseUnits, smartNumber, toBN,
+} from "../../../utils";
+import {Llamalend} from "../../../llamalend";
+import BigNumber from "bignumber.js";
+import {TGas} from "../../../interfaces";
+import {IAmm} from "../../interfaces/common";
+
+
+export class AmmModule implements IAmm {
+    private market: LendMarketTemplate;
+    private llamalend: Llamalend;
+
+    constructor(market: LendMarketTemplate) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+
+    public async maxSwappable(i: number, j: number): Promise<string> {
+        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] = await contract.get_dxdy(i, j, MAX_ALLOWANCE, this.llamalend.constantOptions) as bigint[];
+        if (_outAmount === BigInt(0)) return "0";
+
+        return formatUnits(_inAmount, inDecimals)
+    }
+
+    private async _swapExpected(i: number, j: number, _amount: bigint): Promise<bigint> {
+        return await this.llamalend.contracts[this.market.addresses.amm].contract.get_dy(i, j, _amount, this.llamalend.constantOptions) as bigint;
+    }
+
+    public async swapExpected(i: number, j: number, amount: number | string): Promise<string> {
+        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 = await this._swapExpected(i, j, _amount);
+
+        return formatUnits(_expected, outDecimals)
+    }
+
+    public async swapRequired(i: number, j: number, outAmount: number | string): Promise<string> {
+        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 = await this.llamalend.contracts[this.market.addresses.amm].contract.get_dx(i, j, _amount, this.llamalend.constantOptions) as bigint;
+
+        return formatUnits(_expected, inDecimals)
+    }
+
+    public async swapPriceImpact(i: number, j: number, amount: number | string): Promise<string> {
+        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 = await 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(10 ** 15);
+        const amountIntBN = BN(amount).times(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(10 ** inDecimals));
+        if (smallAmountIntBN.toFixed(0) === '0') return '0';
+
+        const _smallAmount = fromBN(smallAmountIntBN.div(10 ** inDecimals), inDecimals);
+        const _smallOutput = await 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));
+    }
+
+    public async swapIsApproved(i: number, amount: number | string): Promise<boolean> {
+        if (i !== 0 && i !== 1) throw Error("Wrong index");
+
+        return await hasAllowance.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.llamalend.signerAddress, this.market.addresses.amm);
+    }
+
+    private async swapApproveEstimateGas (i: number, amount: number | string): Promise<TGas> {
+        if (i !== 0 && i !== 1) throw Error("Wrong index");
+
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.market.addresses.amm);
+    }
+
+    public async swapApprove(i: number, amount: number | string): Promise<string[]> {
+        if (i !== 0 && i !== 1) throw Error("Wrong index");
+
+        return await ensureAllowance.call(this.llamalend, [this.market.coinAddresses[i]], [amount], this.market.addresses.amm);
+    }
+
+    private async _swap(i: number, j: number, amount: number | string, slippage: number, estimateGas: boolean): Promise<string | TGas> {
+        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 = await this._swapExpected(i, j, _amount);
+        const minRecvAmountBN: BigNumber = 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 = await contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, this.llamalend.constantOptions);
+        if (estimateGas) return smartNumber(gas);
+
+        await this.llamalend.updateFeeData();
+        const gasLimit = _mulBy1_3(DIGas(gas));
+        return (await contract.exchange(i, j, _amount, _minRecvAmount, { ...this.llamalend.options, gasLimit })).hash
+    }
+
+    public async swapEstimateGas(i: number, j: number, amount: number | string, slippage = 0.1): Promise<TGas> {
+        if (!(await this.swapIsApproved(i, amount))) throw Error("Approval is needed for gas estimation");
+        return await this._swap(i, j, amount, slippage, true) as TGas;
+    }
+
+    public async swap(i: number, j: number, amount: number | string, slippage = 0.1): Promise<string> {
+        await this.swapApprove(i, amount);
+        return await this._swap(i, j, amount, slippage, false) as string;
+    }
+}

package/src/lendMarkets/modules/common/index.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';