@1delta/margin-fetcher 0.0.1

package/src/lending/addresses/init.ts

@@ -0,0 +1,37 @@
+import { Chain } from "@1delta/asset-registry"
+
+export function getInitPosManagerAddress(chainId: string) {
+  // @ts-ignore
+  return addressesInitCore.PosManager[chainId]
+}
+
+export function getInitCoreAddress(chainId: string) {
+  // @ts-ignore
+  return addressesInitCore.Core[chainId]
+}
+
+export function getInitLensAddress(chainId: string) {
+  // @ts-ignore
+  return addressesInitCore.PublicLens[chainId]
+}
+
+const addressesInitCore = {
+  InitOracle: {
+    [Chain.MANTLE]: '0x4E195A32b2f6eBa9c4565bA49bef34F23c2C0350'
+  },
+  Core: {
+    [Chain.MANTLE]: '0x972BcB0284cca0152527c4f70f8F689852bCAFc5'
+  },
+  Config: {
+    [Chain.MANTLE]: '0x007F91636E0f986068Ef27c950FA18734BA553Ac'
+  },
+  PosManager: {
+    [Chain.MANTLE]: '0x0e7401707CD08c03CDb53DAEF3295DDFb68BBa92'
+  },
+  Lens: {
+    [Chain.MANTLE]: '0x7d2b278b8ef87bEb83AeC01243ff2Fed57456042'
+  },
+  PublicLens: {
+    [Chain.MANTLE]: '0xDf75fF0452eDf4897B051A54b406eB384503Ac39'
+  },
+}

package/src/lending/addresses/lendle.ts

@@ -0,0 +1,13 @@
+import { Chain } from "@1delta/asset-registry";
+
+export const addressesLendleCore = {
+  AaveOracle: {
+    [Chain.MANTLE]: '0x870c9692Ab04944C86ec6FEeF63F261226506EfC'
+  },
+  IncentivesController: {
+    [Chain.MANTLE]: '0x79e2fd1c484EB9EE45001A98Ce31F28918F27C41'
+  },
+  MultiFeeDistribution: {
+    [Chain.MANTLE]: '0x5C75A733656c3E42E44AFFf1aCa1913611F49230'
+  },
+}

package/src/lending/addresses/meridian.ts

@@ -0,0 +1,13 @@
+import { Chain } from "@1delta/asset-registry";
+
+export const addressesMeridianCore = {
+  AaveOracle: {
+    [Chain.TAIKO_ALETHIA]: '0xd79417be2cE02fc22F2E520869b1DfC02a677751',
+  },
+  IncentivesController: {
+    [Chain.TAIKO_ALETHIA]: '0xb3020EbFD800B488B64E92A8717E826cBf0d63E2'
+  },
+  MultiFeeDistribution: {
+    [Chain.TAIKO_ALETHIA]: '0xb0e103e2A80489Ba697D882EEd0Ba552389Ca31E'
+  }
+}

package/src/lending/addresses/takotako.ts

@@ -0,0 +1,14 @@
+import { Chain } from "@1delta/asset-registry";
+
+
+export const addressesTakoTakoCore = {
+  AaveOracle: {
+    [Chain.TAIKO_ALETHIA]: '0x4Feb232c357F5Fb11A6Ff43FC46808BebC2f55b5'
+  },
+  IncentivesController: {
+    [Chain.TAIKO_ALETHIA]: '0x'
+  },
+  MultiFeeDistribution: {
+    [Chain.TAIKO_ALETHIA]: '0x'
+  },
+}

package/src/lending/compound-v3/publicCallBuild.ts

@@ -0,0 +1,74 @@
+import { Lender } from "@1delta/asset-registry"
+import { getCompoundV3Assets } from "../../assets"
+import { getCompoundV3BaseAsset, getCompoundV3CometAddress, getCompoundV3CometIRGetterAddress } from "../addresses/compoundV3"
+import { Call } from "../../utils/multicall"
+
+export const buildCompoundV3StyleLenderReserveCall = (chainId: string, lender: Lender) => {
+
+  const baseAssetData = getCompoundV3BaseAsset(lender, chainId)
+  const underlyingArray = getCompoundV3Assets(chainId, lender)
+  const cometContractAddress = getCompoundV3CometAddress(chainId, lender)!
+  const assetsToQuery = underlyingArray
+  const tokensNoBase = assetsToQuery.filter(a => a !== baseAssetData.baseAsset)
+
+  const callsAssetInfoAndTotals: Call[] = tokensNoBase.flatMap((tk) => {
+    return [
+      {
+        address: cometContractAddress,
+        name: 'getAssetInfoByAddress',
+        params: [tk],
+      },
+      {
+        address: cometContractAddress,
+        name: 'totalsCollateral',
+        params: [tk],
+      }
+    ]
+  })
+
+  const callSupplyRewards: Call = {
+    address: cometContractAddress,
+    name: 'baseTrackingSupplySpeed',
+    params: [],
+  }
+
+  const callBorrowRewards: Call = {
+    address: cometContractAddress,
+    name: 'baseTrackingBorrowSpeed',
+    params: [],
+  }
+
+  const callIndexScale: Call = {
+    address: cometContractAddress,
+    name: 'baseIndexScale',
+    params: [],
+  }
+
+  const callSupply: Call = {
+    address: cometContractAddress,
+    name: 'totalSupply',
+    params: [],
+  }
+
+  const callBorrow: Call = {
+    address: cometContractAddress,
+    name: 'totalBorrow',
+    params: [],
+  }
+
+  const callInterest: Call = {
+    address: getCompoundV3CometIRGetterAddress(chainId),
+    name: 'getCometInterest',
+    params: [cometContractAddress],
+  }
+  const calls = [
+    ...callsAssetInfoAndTotals,
+    callSupplyRewards,
+    callBorrowRewards,
+    callIndexScale, // rewards data
+    callSupply,
+    callBorrow,  // supply / borrow
+    callInterest
+  ]
+  return calls
+}

package/src/lending/compound-v3/publicCallParse.ts

@@ -0,0 +1,143 @@
+import { Lender } from "@1delta/asset-registry"
+import { AdditionalYields } from "../../types"
+import { CometInterestRateIndexes, CompoundV3GeneralPublicResponse } from "./types"
+import { getAssetMeta, getCompoundV3Assets, LENDER_MODE_NO_MODE, toGenericPriceKey, toOracleKey } from "../../assets"
+import { getCompoundV3BaseAsset } from "../addresses/compoundV3"
+import { calculateRateForCompound, parseRawAmount } from "../../utils/parsing"
+
+const COMET_RISK_DECIMALS = 18
+const SECONDS_PER_DAY = 3600 * 24
+const DAYS_IN_YEAR = 365
+
+export const getCompoundV3ReservesDataConverter = (
+  lender: Lender,
+  chainId: string,
+  prices: { [asset: string]: number },
+  additionalYields: AdditionalYields
+): [(data: any[]) => CompoundV3GeneralPublicResponse | undefined, number] => {
+
+  const assetsToQuery = getCompoundV3Assets(chainId, lender)
+  const baseAssetData = getCompoundV3BaseAsset(lender, chainId)
+  const tokensNoBase = assetsToQuery.filter(a => a !== baseAssetData.baseAsset)
+
+  const baseLength = tokensNoBase.length * 2
+  const expectedNumberOfCalls = baseLength + 6
+  return [
+    (data: any[]) => {
+      if (data.length !== expectedNumberOfCalls) {
+        return undefined
+      }
+      let result: any = {}
+      for (let i = 0; i < tokensNoBase.length; i++) {
+        const asset = tokensNoBase[i]
+        const resultsAssetInfo = data[i * 2]
+        const resultsTotals = data[i * 2 + 1]
+        const assetMeta = getAssetMeta(chainId, asset)
+        const decimals = assetMeta?.decimals ?? 18
+        const totals = parseRawAmount(resultsTotals[0], decimals)
+        const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(asset, chainId)
+        result[asset] = {
+          poolId: asset,
+          underlying: asset,
+          config: {
+            [LENDER_MODE_NO_MODE]: {
+              category: LENDER_MODE_NO_MODE,
+              // collateral factors
+              borrowCollateralFactor: parseRawAmount(resultsAssetInfo.borrowCollateralFactor.toString(), COMET_RISK_DECIMALS),
+              collateralFactor: parseRawAmount(resultsAssetInfo.liquidateCollateralFactor.toString(), COMET_RISK_DECIMALS),
+              borrowFactor: 1
+            }
+          },
+          supplyCap: parseRawAmount(resultsAssetInfo.supplyCap.toString(), decimals),
+
+          // interest rates
+          variableBorrowRate: 0,
+          stableBorrowRate: 0,
+          depositRate: 0,
+          stakingYield: additionalYields.intrinsicYields[oracleKey] ?? 0,
+
+          utilization: 0,
+          // debt and liquidity are zero
+          totalDebt: 0,
+          totalDebtUSD: 0,
+          totalLiquidity: 0,
+          totalLiquidityUSD: 0,
+          // deposits are different outputs for base asset and others
+          totalDeposits: totals,
+          totalDepositsUSD: Number(totals) * (prices[oracleKey] ?? 1),
+          // rewards
+          rewards: {},
+          borrowingEnabled: false
+        }
+      }
+
+      const baseMeta = getAssetMeta(chainId, baseAssetData.baseAsset)
+
+      // parse data for rewards calculation
+      const decimals = baseMeta?.decimals ?? 18
+      const resultsSupplyRewards = Number(data[baseLength]?.toString())
+      const resultsBorrowRewards = Number(data[baseLength + 1]?.toString())
+      const resultsIndexScale = data[baseLength + 2]?.toString()
+      const resultsSupply = parseRawAmount(data[baseLength + 3]?.toString(), decimals)
+      const resultsBorrow = parseRawAmount(data[baseLength + 4]?.toString(), decimals)
+
+      const compToSuppliersPerDay = resultsSupplyRewards / Number(resultsIndexScale) * SECONDS_PER_DAY;
+      const compToBorrowersPerDay = resultsBorrowRewards / Number(resultsIndexScale) * SECONDS_PER_DAY;
+
+      const resultsInterest = data[baseLength + 5]
+
+      const oracleKeyBase = toOracleKey(baseMeta.assetGroup) ?? toGenericPriceKey(baseAssetData.baseAsset, chainId)
+      const price = prices[oracleKeyBase] ?? 1
+      const liquidity = Number(resultsSupply) - Number(resultsBorrow)
+      const compPrice = prices["COMP"]
+
+      const baseData = {
+        [baseAssetData.baseAsset]: {
+          poolId: baseAssetData.baseAsset,
+          underlying: baseAssetData.baseAsset,
+          // collateral factots
+          borrowCollateralFactor: 0,
+          collateralFactor: 0,
+          supplyCap: 0,
+
+          config: {
+            [LENDER_MODE_NO_MODE]: {
+              category: LENDER_MODE_NO_MODE,
+              // collateral factors
+              borrowCollateralFactor: 0,
+              collateralFactor: 0,
+              borrowFactor: 1
+            }
+          },
+          // interest rates
+          variableBorrowRate: calculateRateForCompound(resultsInterest[CometInterestRateIndexes.borrowRate].toString(), chainId, lender),
+          depositRate: calculateRateForCompound(resultsInterest[CometInterestRateIndexes.supplyRate].toString(), chainId, lender),
+          stableBorrowRate: 0,
+          utilization: parseRawAmount(resultsInterest[CometInterestRateIndexes.utilization].toString(), COMET_RISK_DECIMALS),
+
+          totalLiquidity: liquidity,
+          totalLiquidityUSD: liquidity * price,
+
+          totalDebt: resultsBorrow,
+          totalDeposits: resultsSupply,
+
+          totalDebtUSD: Number(resultsBorrow) * price,
+          totalDepositsUSD: Number(resultsSupply) * price,
+          // rewards
+          rewards: {
+            COMP: {
+              depositRate: (compPrice * compToSuppliersPerDay / Number(resultsSupply)) * DAYS_IN_YEAR * 100 / price,
+              variableBorrowRate: (compPrice * compToBorrowersPerDay / Number(resultsBorrow)) * DAYS_IN_YEAR * 100 / price,
+              stableBorrowRate: 0,
+            }
+          },
+          borrowingEnabled: true,
+          stakingYield: additionalYields.intrinsicYields[oracleKeyBase] ?? 0,
+        }
+      }
+      return { data: { ...result, ...baseData }, chainId }
+    },
+    expectedNumberOfCalls
+  ]
+}
+

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

@@ -0,0 +1,43 @@
+import { RewardsMap } from "../aave-v3-type/types";
+
+
+
+export enum CometInterestRateIndexes {
+  borrowRate = 0,
+  supplyRate = 1,
+  utilization = 2
+}
+
+export interface CompoundV3GeneralPublicResponse {
+  data: {
+    [tokenSymbol: string]: {
+
+      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/lending/fetchLender.ts

@@ -0,0 +1,138 @@
+
+// aave v2 style
+import { ProtocolDataProviderAbi } from '../abis/aave-v2/ProtocolDataProvider'
+import { IncentivesControllerAbi } from '../abis/lendle/IncentivesController'
+import { RewarderAbi } from '../abis/aurelius/Rewarder'
+import { UniswapV2PairAbi } from '../abis/uniswap/UniswapV2Pair'
+
+// aave v3 style
+import { AavePoolV3UpgradedAbi } from '../abis/aave/AavePoolV3Upgraded'
+import { AaveV3ProtocolDataProviderAbi } from '../abis/aave/AaveV3ProtocolDataProvider'
+
+// init
+import { InitLensAbi } from '../abis/init/InitLens'
+
+// compound v3
+import { CometAbi } from '../abis/compound-v3/Comet'
+import { CometExtAbi } from '../abis/compound-v3/CometExt'
+import { IrgetterAbi } from '../abis/compound-v3/IrGetter'
+
+import { isAaveV2Type, isAaveV3Original, isAaveV3Type, isCompoundV3, isInit } from '../utils'
+import { AdditionalYields, MulticallRetryFunction } from '../types'
+import { buildAaveV2StyleLenderReserveCall } from './aave-v2-type/publicCallBuild'
+import { buildAaveV3StyleLenderReserveCall } from './aave-v3-type/publicCallBuild'
+import { buildInitStyleLenderReserveCall } from './init/publicCallBuild'
+import { buildCompoundV3StyleLenderReserveCall } from './compound-v3/publicCallBuild'
+import { getAaveV2ReservesDataConverter } from './aave-v2-type/publicCallParse'
+import { getAaveV3ReservesDataConverter } from './aave-v3-type/publicCallParse'
+import { getInitReservesDataConverter } from './init/publicCallParse'
+import { getCompoundV3ReservesDataConverter } from './compound-v3/publicCallParse'
+import { AavePoolLegacyAbi } from '../abis/aave-v3/AavePoolLegacy'
+import { AavePoolDataProviderLegacyAbi } from '../abis/aave-v3/AavePoolDataProviderLegacy'
+import { Lender } from '@1delta/asset-registry'
+import { Call } from 'viem'
+import { YLDRProtocolDataProviderAbi } from '../abis/aave-v2/YLDR'
+
+function buildLenderCall(chainId: string, lender: Lender) {
+  if (isAaveV2Type(lender)) return buildAaveV2StyleLenderReserveCall(chainId, lender)
+  if (isAaveV3Type(lender)) return buildAaveV3StyleLenderReserveCall(chainId, lender)
+  if (isInit(lender)) return buildInitStyleLenderReserveCall(chainId, lender)
+  return buildCompoundV3StyleLenderReserveCall(chainId, lender)
+}
+
+function getLenderDataConverter(
+  lender: Lender,
+  chainId: string,
+  prices: { [a: string]: number },
+  additionalYields: AdditionalYields
+) {
+  if (isAaveV2Type(lender)) return getAaveV2ReservesDataConverter(lender, chainId, prices, additionalYields)
+  if (isAaveV3Type(lender)) return getAaveV3ReservesDataConverter(lender, chainId, prices, additionalYields)
+  if (isInit(lender)) return getInitReservesDataConverter(lender, chainId, prices, additionalYields)
+  return getCompoundV3ReservesDataConverter(lender, chainId, prices, additionalYields)
+}
+
+const getAbi = (lender: string) => {
+  if (isAaveV2Type(lender)) return [
+    ...ProtocolDataProviderAbi,
+    ...UniswapV2PairAbi,
+    ...RewarderAbi,
+    ...IncentivesControllerAbi
+  ]
+
+  if (isAaveV3Original(lender)) return [
+    ...AavePoolV3UpgradedAbi,
+    ...AaveV3ProtocolDataProviderAbi
+  ]
+  if (lender === Lender.YLDR) return [
+    ...YLDRProtocolDataProviderAbi,
+  ]
+
+  if (isAaveV3Type(lender)) return [
+    ...AavePoolLegacyAbi,
+    ...AavePoolDataProviderLegacyAbi
+  ]
+
+
+  if (isCompoundV3(lender)) return [
+    ...IrgetterAbi,
+    ...CometAbi,
+    ...CometExtAbi
+  ]
+
+  if (isInit(lender))
+    return InitLensAbi
+
+  return []
+}
+
+export const getLenderPublicData = async (
+  chainId: string,
+  lenders: Lender[],
+  prices: { [asset: string]: number },
+  additionalYields: AdditionalYields,
+  multicallRetry: MulticallRetryFunction
+): Promise<{ [lender: string]: any }> => {
+  let calls: {
+    call: Call
+    abi: any
+  }[] = []
+
+  for (const lender of lenders) {
+    const abi = getAbi(lender)
+    const callData = buildLenderCall(chainId, lender)
+    const mappedCalls = callData.map((call) => ({ call, abi }))
+    // @ts-ignore
+    calls = [...calls, ...mappedCalls]
+  }
+
+  const rawResults = await multicallRetry(
+    chainId,
+    calls.map((call) => call.call) as any[],
+    calls.map((call) => call.abi),
+    // default size
+    // retries = 3
+    // provider = 0
+    // allowFailure = false
+  )
+
+  const invalidLenders: string[] = []
+  const lenderData: { [lender: string]: any } = {}
+
+  let currentSlice = 0
+  for (const lender of lenders) {
+    const [converter, sliceLength] = getLenderDataConverter(lender, chainId, prices, additionalYields)
+
+    const data = rawResults.slice(currentSlice, currentSlice + sliceLength)
+    const convertedData = converter(data)
+    if (!convertedData) {
+      invalidLenders.push(lender)
+    } else {
+      lenderData[lender] = convertedData
+    }
+
+    currentSlice += sliceLength
+  }
+
+  return lenderData
+}

package/src/lending/index.ts

@@ -0,0 +1,2 @@
+export * from "./fetchLender"
+export * from "./user-data"

package/src/lending/init/publicCallBuild.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,90 @@
+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";
+
+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
+): [(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 = getAssetMeta(chainId, 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,
+                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

@@ -0,0 +1,50 @@
+import { RewardsMap } from "../aave-v3-type/types"
+
+
+export interface InitGeneralPublicResponse {
+  data: {
+    [tokenSymbol: string]: {
+      // 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,
+}