@1delta/margin-fetcher 0.0.46 → 0.0.47

package/src/prices/pendle/fetchPendlePrices.ts

@@ -1,208 +0,0 @@
-const PENDLE_API_BASE = 'https://api-v2.pendle.finance/core'
-const MARKETS_ENDPOINT = (chainId: string) =>
-  `${PENDLE_API_BASE}/v1/${chainId}/markets/active`
-const PRICES_ENDPOINT = (chainId: string, type: string = 'SY') =>
-  `${PENDLE_API_BASE}/v1/${chainId}/assets/prices?&type=${type}`
-
-const SUPPORTED_CHAINS = [
-  // '1', Disabled for now
-  '42161',
-  '10',
-  '56',
-  '8453',
-  '5000',
-  '146',
-  '80094',
-]
-
-let marketsCache: PendleMarketResponse | null = null
-let marketsCacheTimestamp: number = 0
-const MARKETS_CACHE_TTL = 5 * 60 * 1000 // 5mins
-
-interface PendleMarket {
-  name: string
-  address: string
-  expiry: string
-  pt: string
-  yt: string
-  sy: string
-  underlyingAsset: string
-  details: any
-  isNew: boolean
-  isPrime: boolean
-  timestamp: string
-}
-
-interface PendleMarketResponse {
-  markets: PendleMarket[]
-}
-
-interface PendlePricesResponse {
-  prices: { [address: string]: number }
-  total: number
-  skip: number
-  limit: number
-}
-
-/**
- * Fetch Pendle markets data for a specific chain
- */
-async function fetchMarketsForChain(chainId: string): Promise<PendleMarket[]> {
-  try {
-    const response = await fetch(MARKETS_ENDPOINT(chainId))
-    const data = (await response.json()) as PendleMarketResponse
-    return data.markets || []
-  } catch (error) {
-    console.error(`Error fetching markets for chain ${chainId}:`, error)
-    return []
-  }
-}
-
-/**
- * Fetch and cache Pendle markets data for all supported chains
- */
-async function fetchPendleMarkets(): Promise<PendleMarketResponse> {
-  const now = Date.now()
-
-  if (marketsCache && now - marketsCacheTimestamp < MARKETS_CACHE_TTL) {
-    return marketsCache
-  }
-
-  try {
-    const allMarkets: PendleMarket[] = []
-    const promises = []
-
-    for (const chainId of SUPPORTED_CHAINS) {
-      const chainMarkets = fetchMarketsForChain(chainId)
-      promises.push(chainMarkets)
-    }
-    const results = await Promise.all(promises)
-
-    allMarkets.push(...results.flat())
-
-    const result: PendleMarketResponse = { markets: allMarkets }
-    marketsCache = result
-    marketsCacheTimestamp = now
-
-    return result
-  } catch (error) {
-    console.error('Error fetching Pendle markets:', error)
-    // return cached data (if any, even if expired, it is better than nothing I guess)
-    return marketsCache || { markets: [] }
-  }
-}
-
-/**
- * Fetch prices for a specific chain and token type
- */
-async function fetchPendlePricesForChain(
-  chainId: string,
-  type: string = 'all',
-): Promise<{ [address: string]: number }> {
-  try {
-    // Fetch prices for different token types (PT, YT, SY, PENDLE_LP)
-    const types = type === 'all' ? ['PT', 'YT', 'SY', 'PENDLE_LP'] : [type]
-    let allPrices: { [address: string]: number } = {}
-
-    try {
-      const response = await fetch(PRICES_ENDPOINT(chainId, types.join(',')))
-      const data = (await response.json()) as PendlePricesResponse
-      allPrices = data.prices
-    } catch (error) {
-      console.error(`Error fetching prices for chain ${chainId}:`, error)
-    }
-
-    return allPrices
-  } catch (error) {
-    console.error(`Error fetching Pendle prices for chain ${chainId}:`, error)
-    return {}
-  }
-}
-
-/**
- * Extract relevant token addresses from markets data
- * Note: Seperating the chainId from address is not really required since we do the same when we return results
- * but it allows to extend the file later and use individual addresses (maybe), or we can simplify this
- */
-function extractTokenAddressesFromMarkets(markets: PendleMarket[]): {
-  [chainId: string]: { pt: string[]; yt: string[]; sy: string[] }
-} {
-  const tokensByChain: {
-    [chainId: string]: { pt: string[]; yt: string[]; sy: string[] }
-  } = {}
-
-  markets.forEach((market) => {
-    const chain = market.pt?.split('-')[0]
-
-    if (chain && !tokensByChain[chain]) {
-      tokensByChain[chain] = { pt: [], yt: [], sy: [] }
-    }
-
-    // Add token addresses to their respective chains
-    if (market.pt && chain) {
-      const address = market.pt.split('-')[1]
-      if (address && !tokensByChain[chain].pt.includes(address)) {
-        tokensByChain[chain].pt.push(address)
-      }
-    }
-
-    if (market.yt && chain) {
-      const address = market.yt.split('-')[1]
-      if (address && !tokensByChain[chain].yt.includes(address)) {
-        tokensByChain[chain].yt.push(address)
-      }
-    }
-
-    if (market.sy && chain) {
-      const address = market.sy.split('-')[1]
-      if (address && !tokensByChain[chain].sy.includes(address)) {
-        tokensByChain[chain].sy.push(address)
-      }
-    }
-  })
-
-  return tokensByChain
-}
-
-/**
- * Main function to fetch Pendle prices
- */
-export async function fetchPendlePrices(): Promise<{
-  [address: string]: number
-}> {
-  try {
-    const marketsResponse = await fetchPendleMarkets()
-
-    if (!marketsResponse.markets.length) {
-      // console.warn('No Pendle markets found')
-      return {}
-    }
-
-    const tokensByChain = extractTokenAddressesFromMarkets(
-      marketsResponse.markets,
-    )
-
-    const allPrices: { [address: string]: number } = {}
-
-    for (const chainId of SUPPORTED_CHAINS) {
-      if (tokensByChain[chainId]) {
-        // console.log(`Fetching Pendle prices for chain ${chainId}`)
-        const chainPrices = await fetchPendlePricesForChain(chainId, 'YT') // only fetch YT prices
-
-        // create a chainId-address key for each token price
-        Object.entries(chainPrices).forEach(([address, price]) => {
-          if (price !== 0) {
-            const prefixedAddress = `${chainId}-${address}`
-            allPrices[prefixedAddress] = price
-          }
-        })
-      }
-    }
-
-    // console.log(`Fetched ${Object.keys(allPrices).length} Pendle token prices`)
-    return allPrices
-  } catch (error) {
-    console.error('Error in fetchPendlePrices:', error)
-    return {}
-  }
-}

package/src/prices/pendle/index.ts

@@ -1 +0,0 @@
-export * from './fetchPendlePrices'

package/src/types/apiReturnType.ts

@@ -1,76 +0,0 @@
-import { GenericCurrency } from "./general"
-
-export interface BaseYields {
-  // borrow interest rates
-  variableBorrowRate: number
-  stableBorrowRate: number
-  // deposit interest rate
-  depositRate: number
-}
-
-export type RewardsMap = { [rewardId: string]: BaseYields }
-
-
-export interface ConfigEntry {
-  category: number
-  borrowCollateralFactor: number
-  collateralFactor: number
-  borrowFactor: number
-}
-
-interface PoolConfig {
-  [category: number]: ConfigEntry
-}
-
-interface EMode {
-  category: number
-  label: string
-  borrowCollateralFactor: number
-  collateralFactor: number
-  borrowFactor: number
-}
-
-export interface PoolData {
-  poolId: string
-  underlying: string
-  asset: GenericCurrency
-  totalDeposits: string
-  totalDebtStable: string
-  totalDebt: string
-  totalLiquidity: number
-  totalDepositsUSD: number
-  totalDebtStableUSD: number
-  totalDebtUSD: number
-  totalLiquidityUSD: number
-  depositRate: number
-  variableBorrowRate: number
-  stableBorrowRate: number
-  stakingYield: number
-  rewards: RewardsMap
-  decimals: number
-  config: PoolConfig
-  collateralActive: boolean
-  borrowingEnabled: boolean
-  hasStable: boolean
-  isActive: boolean
-  isFrozen: boolean
-  eMode: EMode
-  borrowCap: number
-  supplyCap: number
-  debtCeiling: string
-}
-
-export type LenderData = {
-  [chainId: string]: {
-    data: {
-      [lender: string]: {
-        data: {
-          [poolId: string]: PoolData
-        }
-        eModes: { [modeId: number]: EMode }
-        chainId: string
-      }
-    }
-    lastFetched: number
-  }
-}

package/src/types/general.ts

@@ -1,16 +0,0 @@
-export interface GenericCurrency {
-    /** chainId as string */
-    chainId: string
-    /** lower case address */
-    address: string
-    /** name */
-    name?: string
-    /** symbol */
-    symbol?: string
-    /** decimal number */
-    decimals: number
-    /** extensible */
-    [k: string]: any
-}
-
-export type GenericTokenList = { [addressLowerCase: string]: GenericCurrency }

package/src/types/index.ts

@@ -1,5 +0,0 @@
-export * from './apiReturnType'
-export * from './misc'
-export * from './providers'
-export * from './lenderTypes'
-export * from './general'

package/src/types/lender/aave-v2-types.ts

@@ -1,96 +0,0 @@
-import { RewardsMap } from './aave-v3-types'
-import { GenericCurrency } from '../general'
-
-export enum AaveV2TypeGetReserveDataIndexes {
-  availableLiquidity = 0,
-  totalStableDebt,
-  totalVariableDebt,
-  liquidityRate,
-  variableBorrowRate,
-  stableBorrowRate,
-  averageStableBorrowRate,
-  liquidityIndex,
-  variableBorrowIndex,
-  lastUpdateTimestamp,
-}
-
-export enum AaveV2TypeGetReserveConfigurationData {
-  decimals = 0,
-  ltv,
-  liquidationThreshold,
-  liquidationBonus,
-  reserveFactor,
-  usageAsCollateralEnabled,
-  borrowingEnabled,
-  stableBorrowRateEnabled,
-  isActive,
-  isFrozen,
-}
-
-export enum AaveV2TypeGetUserReserveData {
-  currentATokenBalance = 0,
-  currentStableDebt,
-  currentVariableDebt,
-  principalStableDebt,
-  scaledVariableDebt,
-  stableBorrowRate,
-  liquidityRate,
-  stableRateLastUpdated,
-  usageAsCollateralEnabled,
-}
-
-export enum AaveV2TypeIncentivesControllerPoolInfoIndexes {
-  totalSupply = 0,
-  allocPoint,
-  lastRewardTime,
-  accRewardPerShare,
-  onwardIncentives,
-}
-
-export interface AaveV2GeneralPublicResponse {
-  data: {
-    [tokenSymbol: string]: {
-      asset: GenericCurrency
-      // token amounts
-      totalDeposits: number
-      totalDebtStable: number
-      totalDebt: number
-      // USD amounts
-      totalDepositsUSD: number
-      totalDebtStableUSD: number
-      totalDebtUSD: number
-
-      // reserve market data
-      depositRate: number
-      variableBorrowRate: number
-      stableBorrowRate: number
-      lastUpdateTimestamp?: number
-      stakingYield: number
-
-      // rewards
-      rewards?: RewardsMap
-
-      // reserve config
-      decimals?: number
-      usageAsCollateralEnabled?: boolean
-
-      config: {
-        [0]: {
-          category: 0
-          // collateral factors
-          borrowCollateralFactor: number
-          collateralFactor: number
-          borrowFactor: number
-        }
-      }
-
-      // flags
-      collateralActive: boolean
-      borrowingEnabled: boolean
-      hasStable: boolean
-      isActive: boolean
-      isFrozen: boolean
-    }
-  }
-  chainId: string
-}

package/src/types/lender/aave-v3-types.ts

@@ -1,185 +0,0 @@
-import { GenericCurrency } from '../general'
-
-export interface BaseYields {
-  // borrow interest rates
-  variableBorrowRate: number
-  stableBorrowRate: number
-  // deposit interest rate
-  depositRate: number
-}
-
-export type RewardsMap = { [rewardId: string]: BaseYields }
-
-export interface ModeBase {
-  category: number
-  label: string
-}
-
-export interface EModeData extends ModeBase {
-  borrowCollateralFactor: number
-  collateralFactor: number
-  priceSource: string
-}
-
-export enum AaveV3GetReservesIndexes {
-  unbacked = 0,
-  accruedToTreasuryScaled = 1,
-  totalAToken = 2,
-  totalStableDebt = 3,
-  totalVariableDebt = 4,
-  liquidityRate = 5,
-  variableBorrowRate = 6,
-  stableBorrowRate = 7,
-  averageStableBorrowRate = 8,
-  liquidityIndex = 9,
-  variableBorrowIndex = 10,
-  lastUpdateTimestamp = 11,
-}
-
-export enum AaveV3PoolGetReservesFields {
-  configuration = 0,
-  liquidityIndex,
-  currentLiquidityRate,
-  variableBorrowIndex,
-  currentVariableBorrowRate,
-  currentStableBorrowRate,
-  lastUpdateTimestamp,
-  id,
-  aTokenAddress,
-  stableDebtTokenAddress,
-  variableDebtTokenAddress,
-  interestRateStrategyAddress,
-  accruedToTreasury,
-  unbacked,
-  isolationModeTotalDebt,
-}
-
-export enum AaveV3GetreserveConfigDataIndexes {
-  decimals = 0,
-  ltv,
-  liquidationThreshold,
-  liquidationBonus,
-  reserveFactor,
-  usageAsCollateralEnabled,
-  borrowingEnabled,
-  stableBorrowRateEnabled,
-  isActive,
-  isFrozen,
-}
-
-/** Names for the emode struct query */
-
-export enum AaveV3GetEModeCategoryDataIndexes {
-  ltv = 'ltv',
-  liquidationThreshold = 'liquidationThreshold',
-  liquidationBonus = 'liquidationBonus',
-  priceSource = 'priceSource',
-  label = 'label',
-}
-
-export interface AaveV3GeneralPublicResponse {
-  data: {
-    [tokenSymbol: string]: {
-      asset: GenericCurrency
-      // token amounts
-      totalDeposits: number
-      totalDebtStable: number
-      totalDebt: number
-      // USD amounts
-      totalDepositsUSD: number
-      totalDebtStableUSD: number
-      totalDebtUSD: number
-      // rates
-      depositRate: number
-      variableBorrowRate: number
-      stableBorrowRate: number
-      averageStableBorrowRate: number
-      // misc
-      liquidityIndex: string
-      variableBorrowIndex: string
-      lastUpdateTimestamp: number
-      // rewards
-      rewards?: RewardsMap
-
-      // config part
-      decimals: number
-
-      config: {
-        [modeId: number]: {
-          category: number
-          // collateral factors
-          borrowCollateralFactor: number
-          collateralFactor: number
-          borrowFactor: 1
-        }
-      }
-
-      // flags
-      collateralActive: boolean
-      borrowingEnabled: boolean
-      hasStable: boolean
-      isActive: boolean
-      isFrozen: boolean
-
-      // eMode
-      eMode: {
-        label: string
-        category: number
-        borrowCollateralFactor: number
-        collateralFactor: number
-        priceSource: string
-      }
-
-      // caps
-      borrowCap: number
-      supplyCap: number
-      debtCeiling: number
-    }
-  }
-  chainId: string
-  eModes: {
-    [mode: number]: EModeData
-  }
-}
-
-export enum AaveTypeGetUserReserveIndexes {
-  currentATokenBalance = 0,
-  currentStableDebt,
-  currentVariableDebt,
-  principalStableDebt,
-  scaledVariableDebt,
-  stableBorrowRate,
-  liquidityRate,
-  stableRateLastUpdated,
-  usageAsCollateralEnabled,
-}
-
-export enum YldrTypeGetUserReserveIndexes {
-  currentYTokenBalance = 0,
-  currentVariableDebt,
-  scaledVariableDebt,
-  liquidityRate,
-  usageAsCollateralEnabled,
-}
-
-export enum YLDRTypeGetReserveDataIndexes {
-  accruedToTreasuryScaled = 0,
-  totalYToken,
-  totalVariableDebt,
-  liquidityRate,
-  variableBorrowRate,
-  liquidityIndex,
-  variableBorrowIndex,
-  lastUpdateTimestamp,
-}
-export enum YLDRTypeGetReserveConfigurationData {
-  decimals = 0,
-  ltv,
-  liquidationThreshold,
-  liquidationBonus,
-  reserveFactor,
-  usageAsCollateralEnabled,
-  borrowingEnabled,
-  isActive,
-  isFrozen,
-}

package/src/types/lender/compound-v3-types.ts

@@ -1,43 +0,0 @@
-import { RewardsMap } from '../apiReturnType'
-import { GenericCurrency } from '../general'
-
-export enum CometInterestRateIndexes {
-  borrowRate = 0,
-  supplyRate = 1,
-  utilization = 2,
-}
-
-export interface CompoundV3GeneralPublicResponse {
-  data: {
-    [tokenSymbol: string]: {
-      asset: GenericCurrency
-
-      config: {
-        [0]: {
-          category: 0
-          // collateral factors
-          borrowCollateralFactor: number
-          collateralFactor: number
-          borrowFactor: 1
-        }
-      }
-
-      liquidationFactor: string
-      supplyCap: number
-
-      // interest rates
-      variableBorrowRate: number
-      depositRate: number
-
-      utilization: number
-
-      totalDebt: number
-      // deposits are different outputs for base asset and others
-      totalDeposits: number
-
-      // rewards
-      rewards?: RewardsMap
-    }
-  }
-  chainId: string
-}

package/src/types/lender/init-types.ts

@@ -1,51 +0,0 @@
-import { RewardsMap } from '../apiReturnType'
-import { GenericCurrency } from '../general'
-
-export interface InitGeneralPublicResponse {
-  data: {
-    [tokenSymbol: string]: {
-      asset: GenericCurrency
-      // reserve market data
-      unbacked?: number
-      depositRate: number
-      averageStableBorrowRate?: number
-      liquidityIndex?: string
-      variableBorrowIndex?: string
-      lastUpdateTimestamp?: number
-
-      config: {
-        [modeId: number]: {
-          category: number
-          // collateral factors
-          borrowCollateralFactor: number
-          collateralFactor: number
-          borrowFactor: number
-        }
-      }
-
-      // rewards
-      rewards?: RewardsMap
-
-      // reserve config
-      decimals?: number
-      reserveFactor?: string
-      usageAsCollateralEnabled?: boolean
-      stableBorrowRateEnabled?: boolean
-
-      // frozen
-      isActive?: boolean
-      isFrozen?: boolean
-    }
-  }
-  chainId: string
-}
-
-export interface InitReservesQueryParams {
-  chainId: string
-}
-
-export enum InitGetUserPositionDataIndexes {
-  posMeta = 0,
-  collaterals,
-  debts,
-}