@1delta/margin-fetcher 0.0.1

package/src/assets/index.ts

@@ -0,0 +1,82 @@
+import { AAVE_FORK_POOL_DATA, AAVE_STYLE_RESERVE_ASSETS, AAVE_STYLE_TOKENS, ASSET_META, COMPOUND_STYLE_RESERVE_ASSETS, COMPOUND_V2_STYLE_RESERVE_ASSETS, INIT_STYLE_RESERVE_ASSETS, Lender, SWAYLEND_RESERVE_ASSETS } from "@1delta/asset-registry"
+import { isAaveType, isCompoundV3, isInit, isSwaylend } from "../utils"
+
+/** No specific configuration */
+export const LENDER_MODE_NO_MODE = 0
+
+
+export function getAaveStyleProtocolTokenMap(chainId: string, lender: string) {
+    return AAVE_STYLE_TOKENS[lender]?.[chainId] as any
+}
+
+
+export const getAaveAssets = (
+    chainId: string | undefined,
+    lendingProtocol: string = Lender.AAVE_V3
+): string[] => {
+    if (isAaveType(lendingProtocol)) return AAVE_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? "0"] ?? []
+    return []
+}
+
+export const getInitAssets = (
+    chainId: string | undefined,
+    lendingProtocol = Lender.INIT
+): string[] => {
+    if (isInit(lendingProtocol)) return INIT_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? "0"] ?? []
+    return []
+}
+
+export const getCompoundV3Assets = (
+    chainId: string | undefined,
+    lendingProtocol = Lender.COMPOUND_V3_USDC_E
+): string[] => {
+    if (isCompoundV3(lendingProtocol)) return COMPOUND_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? "0"] ?? []
+    return []
+}
+
+export const getCompoundV2Assets = (
+    chainId: string | undefined,
+    lendingProtocol = Lender.VENUS
+): string[] => {
+    if (isCompoundV3(lendingProtocol)) return COMPOUND_V2_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? "0"] ?? []
+    return []
+}
+
+
+export const getSwaylendAssets = (
+    chainId: string | undefined,
+    lendingProtocol = Lender.SWAYLEND_USDC
+): string[] => {
+    if (isSwaylend(lendingProtocol)) return SWAYLEND_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? "0"] ?? []
+    return []
+}
+
+export function getAaveTypePoolDataProviderAddress(chainId: string, lender: string) {
+    // @ts-ignore
+    return AAVE_FORK_POOL_DATA[lender]?.[chainId]?.protocolDataProvider
+}
+
+
+export function getAaveTypePoolAddress(chainId: string, lender: string): string {
+    // @ts-ignore
+    return AAVE_FORK_POOL_DATA[lender]?.[chainId]?.pool
+}
+
+
+export function getAssetMeta(chainId: string, asset: string | undefined) {
+    return ASSET_META[chainId ?? "0"]?.[asset?.toLowerCase() ?? ""] as any
+}
+
+
+/**
+* Convert a string (asset symbol) to a Supported asset, considering also naming conflicts
+* @param a string
+* @returns SupportedAsset
+*/
+export const toOracleKey = (a: string) => {
+    return a?.toUpperCase()
+}
+
+export const toGenericPriceKey = (assetAddress: string, chainId: string) => {
+    return chainId + "-" + assetAddress
+}

package/src/flash-liquidity/assets.ts

@@ -0,0 +1,61 @@
+import { AAVE_STYLE_RESERVE_ASSETS, COMPOUND_STYLE_RESERVE_ASSETS, COMPOUND_V2_STYLE_RESERVE_ASSETS, MORPHO_BLUE_POOL_DATA } from "@1delta/asset-registry"
+import { BALANCER_V2_FORKS, BALANCER_V3_FORKS, UNISWAP_V4_FORKS } from "@1delta/dex-registry"
+import { uniq } from "lodash"
+
+function createAssetArrayPerChain() {
+    let assetsPerChain: { [chainId: string]: string[] } = {}
+    Object.entries(COMPOUND_STYLE_RESERVE_ASSETS).forEach(([lender, data]) => {
+
+        Object.entries(data).forEach(([chainId, assetArray]) => {
+            if (!assetsPerChain[chainId]) assetsPerChain[chainId] = []
+            assetsPerChain[chainId] = uniq([...assetsPerChain[chainId], ...assetArray])
+        })
+    })
+
+    Object.entries(AAVE_STYLE_RESERVE_ASSETS).forEach(([lender, data]) => {
+        Object.entries(data).forEach(([chainId, assetArray]) => {
+            if (!assetsPerChain[chainId]) assetsPerChain[chainId] = []
+            assetsPerChain[chainId] = uniq([...assetsPerChain[chainId], ...assetArray])
+        })
+    })
+
+    Object.entries(COMPOUND_V2_STYLE_RESERVE_ASSETS).forEach(([lender, data]) => {
+        Object.entries(data).forEach(([chainId, assetArray]) => {
+            if (!assetsPerChain[chainId]) assetsPerChain[chainId] = []
+            assetsPerChain[chainId] = uniq([...assetsPerChain[chainId], ...assetArray])
+        })
+    })
+    return assetsPerChain
+}
+
+export const RELEVANT_LENDING_ASSETS = createAssetArrayPerChain()
+
+
+interface PoolData {
+    pool: string
+    address: string
+}
+
+function createSimpleArrayPerChain(fork: any, field: undefined | string = undefined) {
+    let pools: { [chainId: string]: PoolData[] } = {}
+    Object.entries(fork).forEach(([b2, data]: [string, any]) => {
+        // @ts-ignore
+        Object.entries(field ? data[field] : data).forEach(([chainId, address]: [string, any]) => {
+            if (!pools[chainId]) pools[chainId] = []
+            pools[chainId] = uniq([...pools[chainId], { address, pool: b2 }])
+        })
+    })
+    return pools
+}
+
+
+export const RELEVANT_BALANCER_V2_FORKS = createSimpleArrayPerChain(BALANCER_V2_FORKS)
+
+
+export const RELEVANT_MORPHOB_FORKS = createSimpleArrayPerChain(MORPHO_BLUE_POOL_DATA)
+
+
+export const RELEVANT_BALANCER_V3_FORKS = createSimpleArrayPerChain(BALANCER_V3_FORKS, "vault")
+
+
+export const RELEVANT_UNISWAP_V4_FORKS = createSimpleArrayPerChain(UNISWAP_V4_FORKS, "pm")

package/src/flash-liquidity/fetchLiquidity.ts

@@ -0,0 +1,300 @@
+import { getAaveStyleProtocolTokenMap, getAaveTypePoolAddress, getAssetMeta } from "../assets";
+import { AAVES_PER_CHAIN } from "../utils";
+import {
+    RELEVANT_BALANCER_V2_FORKS,
+    RELEVANT_BALANCER_V3_FORKS,
+    RELEVANT_LENDING_ASSETS,
+    RELEVANT_MORPHOB_FORKS,
+    RELEVANT_UNISWAP_V4_FORKS
+} from "./assets";
+import { Call } from "../utils/multicall";
+import { MulticallRetryFunction } from "../types";
+import { FlashAbi } from "../abis/flashloan-united/flashAbi";
+import { FlashLiquiditiesOnChain, FlashLoanIds } from "./types";
+import { FLASH_LOAN_IDS } from "@1delta/dex-registry";
+import { formatUnits, zeroAddress } from "viem";
+import { AAVE_V2_LENDERS, AAVE_V3_LENDERS } from "@1delta/asset-registry";
+import _ from "lodash"
+import { MULTICALL_ADDRESS } from "../utils/constants";
+
+const DEFAULT_BATCH_SIZE = 4096;
+
+enum BalanceFetchCall {
+    balanceOf = "balanceOf",
+    getEthBalance = "getEthBalance"
+}
+
+// Aave V3 flash loan flag enabled flag
+const FLASHLOAN_ENABLED_MASK = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFFF');
+function getFlashLoanEnabled(data: bigint): boolean {
+    return (data & ~FLASHLOAN_ENABLED_MASK) !== BigInt(0);
+}
+
+export async function fetchFlashLiquidityForChain(
+    chain: string,
+    multicallRetry: MulticallRetryFunction
+) {
+
+    let callLengths: { [l: string]: number } = {}
+    let aaveAssets: { [l: string]: string[] } = {}
+
+    let aaveCalls: Call[] = []
+
+    const aaveProtocols = AAVES_PER_CHAIN[chain] ?? []
+
+    // we only ned to check aave flash liquidity for aave assets
+    aaveProtocols.forEach(aaveFork => {
+        const underlyingsAndATokens = Object.entries(getAaveStyleProtocolTokenMap(chain, aaveFork))
+
+        const pool = getAaveTypePoolAddress(chain, aaveFork)
+
+        const tokenCalls = underlyingsAndATokens
+            .map(([a, b]: [string, any]) => [
+                { name: BalanceFetchCall.balanceOf, address: a, args: [b.aToken] },
+                { name: "getConfiguration", address: pool, args: [a] }
+            ])
+            .reduce((acc, b) => [...acc, ...b], [])
+
+        aaveAssets[aaveFork] = underlyingsAndATokens.map(a => a[0])
+
+        callLengths[aaveFork] = tokenCalls.length * 2 + 1
+
+
+        aaveCalls = [
+            ...aaveCalls,
+            ...tokenCalls,
+            { name: "FLASHLOAN_PREMIUM_TOTAL", address: pool },
+        ]
+    })
+
+    // @ts-ignore
+    const morphoBs = RELEVANT_MORPHOB_FORKS[chain] ?? []
+
+    const otherAssets = RELEVANT_LENDING_ASSETS[chain] ?? []
+
+    let morphoCalls: Call[] = []
+
+    if (morphoBs && morphoBs.length > 0) {
+        morphoBs.forEach(bFork => {
+            callLengths[bFork.pool] = otherAssets.length
+            morphoCalls = [
+                ...morphoCalls,
+                ...otherAssets.map(address => address === zeroAddress ? ({
+                    name: BalanceFetchCall.getEthBalance,
+                    address: MULTICALL_ADDRESS[chain],
+                    args: [bFork.address],
+                }) : ({ name: BalanceFetchCall.balanceOf, address, args: [bFork.address] }))
+            ]
+        })
+    }
+
+    const balancerV2s = RELEVANT_BALANCER_V2_FORKS[chain] ?? []
+
+    let balancerV2Calls: Call[] = []
+    if (balancerV2s && balancerV2s.length > 0) {
+        balancerV2s.forEach(bFork => {
+            callLengths[bFork.pool] = otherAssets.length
+            balancerV2Calls = [
+                ...balancerV2Calls,
+                ...otherAssets.map(address => address === zeroAddress ? ({
+                    name: BalanceFetchCall.getEthBalance,
+                    address: MULTICALL_ADDRESS[chain],
+                    args: [bFork.address],
+                }) : ({ name: BalanceFetchCall.balanceOf, address, args: [bFork.address] }))
+            ]
+        })
+    }
+
+    const balancerV3s = RELEVANT_BALANCER_V3_FORKS[chain] ?? []
+    let balancerV3Calls: Call[] = []
+    if (balancerV3s && balancerV3s.length > 0) {
+        balancerV3s.forEach(bFork => {
+            callLengths[bFork.pool] = otherAssets.length
+            balancerV3Calls = [
+                ...balancerV3Calls,
+                ...otherAssets.map(address => address === zeroAddress ? ({
+                    name: BalanceFetchCall.getEthBalance,
+                    address: MULTICALL_ADDRESS[chain],
+                    args: [bFork.address],
+                }) : ({ name: BalanceFetchCall.balanceOf, address, args: [bFork.address] }))
+            ]
+        })
+    }
+
+    const uniswapV4s = RELEVANT_UNISWAP_V4_FORKS[chain] ?? []
+    let uniswapV4Calls: Call[] = []
+    if (uniswapV4s && uniswapV4s.length > 0) {
+        uniswapV4s.forEach(u4Fork => {
+            callLengths[u4Fork.pool] = otherAssets.length
+            uniswapV4Calls = [
+                ...uniswapV4Calls,
+                ...otherAssets.map(address => address === zeroAddress ? ({
+                    name: BalanceFetchCall.getEthBalance,
+                    address: MULTICALL_ADDRESS[chain],
+                    args: [u4Fork.address],
+                }) : ({ name: BalanceFetchCall.balanceOf, address, args: [u4Fork.address] }))
+            ]
+        })
+    }
+
+    const calls = [
+        ...aaveCalls,
+        ...balancerV2Calls,
+        ...morphoCalls,
+        ...balancerV3Calls,
+        ...uniswapV4Calls,
+    ]
+
+    const rawResults = await multicallRetry(
+        chain,
+        calls,
+        FlashAbi,
+        DEFAULT_BATCH_SIZE,
+        3,
+        0,
+        false
+    )
+
+    let liquidity: FlashLiquiditiesOnChain = {}
+
+    let currentOffset = 0
+    aaveProtocols.forEach(aave => {
+        const callLen = aaveAssets[aave].length * 2 + 1
+
+        const data: any[] = rawResults.slice(currentOffset, callLen + currentOffset)
+        const fee = data[callLen - 1]
+        // update offset
+        currentOffset += callLen;
+
+
+        aaveAssets[aave].forEach((asset, i) => {
+            const decimals = getAssetMeta(chain, asset)?.decimals
+            const rawAmount = data[2 * i]
+
+            const config = data[2 * i + 1]
+            const enabled = !AAVE_V3_LENDERS.includes(aave as any) || getFlashLoanEnabled(config)
+            if (enabled && rawAmount > 0n) {
+                if (!liquidity[asset]) liquidity[asset] = []
+                liquidity[asset].push({
+                    id: FLASH_LOAN_IDS[aave],
+                    name: aave,
+                    type: AAVE_V2_LENDERS.includes(aave as any) ? FlashLoanIds.AAVE_V2 : FlashLoanIds.AAVE_V3,
+                    source: getAaveTypePoolAddress(chain, aave),
+                    fee: fee.toString(),
+                    availableRaw: rawAmount.toString(),
+                    available: Number(formatUnits(rawAmount, decimals ?? 18))
+                })
+            }
+        })
+    })
+
+
+    balancerV2s.forEach(balancer => {
+        const callLen = otherAssets.length
+
+        const data: any[] = rawResults.slice(currentOffset, callLen + currentOffset)
+        // update offset
+        currentOffset += callLen;
+
+
+        otherAssets.forEach((asset, i) => {
+            const decimals = getAssetMeta(chain, asset)?.decimals
+            const rawAmount = data[i]
+            if (rawAmount > 0n) {
+                if (!liquidity[asset]) liquidity[asset] = []
+                liquidity[asset].push({
+                    id: FLASH_LOAN_IDS[balancer.pool],
+                    name: balancer.pool,
+                    type: FlashLoanIds.BALANCER_V2,
+                    source: balancer.address,
+                    fee: "0",
+                    availableRaw: rawAmount.toString(),
+                    available: Number(formatUnits(rawAmount, decimals ?? 18))
+                })
+            }
+        })
+    })
+
+
+
+    morphoBs.forEach(morpho => {
+        const callLen = otherAssets.length
+
+        const data: any[] = rawResults.slice(currentOffset, callLen + currentOffset)
+        // update offset
+        currentOffset += callLen;
+
+
+        otherAssets.forEach((asset, i) => {
+            const decimals = getAssetMeta(chain, asset)?.decimals
+            const rawAmount = data[i]
+            if (rawAmount > 0n) {
+                if (!liquidity[asset]) liquidity[asset] = []
+                liquidity[asset].push({
+                    id: FLASH_LOAN_IDS[morpho.pool],
+                    name: morpho.pool,
+                    type: FlashLoanIds.MORPHO,
+                    source: morpho.address,
+                    fee: "0",
+                    availableRaw: rawAmount.toString(),
+                    available: Number(formatUnits(rawAmount, decimals ?? 18))
+                })
+            }
+        })
+    })
+
+    balancerV3s.forEach(balancerV3 => {
+        const callLen = otherAssets.length
+
+        const data: any[] = rawResults.slice(currentOffset, callLen + currentOffset)
+        // update offset
+        currentOffset += callLen;
+
+
+        otherAssets.forEach((asset, i) => {
+            const decimals = getAssetMeta(chain, asset)?.decimals
+            const rawAmount = data[i]
+            if (rawAmount > 0n) {
+                if (!liquidity[asset]) liquidity[asset] = []
+                liquidity[asset].push({
+                    id: FLASH_LOAN_IDS[balancerV3.pool],
+                    name: balancerV3.pool,
+                    type: FlashLoanIds.SINGLETON,
+                    source: balancerV3.address,
+                    fee: "0",
+                    availableRaw: rawAmount.toString(),
+                    available: Number(formatUnits(rawAmount, decimals ?? 18))
+                })
+            }
+        })
+    })
+
+    uniswapV4s.forEach(uniV4 => {
+        const callLen = otherAssets.length
+
+        const data: any[] = rawResults.slice(currentOffset, callLen + currentOffset)
+        // update offset
+        currentOffset += callLen;
+
+
+        otherAssets.forEach((asset, i) => {
+            const decimals = getAssetMeta(chain, asset)?.decimals
+            const rawAmount = data[i]
+            if (rawAmount > 0n) {
+                if (!liquidity[asset]) liquidity[asset] = []
+                liquidity[asset].push({
+                    id: FLASH_LOAN_IDS[uniV4.pool],
+                    name: uniV4.pool,
+                    type: FlashLoanIds.SINGLETON,
+                    source: uniV4.address,
+                    fee: "0",
+                    availableRaw: rawAmount.toString(),
+                    available: Number(formatUnits(rawAmount, decimals ?? 18))
+                })
+            }
+        })
+    })
+
+    return liquidity;
+
+}

package/src/flash-liquidity/index.ts

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

package/src/flash-liquidity/types.ts

@@ -0,0 +1,20 @@
+export enum FlashLoanIds {
+    MORPHO = 0,
+    BALANCER_V2 = 1,
+    AAVE_V3 = 2,
+    AAVE_V2 = 3,
+    SINGLETON = "SINGLETON"
+}
+export interface FlashLoanLiquidityForAsset {
+    id: number
+    type: FlashLoanIds
+    name: string
+    source: string
+    fee: string
+    availableRaw: string
+    available: number
+}
+
+export type FlashLiquiditiesOnChain = { [asset: string]: FlashLoanLiquidityForAsset[] }
+
+export type FlashLiquidity = { [chain: string]: FlashLiquiditiesOnChain }

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./lending"
+export * from "./lending-pairs"
+export * from "./yields"
+export * from "./prices"
+export * from "./utils"
+export * from "./flash-liquidity"
+export type { MulticallRetryFunction, GetEvmClientFunction, ProviderDependencies, OptionalProviderDependencies } from "./types/providers"

package/src/lending/aave-v2-type/misc.ts

@@ -0,0 +1,9 @@
+import { Chain, WRAPPED_NATIVE_INFO } from "@1delta/asset-registry";
+
+export const AURELIUS_REWARD_ASSETS = [WRAPPED_NATIVE_INFO[Chain.MANTLE], {
+    chainId: Chain.MANTLE,
+    address: '0x6e20E155819f0ee08d1291b0b9889b0e011b8224',
+    decimals: 18,
+    symbol: 'oAU',
+    name: 'Aurelius Call Option Token',
+}]

package/src/lending/aave-v2-type/publicCallBuild.ts

@@ -0,0 +1,105 @@
+
+import { AURELIUS_REWARD_ASSETS } from "./misc";
+import { getAaveAssets, getAaveStyleProtocolTokenMap, getAaveTypePoolDataProviderAddress } from "../../assets";
+import { Lender } from "@1delta/asset-registry";
+import { getAaveTypeIncentivesControllerAddress } from "../addresses";
+
+
+export const buildAaveV2StyleLenderReserveCall = (chainId: string, lender: Lender) => {
+  const providerAddress = getAaveTypePoolDataProviderAddress(chainId, lender)
+  const underlyingTokensArray = getAaveAssets(chainId, lender)
+  switch (lender) {
+    case Lender.AURELIUS: {
+      const aaveprotocolTokens = getAaveStyleProtocolTokenMap(chainId, lender)
+      const incentivesController = getAaveTypeIncentivesControllerAddress(chainId, lender)
+      const [reward0, reward1] = AURELIUS_REWARD_ASSETS.map(t => t.address)
+      return [
+        ...underlyingTokensArray.flatMap(asset => [
+          {
+            address: providerAddress,
+            name: 'getReserveData',
+            params: [asset],
+          },
+          {
+            address: providerAddress,
+            name: 'getReserveConfigurationData',
+            params: [asset],
+          },
+          {
+            address: incentivesController,
+            name: 'getRewardsData',
+            params: [aaveprotocolTokens[asset].aToken, reward0],
+          },
+          {
+            address: incentivesController,
+            name: 'getRewardsData',
+            params: [aaveprotocolTokens[asset].aToken, reward1],
+          },
+          {
+            address: incentivesController,
+            name: 'getRewardsData',
+            params: [aaveprotocolTokens[asset].vToken, reward0],
+          },
+          {
+            address: incentivesController,
+            name: 'getRewardsData',
+            params: [aaveprotocolTokens[asset].vToken, reward1],
+          },
+        ]),
+      ]
+    }
+    case Lender.LENDLE: {
+      const incentivesController = getAaveTypeIncentivesControllerAddress(chainId, lender)
+      const aaveprotocolTokens = getAaveStyleProtocolTokenMap(chainId, lender)
+      return [
+        ...underlyingTokensArray.flatMap(asset => [
+          {
+            address: providerAddress,
+            name: 'getReserveData',
+            params: [asset],
+          },
+          {
+            address: providerAddress,
+            name: 'getReserveConfigurationData',
+            params: [asset],
+          },
+          {
+            address: incentivesController,
+            name: 'poolInfo',
+            params: [aaveprotocolTokens[asset].aToken],
+          },
+          {
+            address: incentivesController,
+            name: 'poolInfo',
+            params: [aaveprotocolTokens[asset].vToken],
+          }
+        ]),
+        {
+          address: incentivesController,
+          name: 'rewardsPerSecond',
+          params: []
+        },
+        {
+          address: incentivesController,
+          name: 'totalAllocPoint',
+          params: []
+        },
+      ]
+    }
+    default:
+      return [
+        ...underlyingTokensArray.flatMap(tk => [
+          {
+            address: providerAddress,
+            name: 'getReserveData',
+            params: [tk],
+          },
+          {
+            address: providerAddress,
+            name: 'getReserveConfigurationData',
+            params: [tk],
+          },
+        ]),
+      ]
+  }
+}