@1delta/margin-fetcher 0.0.1

package/src/lending-pairs/computeLendingPairs.ts

@@ -0,0 +1,213 @@
+import { getAssetMeta, toGenericPriceKey, toOracleKey } from "../assets"
+import { ConfigEntry, LenderData, PoolData } from "../types"
+import { isAaveV3Type, isInit } from "../utils"
+
+export interface LendingPair {
+    // lender info
+    chainId: string
+    lender: string
+    // asset addresses
+    assetLong: string
+    assetShort: string
+
+    // asset group for long asset
+    assetGroupLong: string
+    // asset group for short asset
+    assetGroupShort: string
+    // pair prices
+    price: number
+    price24h: number
+    priceChange: number
+
+    // pair props
+    maxLeverage: number
+    apr: number
+    tags?: string[]
+    eMode?: number
+}
+
+const isEMode = (longData: PoolData, shortData: PoolData) => Boolean(longData.eMode) ?
+    Number(longData.eMode?.category) > 0 && Number(longData.eMode?.category) === shortData.eMode?.category : false
+
+const intersection = <T>(a0: T[], a1: T[]): T[] => {
+    return a0.filter(a => a1.includes(a))
+}
+const LENDER_MODE_NO_MODE = 0
+
+// calculate the maximum  leverage for a given pair
+const getMaxLeverage = (lender: string, longData: PoolData, shortData: PoolData) => {
+    // for Aave V3 we check for eModes
+    if (isAaveV3Type(lender)) {
+        const cf = isEMode(longData, shortData) ?
+            longData.config[longData.eMode?.category ?? 0]?.borrowCollateralFactor :
+            longData.config[LENDER_MODE_NO_MODE]?.borrowCollateralFactor
+        return 1 / (1 - cf)
+    }
+    // for init, we match the modes and find the one with the highest collatearal factor
+    if (isInit(lender)) {
+        const modeIntersect = intersection(
+            Object.values(longData.config).map((c: ConfigEntry) => c.category),
+            Object.values(shortData.config).map((c: ConfigEntry) => c.category))
+
+        if (modeIntersect.length === 0) return 1
+        const configId = Object.values(longData.config).filter(
+            (c: ConfigEntry) => modeIntersect.includes(c.category)
+        ).sort((c: ConfigEntry, d: ConfigEntry) => c.borrowCollateralFactor < d.borrowCollateralFactor ? 1 : -1)[0].category
+
+        // we have to use the adjusted formula with the borrowFactor here
+        const cf = longData.config[configId]?.borrowCollateralFactor
+        const bf = shortData.config[configId]?.borrowFactor
+        return 1 / (1 - (cf / bf))
+    }
+    // all other cases use the default mode no_mode without borrowFactor
+    const cf = longData?.config?.[LENDER_MODE_NO_MODE]?.borrowCollateralFactor ?? 0.8
+    return 1 / (1 - cf)
+}
+
+/** create array of pairs for given lender data */
+export function generateLendingPairs(lenderData: LenderData, prices: { [k: string]: number }, histPrices: { [k: string]: number }): LendingPair[] {
+    const pairs: LendingPair[] = [];
+
+    for (const chainId in lenderData) {
+        const chainEntry = lenderData[chainId];
+        const lenderToData = (chainEntry.data ?? chainEntry)
+
+        for (const lender in lenderToData) {
+            const lenderEntry = lenderToData[lender];
+
+            // protect agaist error data
+            // @ts-ignore
+            let pools: PoolData[] = Object.values(lenderEntry?.data ?? lenderEntry ?? {}).map(a => a?.data ? a.data : a);
+
+            // sometimes error messages are included
+            // @ts-ignore
+            if (pools.includes("No lenders available") || pools.includes("Failed to fetch")) continue;
+            const poolArray = pools.filter(p => !p?.isFrozen);
+
+            // Loop through all ordered pairs of pools
+            for (let i = 0; i < poolArray.length; i++) {
+                for (let j = 0; j < poolArray.length; j++) {
+                    if (i === j) continue;
+
+                    const long = poolArray[i];
+                    const short = poolArray[j];
+                    if (!short.borrowingEnabled) continue;
+
+                    // Skip same asset pairs
+                    if (long.underlying === short.underlying) continue;
+
+                    const maxDepositLeverage = getMaxLeverage(lender, long, short)
+                    const borrowLeverage = (maxDepositLeverage - 1)
+                    const depositLeverage = borrowLeverage + 1
+                    let collateralRewards = 0
+                    let borrowRewards = 0
+                    const rewards: any = {}
+                    // get the rewards from the collateral
+                    for (const [rewardId, baseYields] of Object.entries(long.rewards ?? {})) {
+                        collateralRewards += baseYields.depositRate
+                        if (baseYields.depositRate > 0)
+                            rewards[rewardId] = baseYields.depositRate * depositLeverage
+                    }
+                    // get the rewards from debt
+                    for (const [rewardId, baseYields] of Object.entries(short.rewards ?? {})) {
+                        const borrowRate = baseYields.stableBorrowRate >= baseYields.variableBorrowRate
+                            ? baseYields.stableBorrowRate
+                            : baseYields.variableBorrowRate
+                        borrowRewards += borrowRate
+                        if (borrowRate != 0)
+                            rewards[rewardId] = (rewards[rewardId] ?? 0) + borrowRate * borrowLeverage
+                    }
+                    const depositApr = long.depositRate + long.stakingYield
+                    const borrowApr = short.variableBorrowRate + short.stakingYield
+
+
+                    const [assetGroupLong, keyLong] = getPriceKey(long.underlying, chainId)
+                    const [assetGroupShort, keyShort] = getPriceKey(short.underlying, chainId)
+                    const priceLong = prices[keyLong] ?? 0
+                    const priceShort = prices[keyShort] ?? 0
+
+                    const price24hLong = histPrices[keyLong] ?? priceLong
+                    const price24hShort = histPrices[keyShort] ?? priceShort
+
+                    const price = priceShort !== 0 ? priceLong / priceShort : 0
+                    const price24h = price24hShort !== 0 ? price24hLong / price24hShort : 0
+
+
+                    pairs.push({
+                        chainId,
+                        lender,
+                        assetLong: long.underlying,
+                        assetShort: short.underlying,
+                        price,
+                        price24h,
+                        assetGroupLong,
+                        assetGroupShort,
+                        priceChange: price24h === 0 ? 0 : (price - price24h) / price24h,
+                        maxLeverage: maxDepositLeverage,
+                        apr: (depositApr + collateralRewards) * depositLeverage + (borrowRewards - borrowApr) * borrowLeverage,
+                        eMode: long.eMode?.category ?? 0
+                    });
+                }
+            }
+        }
+    }
+
+    return pairs;
+}
+
+function getPriceKey(asset: string, chainId: string): [string, string] {
+    const assetGroup = getAssetMeta(chainId, asset)?.assetGroup
+    return [assetGroup, toOracleKey(assetGroup) ?? toGenericPriceKey(asset, chainId)]
+}
+
+const MAX_ENTRIES = 10
+
+export function getTopPairs(pairs: LendingPair[]) {
+    const stables = pairs.filter(p => p.assetGroupLong?.includes("USD") && p.assetGroupShort?.includes("USD") && !p.assetGroupShort?.includes("PT-")).sort((a, b) => a.apr > b.apr ? -1 : 1).slice(0, MAX_ENTRIES)
+    const btcLst = pairs.filter(p => p.assetGroupLong?.includes("BTC") && p.assetGroupShort?.includes("BTC") && !p.assetGroupShort?.includes("PT-")).sort((a, b) => a.apr > b.apr ? -1 : 1).slice(0, MAX_ENTRIES)
+    const ethLst = pairs.filter(p => p.assetGroupLong?.includes("ETH") && p.assetGroupShort?.includes("ETH") && !p.assetGroupShort?.includes("PT-")).sort((a, b) => a.apr > b.apr ? -1 : 1).slice(0, MAX_ENTRIES)
+
+    return {
+        stables,
+        btcLst,
+        ethLst,
+        gainers: getDistinctPairsByShortAsset(pairs).slice(0, MAX_ENTRIES),
+    }
+}
+
+function isStable(assetGroup: string): boolean {
+    return assetGroup.includes("USD");
+}
+
+export function getDistinctPairsByShortAsset(
+    pairs: LendingPair[],
+): LendingPair[] {
+    const sorted = [...pairs].sort((a, b) =>
+        b.priceChange - a.priceChange
+    );
+
+    const blacklist = new Set<string>();
+    const blacklistLong = new Set<string>();
+    const result: LendingPair[] = [];
+
+    for (const pair of sorted) {
+        const shortGroup = pair.assetGroupShort;
+        const longGroup = pair.assetGroupLong;
+
+        if (blacklist.has(shortGroup)|| blacklistLong.has(longGroup)) continue;
+
+        result.push(pair);
+
+        // Only blacklist if not a stablecoin
+        if (!isStable(shortGroup)) {
+            blacklist.add(shortGroup);
+        }
+        if (!isStable(longGroup)) {
+            blacklistLong.add(longGroup);
+        }
+        if (result.length >= 10) return result
+    }
+
+
+    return result;
+}

package/src/lending-pairs/index.ts

@@ -0,0 +1 @@
+export * from "./computeLendingPairs"

package/src/prices/defillama/index.ts

@@ -0,0 +1,306 @@
+
+import fetch from "axios"
+
+const prefixEthereum = 'ethereum:'
+const RETH = '0xae78736Cd615f374D3085123A210448E74Fc6393'
+const WBTC = '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599'
+const WETH = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+const MNT = '0x3c3a81e81dc49a522a592e7622a7e711c06bf354'
+const USDE = '0x4c9edd5852cd905f086c759e8383e09bff1e68b3'
+const METH = '0xd5f7838f5c461feff7fe49ea5ebaf7728bb0adfa'
+const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'
+const USDT = '0xdac17f958d2ee523a2206206994597c13d831ec7'
+const USDY = '0x96f6ef951840721adbf46ac996b59e0235cb985c'
+const CRV = '0xD533a949740bb3306d119CC777fa900bA034cd52'
+const BAL = '0xba100000625a3754423978a60c9317c58a424e3D'
+const AGEUR = '0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8'
+const LINK = '0x514910771AF9Ca656af840dff83E8264EcF986CA'
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
+const MATIC = '0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0'
+const BNB = '0xB8c77482e45F1F44dE1745F52C74426C631bDD52'
+const STMATIC = '0x9ee91F9f426fA633d227f7a9b000E28b9dfd8599'
+const MATICX = '0xf03A7Eb46d01d9EcAA104558C732Cf82f6B6B645'
+const AAVE = '0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9'
+const COMP = '0xc00e94cb662c3520282e6f5717214004a7f26888'
+const EURS = '0xdB25f211AB05b1c97D595516F45794528a807ad8'
+const FBTC = '0xC96dE26018A54D51c097160568752c4E3BD6C364'
+const TAIKO = '0x10dea67478c5F8C5E2D90e5E9B26dBe60c54d800'
+const CMETH = '0xe6829d9a7ee3040e1276fa75293bde931859e8fa'
+const AUSD = '0x00000000efe302beaa2b3e6e1b18d08d69a9012a'
+const SUSDE = '0x9D39A5DE30e57443BfF2A8307A4256c8797A3497'
+const FUEL = '0x675B68AA4d9c2d3BB3F0397048e62E6B7192079c'
+const GHO = '0x40d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f'
+const FRAX = '0x853d955acef822db058eb8505911ed77f175b99e'
+const WEETH = '0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee'
+const ARB = '0xb50721bcf8d664c30412cfbc6cf7a15145234ad1'
+const WUSDM = '0x57f5e098cad7a3d1eed53991d4d66c45c9af7812'
+const RSETH = "0xa1290d69c65a6fe4df752f95823fae25cb99e5a7"
+const CBETH = "0xbe9895146f7af43049ca1c1ae358b0541ea49704"
+const SNX = "0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f"
+const VUSD = "0x677ddbd918637e5f2c79e164d402454de7da8619"
+const EZETH = "0xbf5495Efe5DB9ce00f80364C8B423567e58d2110"
+const LBTC = "0x8236a87084f8B84306f72007F36F2618A5634494"
+const BRBTC = "0x2eC37d45FCAE65D9787ECf71dc85a444968f6646"
+const SDAI = "0x83f20f44975d03b1b09e64809b757c47f942beea"
+const datasEthereum = [
+    RETH,
+    WBTC,
+    WETH,
+    MNT,
+    USDC,
+    USDT,
+    USDE,
+    METH,
+    USDY,
+    CRV,
+    BAL,
+    AGEUR,
+    LINK,
+    DAI,
+    BNB,
+    MATIC,
+    STMATIC,
+    MATICX,
+    AAVE,
+    COMP,
+    EURS,
+    FBTC,
+    TAIKO,
+    CMETH,
+    AUSD,
+    SUSDE,
+    FUEL,
+    GHO,
+    FRAX,
+    WEETH,
+    ARB,
+    WUSDM,
+    RSETH,
+    CBETH,
+    SNX,
+    EZETH,
+    VUSD,
+    LBTC,
+    BRBTC,
+    SDAI
+].map(d => prefixEthereum + d).join(',')
+
+const prefixAvalanche = 'avax:'
+const WAVAX = '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7'
+const SAVAX = "0x2b2C81e08f1Af8835a78Bb2A90AE924ACE0eA4bE"
+
+const prefixArbitrum = "arbitrum:"
+const GMX = "0xfc5a1a6eb076a2c7ad06ed22c90d7e710e35ad0a"
+
+const prefixOptimism = "optimism:"
+const OP = "0x4200000000000000000000000000000000000042"
+const SUSD = "0x8c6f28f2F1A3C87F0f938b96d27520d9751ec8d9"
+const WRSETH = "0x87eee96d50fb761ad85b1c982d28a042169d61b1"
+
+const prefixBase = "base:"
+const AERO = "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
+
+const prefixCore = "core:"
+const WCORE = "0xb0788b601c0d712702bc829b52771199ad8e33ff"
+
+const prefixMetis = "metis:"
+const WMETIS = "0x75cb093e4d61d2a2e65d8e0bbb01de8d89b53481"
+
+const prefixSonic = "sonic:"
+const WS = "0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38"
+
+const prefixFantom = "fantom:"
+const WFTM = "0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83"
+
+const prefixKaia = "kaia:"
+const WKAIA = "0x19aac5f612f524b754ca7e7c41cbfa2e981a4432"
+
+
+const datasAvalanche = [
+    WAVAX,
+    SAVAX
+].map(d => prefixAvalanche + d).join(',')
+const datasArbitrum = [GMX].map(d => prefixArbitrum + d).join(',')
+const datasOptimism = [OP, SUSD, WRSETH].map(d => prefixOptimism + d).join(',')
+const datasBase = [AERO].map(d => prefixBase + d).join(',')
+const datasCore = [WCORE].map(d => prefixCore + d).join(',')
+const datasMetis = [WMETIS].map(d => prefixMetis + d).join(',')
+const datasFantom = [WFTM].map(d => prefixFantom + d).join(',')
+const datasSonic = [WS].map(d => prefixSonic + d).join(',')
+const datasKaia = [WKAIA].map(d => prefixKaia + d).join(',')
+
+
+const URL = `https://coins.llama.fi/prices/current/${[
+    datasEthereum,
+    datasAvalanche,
+    datasArbitrum,
+    datasOptimism,
+    datasBase,
+    datasCore,
+    datasMetis,
+    datasFantom,
+    datasKaia,
+    datasSonic, //
+].join(',')}?searchWidth=4h`
+const URL_HIST = (ref: number) => `https://coins.llama.fi/prices/historical/${ref}/${[
+    datasEthereum,
+    datasAvalanche,
+    datasArbitrum,
+    datasOptimism,
+    datasBase,
+    datasCore,
+    datasMetis,
+    datasFantom,
+    datasKaia,
+    datasSonic, //
+].join(',')}?searchWidth=4h`
+
+const SYMBOL_MAP = {
+    'weth': "WETH",
+    'usde': "USDE",
+    'meth': "METH",
+    'mnt': "WMNT",
+    'usdc': "USDC",
+    'usdt': "USDT",
+    'wbtc': "WBTC",
+    'usdy': "USDY",
+    'crv': "CRV",
+    'op': "OP",
+    'bal': "BAL",
+    'eura': "AGEUR",
+    'link': "LINK",
+    'dai': "DAI",
+    'bnb': "WBNB",
+    'matic': "WPOL",
+    'wpol': "WPOL",
+    'pol': "WPOL",
+    'stmatic': "STMATIC",
+    'maticx': "MATICX",
+    'wavax': "WAVAX",
+    'aave': "AAVE",
+    'comp': "COMP",
+    'eurs': "EURS",
+    'fbtc': "FBTC",
+    'taiko': "TAIKO",
+    'cmeth': "CMETH",
+    'ausd': "AUSD",
+    'susde': "SUSDE",
+    'fuel': "FUEL",
+    'gho': "GHO",
+    'frax': "FRAX",
+    'weeth': "WEETH",
+    'arb': "ARB",
+    'lusd': "LUSD",
+    'reth': "RETH",
+    'gmx': "GMX",
+    'wusdm': "WUSDM",
+    'rseth': "RSETH",
+    'susd': "SUSD",
+    'wrseth': "WRSETH",
+    'cbeth': "CBETH",
+    'aero': "AERO",
+    'snx': "SNX",
+    'wftm': "WFTM",
+    'ftm': "WFTM",
+    'wcore': "WCORE",
+    'core': "WCORE",
+    'ws': "WS",
+    's': "WS",
+    'wmetis': "WMETIS",
+    'metis': "WMETIS",
+    'vusd': "VUSD",
+    'ezeth': "EZETH",
+    'lbtc': "LBTC",
+    'brbtc': "BRBTC",
+    'sdai': "SDAI",
+    'wkaia': "KAIA",
+    'savax': "SAVAX",
+}
+
+export async function fetchDefillamaData() {
+    try {
+        const res: any = await fetch(URL)
+        let prices = Object.assign(
+            {},
+            ...Object.values(res.data.coins).map(
+                // @ts-ignore
+                (k: any) => { return { [SYMBOL_MAP[k.symbol.toLowerCase()]]: k.price } }
+            )
+        )
+
+        prices["POL"] = prices["WPOL"]
+        prices["BNB"] = prices["WBNB"]
+        prices["ETH"] = prices["WETH"]
+        prices["S"] = prices["WS"]
+        prices["CORE"] = prices["WCORE"]
+        prices["AVAX"] = prices["WAVAX"]
+        prices["METIS"] = prices["WMETIS"]
+        prices["KAIA"] = prices["WKAIA"]
+
+        prices["USDBC"] = prices["USDC"]
+        prices["BTCB"] = prices["WBTC"]
+        prices["CBBTC"] = prices["WBTC"]
+        prices["SOLVBTC"] = prices["WBTC"]
+        prices["XSOLVBTC"] = prices["WBTC"]
+        prices["SUBTC"] = prices["WBTC"]
+
+        prices["IBTC"] = prices["WBTC"]
+        prices["ENZOBTC"] = prices["WBTC"]
+
+        prices["LUSD"] = prices["USDT"]
+        prices["XDAI"] = prices["DAI"]
+        prices["WXDAI"] = prices["DAI"]
+        return prices
+    }
+    catch (e: any) {
+        console.log("error fetching prices from defillama", e)
+        return {}
+    }
+}
+
+export async function fetchDefillamaHistData() {
+    try {
+        const nowMinus24 = Math.floor(Date.now() / 1000 - 24 * 3600)
+        const resHist: any = await fetch(URL_HIST(nowMinus24))
+
+        let histPrices = Object.assign(
+            {},
+            ...Object.values(resHist.data.coins).map(
+                // @ts-ignore
+                (k: any) => { return { [SYMBOL_MAP[k.symbol.toLowerCase()]]: k.price } }
+            )
+        )
+
+        histPrices["POL"] = histPrices["WPOL"]
+        histPrices["BNB"] = histPrices["WBNB"]
+        histPrices["ETH"] = histPrices["WETH"]
+        histPrices["S"] = histPrices["WS"]
+        histPrices["CORE"] = histPrices["WCORE"]
+        histPrices["AVAX"] = histPrices["WAVAX"]
+        histPrices["METIS"] = histPrices["WMETIS"]
+        histPrices["KAIA"] = histPrices["WKAIA"]
+
+        histPrices["LUSD"] = histPrices["USDT"]
+        histPrices["XDAI"] = histPrices["DAI"]
+        histPrices["WXDAI"] = histPrices["DAI"]
+
+        histPrices["BTCB"] = histPrices["WBTC"]
+        histPrices["M-BTC"] = histPrices["WBTC"]
+        histPrices["SOLVBTC"] = histPrices["WBTC"]
+        histPrices["XSOLVBTC"] = histPrices["WBTC"]
+        histPrices["UNIBTC"] = histPrices["WBTC"]
+        histPrices["HEMIBTC"] = histPrices["WBTC"]
+        histPrices["SUBTC"] = histPrices["WBTC"]
+        histPrices["IBTC"] = histPrices["WBTC"]
+        histPrices["ENZOBTC"] = histPrices["WBTC"]
+        histPrices["PUMPBTC"] = histPrices["WBTC"]
+
+        return histPrices
+
+    }
+    catch (e: any) {
+        console.log("error fetching prices from defillama", e)
+        return {}
+    }
+}
+

package/src/prices/index.ts

@@ -0,0 +1,2 @@
+export * from "./defillama"
+export * from "./main-prices"