@1delta/margin-fetcher 0.0.1

package/src/utils/index.ts

@@ -0,0 +1,87 @@
+import { AAVE_FORK_POOL_DATA, AAVE_STYLE_RESERVE_ASSETS, AAVE_V2_LENDERS, AAVE_V3_LENDERS, COMPOUND_BASE_TOKENS, COMPOUND_STYLE_RESERVE_ASSETS, INIT_STYLE_RESERVE_ASSETS, Lender, SWAYLEND_RESERVE_ASSETS, INIT_CONFIG_DATA } from "@1delta/asset-registry"
+import { uniq } from "lodash"
+import { COMPOSERS } from "./constants"
+
+export const AAVE_V3_2_PROTOCOLS = [
+    Lender.AAVE_V3,
+    Lender.AAVE_V3_ETHER_FI,
+    Lender.AAVE_V3_PRIME,
+  ]
+
+export function isAaveV3Type(lender: string) { return AAVE_V3_LENDERS.includes(lender as any) }
+
+const AAVE_V3_KEY = "AAVE_V3"
+export function isAaveV3Original(lender: string) { return lender.startsWith(AAVE_V3_KEY) }
+
+export function isAaveV2Type(lender: string) { return AAVE_V2_LENDERS.includes(lender as any) }
+
+export function isAaveV32Type(lender: Lender) { return AAVE_V3_2_PROTOCOLS.includes(lender) }
+
+export function isAaveType(lender: string) { return [...AAVE_V3_LENDERS, ...AAVE_V2_LENDERS].includes(lender as any) }
+
+const COMPOUND_V3_KEY = "COMPOUND_V3"
+
+export function isCompoundV3(lender: string) { return lender.startsWith(COMPOUND_V3_KEY) }
+
+export function isCompoundV3Type(lender: string) { return lender.startsWith(COMPOUND_V3_KEY) }
+
+export function isInit(lender: string) { return lender === Lender.INIT }
+
+const SWAYLEND_KEY = "SWAYLEND"
+
+export function isSwaylend(lender: string) { return lender.startsWith(SWAYLEND_KEY) }
+
+
+export const getLendersForChain = (c: string) => {
+    let lenders: string[] = []
+    // aaves
+    Object.entries(AAVE_FORK_POOL_DATA).forEach(([l, data]) => {
+        const chains = Object.keys(data)
+        if (chains.includes(c)) lenders.push(l)
+    })
+
+    // compound V3s
+    Object.entries(COMPOUND_BASE_TOKENS).forEach(([l, data]) => {
+        const chains = Object.keys(data)
+        if (chains.includes(c)) lenders.push(l)
+    })
+
+    // init
+    Object.entries(INIT_CONFIG_DATA).forEach(([l, data]) => {
+        const chains = Object.keys(data)
+        if (chains.includes(c)) lenders.push(l)
+    })
+
+    return lenders
+}
+
+
+const getAavesForChain = () => {
+    let lenders: { [c: string]: string[] } = {}
+    Object.entries(AAVE_FORK_POOL_DATA).forEach(([l, data]) => {
+        Object.entries(data).forEach(([chain, data]) => {
+            if (!lenders[chain]) lenders[chain] = []
+            lenders[chain] = uniq([...lenders[chain], l])
+        })
+    })
+    return lenders
+}
+
+/** All aave protocols per chain */
+export const AAVES_PER_CHAIN = getAavesForChain()
+
+export const getComposerAddress = (chainId: string): string => {
+    return COMPOSERS[chainId as keyof typeof COMPOSERS]
+}
+
+export const getLenderAssets = (
+    chainId: string | number | undefined,
+    lendingProtocol = Lender.AAVE_V3
+  ): string[] => {
+    if (!chainId) return []
+    if (isAaveType(lendingProtocol)) return AAVE_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? []
+    if (isCompoundV3(lendingProtocol)) return COMPOUND_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? []
+    if (isInit(lendingProtocol)) return INIT_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? []
+    if (isSwaylend(lendingProtocol)) return SWAYLEND_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? 0] ?? []
+    return []
+  }

package/src/utils/multicall.ts

@@ -0,0 +1,53 @@
+import { isArray } from 'lodash'
+import { GeneralCall, GetEvmClientFunction } from '../types'
+
+export type Call = GeneralCall
+
+
+interface ViemMulticallresult {
+    result: any[],
+    status: string
+}
+
+const MULTICALL_DEFAULT_BATCH_SIZE = 4096
+
+const maxRetries = 3
+
+
+/** Same as Multicall viem except that the abi param is supposed to be the abi per call */
+export const multicallViemAbiArray = async (
+    chainId: string, 
+    abi: any[], 
+    calls: Call[], 
+    getEvmClient: GetEvmClientFunction,
+    retry = true, 
+    providerId = 0, 
+    retries = maxRetries
+): Promise<any[]> => {
+    try {
+        const provider = getEvmClient(chainId, providerId)
+
+        const abiIsArray = isArray(abi[0])
+        const returnData = await provider.multicall({
+            allowFailure: true,
+            batchSize: MULTICALL_DEFAULT_BATCH_SIZE,
+            contracts: calls.map(({ address, name, params }, i) => ({
+                abi: abiIsArray ? abi?.[i] as any : abi,
+                address: address as any,
+                functionName: name,
+                args: params,
+            })),
+        })
+        const res = (returnData as any[]).map(
+            ({ result, status }: ViemMulticallresult) => status !== "success" ? '0x' : result
+        );
+        return res
+    } catch (error: any) {
+        console.log("error in multicall", error)
+        retries--;
+        if (retries < 0) throw new Error("Failed too often")
+        providerId++;
+
+        return multicallViemAbiArray(chainId, abi, calls, getEvmClient, retry, providerId, retries)
+    }
+}

package/src/utils/parsing.ts

@@ -0,0 +1,75 @@
+import { Chain, Lender } from "@1delta/asset-registry"
+import { formatEther, formatUnits } from "viem"
+import { isCompoundV3 } from "."
+
+export const BPS = 10000
+
+export const parseRawAmount = (answer?: string, decimals = 18): string => {
+    if (!answer || answer === "0x") return "0"
+    try {
+        return (formatUnits(BigInt(answer ?? '0'), decimals ?? 18))
+    } catch (e) {
+        return "0"
+    }
+}
+
+export enum TimeScale {
+    BLOCK,
+    MS,
+}
+
+const BLOCK_TIMES: { [chainId: string]: number } = {
+    5: 12,
+    1: 12,
+    56: 3,
+}
+
+// Converters from apy to apr and reversed
+
+const SECONDS_PER_YEAR = 31536000
+
+export const aprToApy = (apr: number) => {
+    return (1 + apr / SECONDS_PER_YEAR) ** SECONDS_PER_YEAR - 1
+}
+
+export const apyToApr = (apy: number) => {
+    return ((apy + 1) ** (1 / SECONDS_PER_YEAR) - 1) * SECONDS_PER_YEAR
+}
+
+
+export const formatAaveYieldToNumber = (n?: string | bigint): number => {
+    if (!n) return 0
+    return Number(formatEther(BigInt(n) / BigInt(1e7)))
+}
+
+
+export const calculateRateForCompound = (
+    n: string,
+    chainId: string,
+    lender = Lender.COMPOUND_V3_USDC_E,
+): number => {
+    let scale = TimeScale.MS
+    if (isCompoundV3(lender) || Lender.COMPOUND_V2) {
+        scale = TimeScale.BLOCK
+    } else if (chainId === Chain.BNB_SMART_CHAIN_MAINNET) {
+        scale = TimeScale.BLOCK
+    }
+    const rate = Number(formatEther(BigInt(n)))
+    if (scale === TimeScale.BLOCK)
+        return (Math.pow((rate * 60 * 60 * 24) / (BLOCK_TIMES[chainId] ?? 1) + 1, 365) - 1) * 100
+
+    return (Math.pow(rate * 60 * 60 * 24 + 1, 365) - 1) * 100
+}
+export const formatAaveRawApyToApr = (raw: bigint | string | undefined) => {
+    const apy = formatAaveYieldToNumber(raw)
+    return apyToApr(apy / 100) * 100
+}
+
+
+
+// converts rate per second to rate per year
+export const convertRateToApr = (ratePerSecond: number | string) => {
+    const rps = Number(ratePerSecond)
+    if(isNaN(rps)) return 0
+    return rps * 3600 * 24 * 365 * 100
+}

package/src/yields/index.ts

@@ -0,0 +1,198 @@
+import { apyToApr } from "../utils/parsing"
+
+const FeedData = {
+    WSTETH: 'https://eth-api.lido.fi/v1/protocol/steth/apr/sma',
+    STMATIC: 'https://polygon.lido.fi/api/stats',
+    CBETH: 'https://api.exchange.coinbase.com/wrapped-assets/cbeth',
+    MATICX: 'https://universe.staderlabs.com/polygon/apy',
+    METH: 'https://meth.mantle.xyz/api/stats/apy',
+    SUSDE: 'https://yields.llama.fi/poolsEnriched?pool=66985a81-9c51-46ca-9977-42b4fe7bc6df',
+    EZETH: 'https://app.renzoprotocol.com/api/stats?chainId=1',
+    RETH: 'https://api.rocketpool.net/api/mainnet/payload',
+    WEETH: 'https://www.ether.fi/api/apr',
+    SAVAX: "https://api.benqi.fi/liquidstaking/apr",
+    RSETH: "https://universe.kelpdao.xyz/rseth/totalApy",
+}
+
+const LenderAPIs = {
+    MERIDIAN: 'https://omnidex.bmaa3ajd1gjri.eu-west-2.cs.amazonlightsail.com/lending_yields'
+}
+
+enum MeridainNetwork {
+    TAIKO = 'taiko'
+}
+
+function formatMeridianKey(k: string) {
+    const _k = k.toUpperCase()
+    if (_k === "USDT") return 'USDT.E'
+    if (_k === "USDCE") return 'USDC.E'
+    return _k
+}
+
+// Converters from apy to apr and reversed
+
+interface LenderAssetReward {
+    deposit: number
+    borrow: number
+    additionalDepositData: any
+    additionalBorrowData: any
+}
+
+export interface YieldDataWithTimestamp {
+    intrinsicYields: { [asset: string]: number | undefined }
+    lenderRewards: { [chainId: number]: { [lender: string]: { [asset: string]: LenderAssetReward } } }
+}
+
+const safeFetch = async <T>(label: string, fn: () => Promise<T>): Promise<T | undefined> => {
+    try {
+        return await fn()
+    } catch (e) {
+        console.error(`Error fetching ${label}:`, e)
+        return undefined
+    }
+}
+
+
+export const fetchGeneralYields = async () => {
+    const wstethPromise = safeFetch('WSTETH', async () => {
+        const res = await fetch(FeedData.WSTETH).then(r => r.json())
+        return Number(res.data.aprs.at(-1).apr) * 0.9
+    })
+
+    const ezethPromise = safeFetch('EZETH', async () => {
+        const res = await fetch(FeedData.EZETH).then(r => r.json())
+        return Number(res.data.apr.data.rate)
+    })
+
+    const rethPromise = safeFetch('RETH', async () => {
+        const res = await fetch(FeedData.RETH).then(r => r.json())
+        return Number(res.rethAPR)
+    })
+
+    const weethPromise = safeFetch('WEETH', async () => {
+        const wstethRes = await fetch(FeedData.WSTETH).then(r => r.json())
+        const wstethApr = Number(wstethRes.data.aprs.at(-1).apr) * 0.9
+        let aYield = 0
+        try {
+            const weethRes = await fetch(FeedData.WEETH).then(r => r.json())
+            aYield = Number(weethRes.lrt2Apr)
+        } catch (e) {
+            aYield = 0.5
+        }
+        return aYield + wstethApr
+    })
+
+    const stmaticPromise = safeFetch('STMATIC', async () => {
+        const res = await fetch(FeedData.STMATIC).then(r => r.json())
+        return Number(res.apr) * 0.9
+    })
+
+    const savaxPromise = safeFetch('SAVAX', async () => {
+        const res = await fetch(FeedData.SAVAX).then(r => r.json())
+        return Number(res.apr) * 100
+    })
+
+    const methPromise = safeFetch('METH', async () => {
+        const res = await fetch(FeedData.METH).then(r => r.json())
+        return apyToApr(Number(res.data[0]?.OneDayAPY)) * 100
+    })
+
+    const maticxPromise = safeFetch('MATICX', async () => {
+        const res = await fetch(FeedData.MATICX).then(r => r.json())
+        return Number(res.value) * 0.9
+    })
+
+    const susdePromise = safeFetch('SUSDE', async () => {
+        try {
+            const res = await fetch(FeedData.SUSDE).then(r => r.json())
+            return Number(res?.data[0]?.apy ?? 0)
+        } catch (e) {
+            return 0
+        }
+    })
+
+    const rsethPromise = safeFetch('RSETH', async () => {
+        const res = await fetch(FeedData.RSETH).then(r => r.json())
+        return Number(res.totalAPY)
+    })
+
+    const cbethPromise = safeFetch('CBETH', async () => {
+        try {
+            const res = await fetch(FeedData.CBETH, {
+                headers: {
+                    "User-Agent": "1delta/yields",
+                    "Content-Type": "application/json"
+                }
+            }).then(r => r.json())
+            return Number(res.apy) * 100
+        } catch (e) {
+            console.log("CBETH failed", e)
+            return 0
+        }
+    })
+
+    const meridianPromise = safeFetch('MERIDIAN', async () => {
+        const res = await fetch(LenderAPIs.MERIDIAN).then(r => r.json())
+        const taikoData = res[MeridainNetwork.TAIKO]
+        return Object.assign({}, ...Object.keys(taikoData).map(key => ({
+            [formatMeridianKey(key)]: {
+                deposit: taikoData[key].apy_reward,
+                borrow: taikoData[key].apy_reward_borrow
+            }
+        })))
+    })
+
+    const [
+        wstethData,
+        ezethData,
+        rethData,
+        weethData,
+        stmaticData,
+        methData,
+        maticXdata,
+        susdeData,
+        meridianData,
+        savaxData,
+        cbethData,
+        rsethData,
+    ] = await Promise.all([
+        wstethPromise,
+        ezethPromise,
+        rethPromise,
+        weethPromise,
+        stmaticPromise,
+        methPromise,
+        maticxPromise,
+        susdePromise,
+        meridianPromise,
+        savaxPromise,
+        cbethPromise,
+        rsethPromise,
+    ])
+
+    const data: YieldDataWithTimestamp = {
+        intrinsicYields: {
+            MATICX: maticXdata,
+            METH: methData,
+            CMETH: methData,
+            WSTETH: wstethData,
+            EZETH: ezethData,
+            RETH: rethData,
+            WEETH: weethData,
+            STMATIC: stmaticData,
+            USDY: 4.35,
+            USDE: 0,
+            SUSDE: susdeData,
+            SAVAX: savaxData,
+            CBETH: cbethData,
+            RSETH: rsethData,
+        },
+        lenderRewards: {
+            "167000": {
+                MERIDIAN: meridianData
+            }
+        }
+    }
+    return data
+}
+

package/test/index.test.ts

@@ -0,0 +1,104 @@
+import { describe, it } from 'vitest'
+import { fetchDefillamaData, fetchFlashLiquidityForChain, fetchGeneralYields, getLenderPublicData } from "../src"
+import { multicallRetry } from "@1delta/providers"
+import { Chain, Lender } from "@1delta/asset-registry"
+import { getLendersForChain } from '../src/utils'
+
+
+describe('find prices', () => {
+  it.only('should return prices for valid tokens', async () => {
+
+    const yields = await fetchGeneralYields()
+
+    console.log("yields", yields)
+
+  })
+
+  it('should return prices for valid tokens', async () => {
+
+    const yields = await fetchDefillamaData()
+
+    console.log("yields", yields)
+
+  })
+}, { timeout: 10000 })
+
+describe('find flash liquidity', () => {
+  it('should return prices for valid tokens', async () => {
+
+    const chain = Chain.BASE
+
+    const yields = await fetchFlashLiquidityForChain(chain, multicallRetry)
+
+    console.log("yields", yields)
+
+  })
+}, { timeout: 10000 })
+
+
+describe('find lending data', () => {
+  it('should return prices for valid tokens', async () => {
+    const chainId = Chain.AVALANCHE_C_CHAIN
+
+
+    const ps = [
+      fetchDefillamaData(),
+      fetchGeneralYields(),
+    ]
+
+    const [prices, yields] = await Promise.all(ps)
+
+    // console.log("yields", yields)
+    // console.log("prices", prices)
+
+    const lenders = getLendersForChain(chainId) as any
+    // console.log("lenders", lenders)
+    const lendingData = await getLenderPublicData(
+      chainId,
+      lenders,
+      prices as any,
+      yields as any,
+      multicallRetry
+    )
+
+    prettyPrint(lendingData)
+
+    // console.log(JSON.stringify(list, null, 2))
+    // const token = list.BRBTC.currencies.find(a => a.chainId === chainId)
+
+    // const bases = [
+    //   ...list.WBTC.currencies.filter(a => a.chainId === chainId).map(a => ({ ...a, assetGroup: "WBTC" })),
+    //   ...list.UNIBTC.currencies.filter(a => a.chainId === chainId).map(a => ({ ...a, assetGroup: "BTCB" })),
+    //   ...list.USDC.currencies.filter(a => a.chainId === chainId).map(a => ({ ...a, assetGroup: "USDC" })),
+    //   { ...WRAPPED_NATIVE_INFO[chainId], chainId, assetGroup: "ETH" }
+    // ]
+
+    // const pools = await fetchV3StylePools(
+    //   // @ts-ignore
+    //   token,
+    //   bases
+    // )
+
+    // Object.entries(pools).map(([c, a]) => console.log(c, a))
+
+    // const price = getTokenPrice(token!, pools)
+    // console.log(token?.symbol, "price", price, "USD")
+    // // expect(result.pricesMap[1]['0xbase']).toBe(5)
+    // // expect(result.pricesMap[1]['0xquote']).toBeCloseTo(0.2) // 1 / 5
+    // // expect(result.pricesUnavailable[1]).toBeUndefined()
+  })
+}, { timeout: 10000 })
+
+
+function prettyPrint(obj: any) {
+  for (const key in obj) {
+    const value = obj[key]
+    const keyStr = `\x1b[1m\x1b[36m${key}:\x1b[0m` // bold cyan
+    if (typeof value === 'object' && value !== null) {
+      console.log(`${keyStr}`)
+      console.dir(value, { depth: null, colors: true })
+    } else {
+      console.log(`${keyStr} ${value}`)
+    }
+  }
+}