@curvefi/llamalend-api 1.0.2

package/src/external-api.ts

@@ -0,0 +1,325 @@
+import axios from "axios";
+import { ethers } from "ethers";
+import memoize from "memoizee";
+import BigNumber from 'bignumber.js';
+import { llamalend } from "./llamalend.js";
+import {
+    IExtendedPoolDataFromApi,
+    INetworkName,
+    IPoolFactory,
+    I1inchSwapData,
+    IDict,
+    IMarketData,
+    IQuoteOdos,
+} from "./interfaces";
+
+
+const _getPoolsFromApi = memoize(
+    async (network: INetworkName, poolFactory: IPoolFactory ): Promise<IExtendedPoolDataFromApi> => {
+        const url = `https://api.curve.fi/api/getPools/${network}/${poolFactory}`;
+        const response = await axios.get(url, { validateStatus: () => true });
+        return response.data.data ?? { poolData: [], tvl: 0, tvlAll: 0 };
+    },
+    {
+        promise: true,
+        maxAge: 5 * 60 * 1000, // 5m
+    }
+)
+
+const _getAllPoolsFromApi = async (network: INetworkName): Promise<IExtendedPoolDataFromApi[]> => {
+    return await Promise.all([
+        _getPoolsFromApi(network, "main"),
+        _getPoolsFromApi(network, "crypto"),
+        _getPoolsFromApi(network, "factory"),
+        _getPoolsFromApi(network, "factory-crvusd"),
+        _getPoolsFromApi(network, "factory-crypto"),
+        _getPoolsFromApi(network, "factory-twocrypto"),
+        _getPoolsFromApi(network, "factory-tricrypto"),
+        _getPoolsFromApi(network, "factory-stable-ng"),
+    ]);
+}
+
+export const _getUsdPricesFromApi = async (): Promise<IDict<number>> => {
+    const network = llamalend.constants.NETWORK_NAME;
+    const allTypesExtendedPoolData = await _getAllPoolsFromApi(network);
+    const priceDict: IDict<Record<string, number>[]> = {};
+    const priceDictByMaxTvl: IDict<number> = {};
+
+    for (const extendedPoolData of allTypesExtendedPoolData) {
+        for (const pool of extendedPoolData.poolData) {
+            const lpTokenAddress = pool.lpTokenAddress ?? pool.address;
+            const totalSupply = pool.totalSupply / (10 ** 18);
+            if(lpTokenAddress.toLowerCase() in priceDict) {
+                priceDict[lpTokenAddress.toLowerCase()].push({
+                    price: pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0,
+                    tvl: pool.usdTotal,
+                })
+            } else {
+                priceDict[lpTokenAddress.toLowerCase()] = []
+                priceDict[lpTokenAddress.toLowerCase()].push({
+                    price: pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0,
+                    tvl: pool.usdTotal,
+                })
+            }
+
+            for (const coin of pool.coins) {
+                if (typeof coin.usdPrice === "number") {
+                    if(coin.address.toLowerCase() in priceDict) {
+                        priceDict[coin.address.toLowerCase()].push({
+                            price: coin.usdPrice,
+                            tvl: pool.usdTotal,
+                        })
+                    } else {
+                        priceDict[coin.address.toLowerCase()] = []
+                        priceDict[coin.address.toLowerCase()].push({
+                            price: coin.usdPrice,
+                            tvl: pool.usdTotal,
+                        })
+                    }
+                }
+            }
+
+            for (const coin of pool.gaugeRewards ?? []) {
+                if (typeof coin.tokenPrice === "number") {
+                    if(coin.tokenAddress.toLowerCase() in priceDict) {
+                        priceDict[coin.tokenAddress.toLowerCase()].push({
+                            price: coin.tokenPrice,
+                            tvl: pool.usdTotal,
+                        });
+                    } else {
+                        priceDict[coin.tokenAddress.toLowerCase()] = []
+                        priceDict[coin.tokenAddress.toLowerCase()].push({
+                            price: coin.tokenPrice,
+                            tvl: pool.usdTotal,
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    for(const address in priceDict) {
+        if(priceDict[address].length > 0) {
+            const maxTvlItem = priceDict[address].reduce((prev, current) => {
+                if (+current.tvl > +prev.tvl) {
+                    return current;
+                } else {
+                    return prev;
+                }
+            });
+            priceDictByMaxTvl[address] = maxTvlItem.price
+        } else {
+            priceDictByMaxTvl[address] = 0
+        }
+
+    }
+
+    return priceDictByMaxTvl
+}
+
+export const _getUserCollateral = memoize(
+    async (network: INetworkName, controller: string, user: string): Promise<Record<string, any>> => {
+        const url = `https://prices.curve.fi/v1/lending/collateral_events/${network}/${controller}/${user}`;
+        const response = await axios.get(url, { validateStatus: () => true });
+        return {
+            total_deposit_precise: response.data.total_deposit_precise,
+            total_deposit_from_user: response.data.total_deposit_from_user,
+            total_deposit_usd_value: response.data.total_deposit_usd_value,
+        }
+    },
+    {
+        promise: true,
+        maxAge: 60 * 1000, // 1m
+    }
+)
+
+export const _getUserCollateralCrvUsd = memoize(
+    async (network: INetworkName, controller: string, user: string): Promise<string> => {
+        const url = `https://prices.curve.fi/v1/crvusd/collateral_events/${network}/${controller}/${user}`;
+        const response = await axios.get(url, { validateStatus: () => true });
+        return response.data.total_deposit;
+    },
+    {
+        promise: true,
+        maxAge: 60 * 1000, // 1m
+    }
+)
+
+export const _getMarketsData = memoize(
+    async (network: INetworkName): Promise<IMarketData> => {
+        const url = `https://api.curve.fi/api/getLendingVaults/${network}/oneway`;
+        const response = await axios.get(
+            url,
+            {
+                headers: {"accept": "application/json"},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`Fetch error: ${response.status} ${response.statusText}`);
+        }
+        return response.data.data;
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
+// --- ODOS ---
+
+export const _getQuoteOdos = async (fromToken: string, toToken: string, _amount: bigint, blacklist: string, pathVizImage: boolean, slippage = 0.5): Promise<IQuoteOdos> => {
+    if (_amount === BigInt(0)) return { outAmounts: ["0.0"], pathId: '', pathVizImage: '', priceImpact: 0, slippage };
+
+    if (ethers.getAddress(fromToken) == "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") fromToken = "0x0000000000000000000000000000000000000000";
+    if (ethers.getAddress(toToken) == "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") toToken = "0x0000000000000000000000000000000000000000";
+
+    const url = `https://prices.curve.fi/odos/quote?chain_id=${llamalend.chainId}&from_address=${ethers.getAddress(fromToken)}` +
+        `&to_address=${ethers.getAddress(toToken)}&amount=${_amount.toString()}&slippage=${slippage}&pathVizImage=${pathVizImage}` +
+        `&caller_address=${ethers.getAddress(llamalend.constants.ALIASES.leverage_zap)}&blacklist=${ethers.getAddress(blacklist)}`;
+
+    const response = await axios.get(
+        url,
+        {
+            headers: {"accept": "application/json"},
+            validateStatus: () => true,
+        });
+    if (response.status !== 200) {
+        throw Error(`Odos quote error - ${response.status} ${response.statusText}`);
+    }
+
+    return { ...response.data, slippage };
+}
+
+export const _getExpectedOdos = async (fromToken: string, toToken: string, _amount: bigint, blacklist: string) => {
+    return (await _getQuoteOdos(fromToken, toToken, _amount, blacklist, false)).outAmounts[0]
+}
+
+export const _assembleTxOdos = memoize(
+    async (pathId: string): Promise<string> => {
+        const url = `https://prices.curve.fi/odos/assemble?user=${ethers.getAddress(llamalend.constants.ALIASES.leverage_zap)}&path_id=${pathId}`;
+
+        const response = await axios.get(
+            url,
+            {
+                headers: {'Content-Type': 'application/json'},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`Odos assemble error - ${response.status} ${response.statusText}`);
+        }
+
+        return response.data['transaction']['data'];
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
+export const _getSpotPriceOdos = memoize(
+    async (fromToken: string, toToken: string): Promise<string | undefined> => {
+        fromToken = ethers.getAddress(fromToken);
+        toToken = ethers.getAddress(toToken);
+        const url = `https://prices.curve.fi/odos/prices?chain_id=${llamalend.chainId}&tokens=${fromToken},${toToken}`;
+        const response = await axios.get(
+            url,
+            {
+                headers: {"accept": "application/json"},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`Odos spot prices error - ${response.status} ${response.statusText}`);
+        }
+
+        const pricesFromOdos = response.data.tokenPrices;
+        const pricesFromApi: IDict<string> = {};
+        for (const coin of [fromToken, toToken]) {
+            if (pricesFromOdos[coin] !== 0) continue;
+            const _pricesFromApi = await _getUsdPricesFromApi();
+            pricesFromApi[coin] = String(_pricesFromApi[coin] || 0);
+        }
+        const prices = { ...pricesFromOdos, ...pricesFromApi };
+        if (BigNumber(prices[fromToken]).eq(0) || BigNumber(prices[toToken]).eq( 0)) return undefined;
+
+        return (new BigNumber(prices[toToken])).div(prices[fromToken]).toString()
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
+// --- 1INCH ---
+
+export const _getExpected1inch = memoize(
+    async (fromToken: string, toToken: string, _amount: bigint): Promise<string> => {
+        if (_amount === BigInt(0)) return "0.0";
+        const url = `https://prices.curve.fi/1inch/swap/v6.0/${llamalend.chainId}/quote?src=${fromToken}&dst=${toToken}&amount=${_amount}&excludedProtocols=${llamalend.constants.EXCLUDED_PROTOCOLS_1INCH}&includeTokensInfo=true&includeProtocols=true`;
+        const response = await axios.get(
+            url,
+            {
+                headers: {"accept": "application/json"},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`1inch error: ${response.status} ${response.statusText}`);
+        }
+        return response.data.dstAmount;
+
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
+export const _getSwapData1inch = memoize(
+    async (fromToken: string, toToken: string, _amount: bigint, slippage: number): Promise<I1inchSwapData> => {
+        if (_amount === BigInt(0)) throw Error("Amount must be > 0");
+        const url = `https://prices.curve.fi/1inch/swap/v6.0/${llamalend.chainId}/swap?src=${fromToken}&dst=${toToken}&amount=${_amount}&from_=${llamalend.constants.ALIASES.leverage_zap}&slippage=${slippage}&excludedProtocols=${llamalend.constants.EXCLUDED_PROTOCOLS_1INCH}&includeTokensInfo=true&includeProtocols=true&disableEstimate=true`;
+        const response = await axios.get(
+            url,
+            {
+                headers: {"accept": "application/json"},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`1inch error: ${response.status} ${response.statusText}`);
+        }
+        return response.data;
+
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)
+
+export const _getSpotPrice1inch = memoize(
+    async (fromToken: string, toToken: string): Promise<string | undefined> => {
+        const url = `https://prices.curve.fi/1inch/price/v1.1/${llamalend.chainId}?tokens=${fromToken},${toToken}&currency=USD`;
+        const response = await axios.get(
+            url,
+            {
+                headers: {"accept": "application/json"},
+                validateStatus: () => true,
+            });
+        if (response.status !== 200) {
+            throw Error(`1inch error: ${response.status} ${response.statusText}`);
+        }
+        const pricesFromApi: IDict<string> = {};
+        for (const coin in response.data) {
+            if (response.data[coin] !== "0") continue;
+            const _pricesFromApi = await _getUsdPricesFromApi();
+            pricesFromApi[coin] = String(_pricesFromApi[coin] || 0);
+        }
+        const prices = { ...response.data, ...pricesFromApi };
+        if (prices[fromToken] === '0' || prices[toToken] === '0') return undefined;
+
+        return (new BigNumber(prices[toToken])).div(prices[fromToken]).toString()
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    }
+)

package/src/index.ts

@@ -0,0 +1,128 @@
+import { ethers, Networkish } from "ethers";
+import { LendMarketTemplate, getLendMarket } from "./lendMarkets/index.js";
+import { MintMarketTemplate, getMintMarket} from "./mintMarkets/index.js";
+import { llamalend as _llamalend} from "./llamalend.js";
+import {
+    getBalances,
+    getAllowance,
+    hasAllowance,
+    ensureAllowanceEstimateGas,
+    ensureAllowance,
+    getUsdRate,
+    getGasPriceFromL2,
+    getGasInfoForL2,
+    getGasPriceFromL1,
+    totalSupply,
+    getLsdApy,
+} from "./utils.js";
+import {
+    convertToAssets,
+    convertToShares,
+    userBalances,
+    totalSupplyAndCrvUSDLocked,
+    maxDeposit,
+    previewDeposit,
+    depositIsApproved,
+    depositAllowance,
+    depositApproveEstimateGas,
+    depositApprove,
+    depositEstimateGas,
+    deposit,
+    maxMint,
+    previewMint,
+    mintIsApproved,
+    mintAllowance,
+    mintApproveEstimateGas,
+    mintApprove,
+    mintEstimateGas,
+    mint,
+    maxWithdraw,
+    previewWithdraw,
+    withdrawEstimateGas,
+    withdraw,
+    maxRedeem,
+    previewRedeem,
+    redeemEstimateGas,
+    redeem,
+} from "./st-crvUSD.js";
+
+
+async function init (
+    providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy',
+    providerSettings: { url?: string, privateKey?: string, batchMaxCount? : number } | { externalProvider: ethers.Eip1193Provider } | { network?: Networkish, apiKey?: string },
+    options: { gasPrice?: number, maxFeePerGas?: number, maxPriorityFeePerGas?: number, chainId?: number } = {}
+): Promise<void> {
+    await _llamalend.init(providerType, providerSettings, options);
+    // @ts-ignore
+    this.signerAddress = _llamalend.signerAddress;
+    // @ts-ignore
+    this.chainId = _llamalend.chainId;
+}
+
+function setCustomFeeData (customFeeData: { gasPrice?: number, maxFeePerGas?: number, maxPriorityFeePerGas?: number }): void {
+    _llamalend.setCustomFeeData(customFeeData);
+}
+
+const llamalend = {
+    init,
+    chainId: 0,
+    signerAddress: '',
+    LendMarketTemplate,
+    getLendMarket,
+    MintMarketTemplate,
+    getMintMarket,
+    totalSupply,
+    getLsdApy,
+    setCustomFeeData,
+    getBalances,
+    getAllowance,
+    hasAllowance,
+    ensureAllowance,
+    getUsdRate,
+    getGasPriceFromL1,
+    getGasPriceFromL2,
+    getGasInfoForL2,
+    fetchStats: _llamalend.fetchStats,
+    getLlammaList: _llamalend.getMintMarketList,
+    lendMarkets: {
+        fetchMarkets:  _llamalend.fetchLendMarkets,
+        getMarketList: _llamalend.getLendMarketList,
+    },
+    estimateGas: {
+        ensureAllowance: ensureAllowanceEstimateGas,
+    },
+    st_crvUSD: {
+        convertToAssets,
+        convertToShares,
+        userBalances,
+        totalSupplyAndCrvUSDLocked,
+        maxDeposit,
+        previewDeposit,
+        depositIsApproved,
+        depositAllowance,
+        depositApprove,
+        deposit,
+        maxMint,
+        previewMint,
+        mintIsApproved,
+        mintAllowance,
+        mintApprove,
+        mint,
+        maxWithdraw,
+        previewWithdraw,
+        withdraw,
+        maxRedeem,
+        previewRedeem,
+        redeem,
+        estimateGas: {
+            depositApprove: depositApproveEstimateGas,
+            deposit: depositEstimateGas,
+            mintApprove: mintApproveEstimateGas,
+            mint: mintEstimateGas,
+            withdraw: withdrawEstimateGas,
+            redeem: redeemEstimateGas,
+        },
+    },
+}
+
+export default llamalend;

package/src/interfaces.ts

@@ -0,0 +1,237 @@
+import { Contract, ethers } from "ethers";
+import { Contract as MulticallContract, Provider as MulticallProvider } from "@curvefi/ethcall";
+
+export interface IDict<T> {
+    [index: string]: T,
+}
+
+export type INetworkName = "ethereum" | "optimism" | "bsc" | "xdai" | "polygon" | "x-layer" | "fantom" | "fraxtal" | "zksync" | "moonbeam" | "kava" | "mantle" | "base" | "arbitrum" | "celo" | "avalanche" | "aurora";
+export type IChainId = 1 | 10 | 56 | 100 | 137 | 196 | 250 | 252 | 324 | 1284 | 2222 | 5000 | 8453 | 42161 | 42220 | 43114 | 1313161554;
+export type IPoolFactory = "main" | "crypto" | "factory" | "factory-crvusd" | "factory-crypto" | "factory-twocrypto" | "factory-tricrypto" | "factory-stable-ng";
+export interface ICurveContract {
+    contract: Contract,
+    multicallContract: MulticallContract,
+    abi: any,
+    address: string
+}
+
+export type TAmount = number | string
+export type TGas = number | number[]
+
+export interface ILlamma {
+    amm_address: string,
+    controller_address: string,
+    monetary_policy_address: string,
+    collateral_address: string,
+    leverage_zap: string,
+    deleverage_zap: string,
+    health_calculator_zap?: string,
+    collateral_symbol: string,
+    collateral_decimals: number,
+    min_bands: number,
+    max_bands: number,
+    default_bands: number,
+    A: number,
+    monetary_policy_abi: any
+}
+
+export interface ICoin {
+    address: string,
+    name: string,
+    symbol: string,
+    decimals: number,
+}
+
+export interface IOneWayMarket {
+    name: string,
+    addresses: {
+        amm: string,
+        controller: string,
+        borrowed_token: string,
+        collateral_token: string,
+        monetary_policy: string,
+        vault: string,
+        gauge: string,
+    },
+    borrowed_token: ICoin,
+    collateral_token: ICoin,
+}
+
+export interface ILlamalend {
+    provider: ethers.BrowserProvider | ethers.JsonRpcProvider,
+    multicallProvider: MulticallProvider,
+    signer: ethers.Signer | null,
+    signerAddress: string,
+    contracts: { [index: string]: { contract: Contract, multicallContract: MulticallContract } },
+    feeData: { gasPrice?: number, maxFeePerGas?: number, maxPriorityFeePerGas?: number },
+    constantOptions: { gasLimit: number },
+    options: { gasPrice?: number | bigint, maxFeePerGas?: number | bigint, maxPriorityFeePerGas?: number | bigint },
+    constants: {
+        ONE_WAY_MARKETS: IDict<IOneWayMarket>,
+        DECIMALS: IDict<number>;
+        NETWORK_NAME: INetworkName;
+        ALIASES: Record<string, string>;
+        COINS: Record<string, string>;
+        ZERO_ADDRESS: string,
+    };
+}
+
+export interface ICoinFromPoolDataApi {
+    address: string,
+    symbol: string,
+    decimals: string,
+    usdPrice: number | string,
+}
+
+export interface IReward {
+    gaugeAddress: string,
+    tokenAddress: string,
+    tokenPrice?: number,
+    name?: string,
+    symbol: string,
+    decimals?: number,
+    apy: number
+}
+
+export interface IPoolDataFromApi {
+    id: string,
+    name: string,
+    symbol: string,
+    assetTypeName: string,
+    address: string,
+    lpTokenAddress?: string,
+    gaugeAddress?: string,
+    implementation: string,
+    implementationAddress: string,
+    coins: ICoinFromPoolDataApi[],
+    gaugeRewards?: IReward[],
+    usdTotal: number,
+    totalSupply: number,
+    amplificationCoefficient: string,
+}
+
+export interface IExtendedPoolDataFromApi {
+    poolData: IPoolDataFromApi[],
+    tvl?: number,
+    tvlAll: number,
+}
+
+export interface IReward {
+    gaugeAddress: string,
+    tokenAddress: string,
+    symbol: string,
+    apy: number
+}
+
+export type T1inchRouteStep = {
+    name: string,
+    part: number,
+    fromTokenAddress: string,
+    toTokenAddress: string,
+}[]
+
+export interface I1inchRoute {
+    part: number,
+    hops: T1inchRouteStep[],
+}
+
+export interface I1inchSwapData {
+    tx: { data: string },
+    dstAmount: string,
+    protocols: I1inchRoute[],
+    slippage: number,
+}
+
+interface Rates {
+    borrowApr: number;
+    borrowApy: number;
+    borrowApyPcent: number;
+    lendApr: number;
+    lendApy: number;
+    lendApyPcent: number;
+}
+
+interface AssetDetail {
+    symbol: string;
+    decimals: number;
+    address: string;
+    blockchainId: string;
+    usdPrice: number;
+}
+
+interface Assets {
+    borrowed: AssetDetail;
+    collateral: AssetDetail;
+}
+
+interface VaultShares {
+    pricePerShare: number;
+    totalShares: number;
+}
+
+interface Total {
+    total: number;
+    usdTotal: number;
+}
+
+interface LendingVaultUrls {
+    deposit: string;
+    withdraw: string;
+}
+
+interface AmmBalances {
+    ammBalanceBorrowed: number;
+    ammBalanceBorrowedUsd: number;
+    ammBalanceCollateral: number;
+    ammBalanceCollateralUsd: number;
+}
+
+export interface IMarketDataAPI {
+    id: string;
+    name: string;
+    address: string;
+    controllerAddress: string;
+    ammAddress: string;
+    monetaryPolicyAddress: string;
+    rates: Rates;
+    gaugeAddress: string;
+    gaugeRewards: any[];
+    assets: Assets;
+    vaultShares: VaultShares;
+    totalSupplied: Total;
+    borrowed: Total;
+    availableToBorrow: Total;
+    lendingVaultUrls: LendingVaultUrls;
+    usdTotal: number;
+    ammBalances: AmmBalances;
+}
+
+export interface IMarketData {
+    lendingVaultData: IMarketDataAPI[]
+}
+
+export interface IQuoteOdos {
+    outAmounts: string[],
+    priceImpact: number,
+    pathId: string | null,
+    pathVizImage: string,
+    slippage: number,
+}
+
+
+export interface ILlamma {
+    amm_address: string,
+    controller_address: string,
+    monetary_policy_address: string,
+    collateral_address: string,
+    leverage_zap: string,
+    deleverage_zap: string,
+    health_calculator_zap?: string,
+    collateral_symbol: string,
+    collateral_decimals: number,
+    min_bands: number,
+    max_bands: number,
+    default_bands: number,
+    A: number,
+    monetary_policy_abi: any
+}