@1delta/margin-fetcher 0.0.13 → 0.0.15-0.1

package/src/lending/fetchLenderExt.ts

@@ -1,82 +0,0 @@
-import { isMorphoType, isMultiMarket } from '../utils'
-import { AdditionalYields } from '../types'
-import { Lender } from '@1delta/asset-registry'
-import { GenericTokenList } from './types'
-import { fetchMorphoMarkets } from './morpho/fetchPublic'
-import { convertMarketsToMorphoResponse } from './morpho/convertPublic'
-
-async function getLenderDataFromApi(
-  lender: Lender,
-  chainId: string,
-  prices: { [a: string]: number },
-  additionalYields: AdditionalYields,
-) {
-  if (isMorphoType(lender)) return await fetchMorphoMarkets(chainId)
-  return {}
-}
-
-function convertLenderDataFromApi(
-  lender: Lender,
-  chainId: string,
-  data: any,
-  prices: { [a: string]: number },
-  additionalYields: AdditionalYields,
-  list: GenericTokenList = {},
-) {
-  if (isMorphoType(lender))
-    return convertMarketsToMorphoResponse(data, chainId, additionalYields, list)
-  return {}
-}
-
-export const getLenderPublicDataViaApi = async (
-  chainId: string,
-  lenders: Lender[],
-  prices: { [asset: string]: number },
-  additionalYields: AdditionalYields,
-  tokenList: () => Promise<GenericTokenList> = async () => {
-    return {}
-  },
-): Promise<{ [lender: string]: any }> => {
-  let promises: any[] = []
-  for (const lender of lenders) {
-    promises.push(
-      getLenderDataFromApi(lender, chainId, prices, additionalYields),
-    )
-  }
-
-  const [list, ...results] = await Promise.all([tokenList(), ...promises])
-
-  const lenderData: { [lender: string]: any } = {}
-  for (let i = 0; i < lenders.length; i++) {
-    try {
-      const lender = lenders[i]
-      if (isMultiMarket(lender)) {
-        const dataObtained = results[i]
-        const converted: any = convertLenderDataFromApi(
-          lender,
-          chainId,
-          dataObtained,
-          prices,
-          additionalYields,
-          list,
-        )
-        Object.keys(converted).forEach((marketId: string) => {
-          lenderData[marketId] = converted[marketId]
-        })
-      } else {
-        lenderData[lender] = convertLenderDataFromApi(
-          lender,
-          chainId,
-          results[i],
-          prices,
-          additionalYields,
-          list,
-        )
-      }
-    } catch (e) {
-      console.log('error fetching from API on', chainId, ':', e)
-    }
-  }
-
-  return lenderData
-}

package/src/lending/index.ts

@@ -1,5 +0,0 @@
-export * from "./fetchLender"
-export * from "./fetchLenderExt"
-export * from "./fetchLenderAll"
-export * from "./user-data"
-export * from "./types"

package/src/lending/init/publicCallBuild.ts

@@ -1,29 +0,0 @@
-import { Lender } from "@1delta/asset-registry"
-import { Call } from "../../utils/multicall"
-import { getInitLensAddress } from "../addresses/init"
-
-export const INIT_MODES = [1, 2, 3, 4, 5, 6]
-
-export const INIT_EMODE_LABELS: { [mode: number]: string } = {
-  [1]: 'Default',
-  [2]: 'Blue Chip Volatile',
-  [3]: 'Stablecoins',
-  [4]: 'ETH correlated',
-  [5]: 'Ethena',
-  [6]: 'BTC',
-}
-
-
-export const buildInitStyleLenderReserveCall = (chainId: string, lender: Lender) => {
-  const lensAddress = getInitLensAddress(chainId)
-  const calls: Call[] = INIT_MODES.map((mode) => {
-    return {
-      address: lensAddress,
-      name: 'getMarketData',
-      params: [mode],
-    }
-  })
-
-  return calls
-
-}

package/src/lending/init/publicCallParse.ts

@@ -1,93 +0,0 @@
-import { InitGeneralPublicResponse } from "./types";
-import { AdditionalYields } from "../../types";
-import { INIT_MODES } from "./publicCallBuild";
-import { getAssetMeta, toGenericPriceKey, toOracleKey } from "../../assets";
-import { convertRateToApr, parseRawAmount } from "../../utils/parsing";
-import { Lender } from "@1delta/asset-registry";
-import { GenericTokenList } from "../types";
-
-export const INIT_EMODE_LABELS: { [mode: number]: string } = {
-  [1]: 'Default',
-  [2]: 'Blue Chip Volatile',
-  [3]: 'Stablecoins',
-  [4]: 'ETH correlated',
-  [5]: 'Ethena',
-  [6]: 'BTC',
-}
-
-export const getInitReservesDataConverter = (
-  lender: Lender,
-  chainId: string,
-  prices: { [asset: string]: number },
-  additionalYields: AdditionalYields,
-  tokenList: GenericTokenList = {}
-): [(data: any[]) => InitGeneralPublicResponse | undefined, number] => {
-  const expectedNumberOfCalls = INIT_MODES.length
-  return [
-    (data: any[]) => {
-      if (data.length !== expectedNumberOfCalls) {
-        return undefined
-      }
-      const modeOne = 0
-      let result = Object.assign(
-        {}, ...data[modeOne]?.map(
-          (dat: any) => {
-            const asset = dat?.underlying.toLowerCase()
-            const meta = tokenList[asset] ?? { ...getAssetMeta(chainId, asset), address: asset }
-            const totalDeposits = parseRawAmount(dat?.totalSupply.toString(), meta?.decimals)
-            const totalDebt = parseRawAmount(dat?.totalDebt.toString(), meta.decimals)
-            const oracleKey = toOracleKey(meta?.assetGroup!) ?? toGenericPriceKey(asset, chainId)
-            const price = prices[oracleKey]
-            const liquidity = Number(totalDeposits) - Number(totalDebt)
-            return {
-              [asset]: {
-                poolId: asset,
-                underlying: asset,
-                asset: meta,
-                borrowCap: parseRawAmount(dat?.borrowCap.toString(), meta.decimals),
-                canBurn: Boolean(dat?.canBurn),
-                canFlash: Boolean(dat?.canFlash),
-                canMint: Boolean(dat?.canMint),
-                canRepay: Boolean(dat?.canRepay),
-                totalDeposits,
-                totalDebt,
-                totalDepositsUSD: price * Number(totalDeposits),
-                totalDebtUSD: price * Number(totalDebt),
-                totalLiquidity: liquidity,
-                totalLiquidityUSD: liquidity * price,
-                depositRate: convertRateToApr(Number(parseRawAmount(dat?.supplyRate.toString(), 18))),
-                variableBorrowRate: convertRateToApr(Number(parseRawAmount(dat?.borrowRate.toString(), 18))),
-                stableBorrowRate: 0,
-                stakingYield: additionalYields.intrinsicYields[oracleKey] ?? 0,
-                rewards: {},
-                config: {},
-                borrowingEnabled: totalDebt !== "0"
-              }
-            }
-          }
-        )
-      )
-
-      let eModes: any = {}
-      INIT_MODES.forEach((mode, index) => {
-        data[index]?.forEach((multicallData: any) => {
-          const asset = multicallData?.underlying.toLowerCase()
-          const cf = parseRawAmount(multicallData.collateralFactor, 18)
-          const modeData = {
-            category: mode,
-            label: INIT_EMODE_LABELS[mode],
-            borrowCollateralFactor: cf,
-            collateralFactor: cf,
-            borrowFactor: parseRawAmount(multicallData.borrowFactor, 18),
-            maxHealthAfterLiq: parseRawAmount(multicallData.maxHealthAfterLiq, 18),
-          }
-          if (!eModes[mode]) eModes[mode] = modeData
-          result[asset].config[mode] = modeData
-        });
-      });
-
-      return { data: result, eModes, chainId }
-    },
-    expectedNumberOfCalls
-  ]
-}

package/src/lending/init/types.ts

@@ -1,53 +0,0 @@
-import { RewardsMap } from "../aave-v3-type/types"
-import { GenericCurrency } from "../types"
-
-
-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,
-}

package/src/lending/morpho/convertPublic.ts

@@ -1,153 +0,0 @@
-import { formatUnits } from 'viem'
-import {
-  MorphoGeneralPublicResponse,
-  RewardsMap,
-  GetMarketsResponse,
-} from './types'
-import { apyToApr } from '../user-data/utils'
-import { AdditionalYields } from '../../types'
-import { GenericTokenList } from '../types'
-
-function parseLtv(ltv: number | string) {
-  let str = 0
-  try {
-    str = Number(formatUnits(BigInt(ltv), 18))
-  } catch (e) {}
-  return str
-}
-
-function formatNr(n: string, d: number) {
-  return Number(formatUnits(BigInt(n ?? 0), d))
-}
-
-export function convertMarketsToMorphoResponse(
-  response: GetMarketsResponse,
-  chainId: string,
-  additionalYields: AdditionalYields = {
-    intrinsicYields: {},
-    lenderRewards: {},
-    loaded: true,
-  },
-  tokens: GenericTokenList = {},
-):  { [m: string]: MorphoGeneralPublicResponse }  {
-  const data: { [m: string]: MorphoGeneralPublicResponse } = {}
-
-  response.markets.items.forEach((market) => {
-    const {
-      uniqueKey,
-      lltv,
-      irmAddress,
-      oracleAddress,
-      loanAsset,
-      collateralAsset,
-      state,
-    } = market
-    if (collateralAsset && loanAsset && oracleAddress) {
-      const m = 'MORPHO_BLUE_' + uniqueKey.slice(2).toUpperCase()
-      // @ts-ignore
-      if (!data[m]) data[m] = { data: {} }
-      // 1. LOAN asset entry
-      const loanRewards: RewardsMap = {}
-
-      // state.rewards?.forEach((reward) => {
-      //     loanRewards[reward.asset.address] = {
-      //         depositRate: formatNr(reward.amountPerSuppliedToken, reward.asset.decimals),
-      //         variableBorrowRate: formatNr(reward.amountPerBorrowedToken, reward.asset.decimals),
-      //         stableBorrowRate: 0,
-      //     }
-      // })
-
-      const loanAssetAddress = loanAsset.address.toLowerCase()
-
-      const meta = tokens[loanAssetAddress] ?? loanAsset
-
-      data[m].data[loanAssetAddress] = {
-        poolId: loanAssetAddress,
-        underlying: loanAssetAddress,
-        asset: meta,
-        totalDeposits: formatNr(state.supplyAssets, loanAsset.decimals),
-        totalDebtStable: 0,
-        totalDebt: formatNr(state.borrowAssets, loanAsset.decimals),
-        totalDepositsUSD: Number(state.supplyAssetsUsd),
-        totalDebtStableUSD: 0,
-        totalDebtUSD: Number(state.borrowAssetsUsd),
-        depositRate: apyToApr(Number(state.supplyApy)) * 100,
-        variableBorrowRate: apyToApr(Number(state.borrowApy)) * 100,
-        stableBorrowRate: 0,
-        stakingYield: additionalYields.intrinsicYields[meta?.assetGroup] ?? 0,
-        rewards: Object.keys(loanRewards).length > 0 ? loanRewards : undefined,
-        decimals: loanAsset.decimals,
-        config: {
-          0: {
-            category: 0,
-            borrowCollateralFactor: 0,
-            collateralFactor: 0,
-            borrowFactor: 1,
-          },
-        },
-        collateralActive: false,
-        borrowingEnabled: true,
-        hasStable: false,
-        isActive: true,
-        isFrozen: false,
-      }
-
-      const ltv = parseLtv(lltv)
-
-      const collateralAssetAddress = collateralAsset.address.toLowerCase()
-      const metaCollateral = tokens[collateralAssetAddress] ?? collateralAsset
-      // 2. COLLATERAL asset entry
-      data[m].data[collateralAssetAddress] = {
-        poolId: collateralAssetAddress,
-        underlying: collateralAssetAddress,
-        asset: metaCollateral,
-        totalDeposits: formatNr(
-          state.collateralAssets,
-          collateralAsset.decimals,
-        ),
-        totalDebtStable: 0,
-        totalDebt: 0,
-        totalDepositsUSD: Number(state.collateralAssetsUsd),
-        totalDebtStableUSD: 0,
-        totalDebtUSD: 0,
-        depositRate: 0,
-        variableBorrowRate: 0,
-        stableBorrowRate: 0,
-        stakingYield:
-          additionalYields.intrinsicYields[metaCollateral?.assetGroup] ?? 0,
-        rewards: undefined,
-        decimals: collateralAsset.decimals,
-        config: {
-          0: {
-            category: 0,
-            borrowCollateralFactor: ltv,
-            collateralFactor: ltv,
-            borrowFactor: 1,
-          },
-        },
-        collateralActive: true,
-        borrowingEnabled: false,
-        hasStable: false,
-        isActive: true,
-        isFrozen: false,
-      }
-
-      data[m].params = {
-        market: {
-          lender: m,
-          collateralDecimals: collateralAsset.decimals,
-          loanDecimals: loanAsset.decimals,
-          id: uniqueKey,
-          lltv,
-          oracle: oracleAddress,
-          irm: irmAddress,
-          collateralAddress: collateralAsset.address,
-          loanAddress: loanAsset.address,
-        },
-      }
-      data[m].chainId = chainId
-    }
-  })
-
-  return data
-}

package/src/lending/morpho/fetchPublic.ts

@@ -1,80 +0,0 @@
-
-export const query = (first: number, skip: number, chainId: string) => `
-query GetMarkets {
-  markets(first: ${first}, skip: ${skip}, where:  {
-     chainId_in: [${chainId}],
-     whitelisted: true
-  },
-  orderBy: SupplyAssetsUsd,   
-  orderDirection: Desc
-  ) {
-    items {
-      uniqueKey
-      irmAddress
-      oracleAddress
-      lltv
-      loanAsset {
-        address
-        name
-        symbol
-        decimals
-        priceUsd
-      }
-      collateralAsset {
-        address
-        name
-        symbol
-        decimals
-        priceUsd
-      }
-      state {
-        borrowApy
-        supplyApy
-        price
-        rewards {
-           asset {
-            address
-            name
-            symbol
-            decimals
-          }
-          amountPerBorrowedToken
-          amountPerSuppliedToken
-        }
-        borrowAssets
-        borrowAssetsUsd
-        supplyAssets
-        supplyAssetsUsd
-        collateralAssets
-        collateralAssetsUsd
-      }
-    }
-  }
-}
-`
-
-const BASE_URL = "https://blue-api.morpho.org/graphql"
-
-
-export async function fetchMorphoMarkets(chainId: string) {
-    const requestBody = {
-        query: query(200, 0, chainId),
-        variables: {},
-    };
-    const response = await fetch(BASE_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(requestBody),
-    });
-
-    if (!response.ok) {
-        throw new Error(`Network error: ${response.status} - ${response.statusText}`);
-    }
-
-    const data: any = await response.json();
-
-    return data.data
-
-}

package/src/lending/morpho/publicCallBuild.ts

@@ -1,11 +0,0 @@
-import { AdditionalYields } from "../../types"
-import { convertMarketsToMorphoResponse } from "./convertPublic"
-import { fetchMorphoMarkets } from "./fetchPublic"
-
-export async function fetchMorphoPublicData(
-    chainId: string,
-    yields: AdditionalYields = { intrinsicYields: {}, lenderRewards: {}, loaded: true }
-) {
-    const mbData = await fetchMorphoMarkets(chainId)
-    return convertMarketsToMorphoResponse(mbData, chainId, yields)
-}

package/src/lending/morpho/types.ts

@@ -1,129 +0,0 @@
-import { GenericCurrency } from "../types";
-
-
-export type GetMarketsResponse = {
-  markets: {
-    items: {
-      uniqueKey: string;
-      irmAddress: string;
-      oracleAddress: string;
-      lltv: string;
-      loanAsset: {
-        address: string;
-        name: string;
-        symbol: string;
-        decimals: number;
-        priceUsd: string;
-      };
-      collateralAsset: {
-        address: string;
-        name: string;
-        symbol: string;
-        decimals: number;
-        priceUsd: string;
-      };
-      state: {
-        borrowApy: string;
-        supplyApy: string;
-        price: string;
-        rewards: {
-          asset: {
-            address: string
-            name: string
-            symbol: string
-            decimals: number
-          }
-          amountPerBorrowedToken: string;
-          amountPerSuppliedToken: string;
-        }[];
-        borrowAssets: string;
-        borrowAssetsUsd: string;
-        supplyAssets: string
-        supplyAssetsUsd: string
-        collateralAssets: string;
-        collateralAssetsUsd: string;
-      };
-    }[];
-  };
-};
-
-export interface BaseYields {
-  // borrow interest rates
-  variableBorrowRate: number
-  stableBorrowRate: number
-  // deposit interest rate
-  depositRate: number
-}
-
-export type RewardsMap = { [rewardId: string]: BaseYields }
-
-
-
-export interface MorphoMarket {
-  /** the 1delta lender enum */
-  lender: string
-  collateralDecimals?: number
-  loanDecimals?: number
-
-
-  /** the market hash */
-  id: string,
-  /** market params */
-  lltv: string;
-  oracle: string;
-  irm: string;
-  collateralAddress: string;
-  loanAddress: string;
-}
-
-
-export interface MorphoGeneralPublicResponse {
-  data: {
-    [tokenSymbol: string]: {
-      poolId: string
-      underlying: string
-      asset: GenericCurrency
-      // token amounts
-      totalDeposits: number;
-      totalDebtStable: 0;
-      totalDebt: number;
-      // USD amounts
-      totalDepositsUSD: number;
-      totalDebtStableUSD: 0;
-      totalDebtUSD: number;
-      // rates
-      depositRate: number;
-      variableBorrowRate: number;
-      stakingYield: number;
-      stableBorrowRate: 0;
-
-      // rewards
-      rewards?: RewardsMap
-
-      // config part
-      decimals: number;
-
-      config: {
-        [0]: {
-          category: number
-          // collateral factors
-          borrowCollateralFactor: number
-          collateralFactor: number
-          borrowFactor: 1
-        }
-      }
-
-      // flags
-      collateralActive: boolean;
-      borrowingEnabled: boolean;
-      hasStable: false;
-      isActive: true;
-      isFrozen: false;
-    }
-  }
-  /** morpho market info */
-  params: {
-    market: MorphoMarket;
-  }
-  chainId: string
-}

package/src/lending/types/index.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 }