@1delta/margin-fetcher 0.0.1

package/src/lending/user-data/compound-v3/addresses.ts

@@ -0,0 +1,40 @@
+import { Chain, COMETS_PER_CHAIN_MAP, COMPOUND_BASE_TOKENS, Lender, SWAYLEND_BASE_TOKENS } from "@1delta/asset-registry"
+
+export function getCompoundV3CometAddress(chainId: string, lender = Lender.COMPOUND_V3_USDC_E): string | undefined {
+    return COMETS_PER_CHAIN_MAP[chainId]?.[lender]
+  }
+  
+  export function getCompoundV3CometRewardsAddress(chainId: string) {
+    return addressesCompoundV3.cometRewards[chainId as keyof typeof addressesCompoundV3.cometRewards]
+  }
+  
+  export function getCompoundV3CometIRGetterAddress(chainId: string) {
+    return addressesCompoundV3.lens[chainId as keyof typeof addressesCompoundV3.lens]
+  }
+  
+  export function getCompoundV3CometLens(chainId: string) {
+    return addressesCompoundV3.lens[chainId as keyof typeof addressesCompoundV3.lens]
+  }
+  
+  const addressesCompoundV3 = {
+    lens: {
+      [Chain.POLYGON_MAINNET]: '0x4eDA401658c5286d16c4d342884F32280B4E8b1b',
+      [Chain.MANTLE]: '0x32B31A066c8dd3F7b77283Ba1d89Ddaf6DA0a8aE',
+      [Chain.ARBITRUM_ONE]: '0x13D9c35f4901491Ac4FFebd3100238BBfFBD7181',
+      [Chain.BASE]: "0x7e2D250E4FD0EeD6BD2cB3DC525A2b9f12508152",
+      [Chain.OP_MAINNET]: "0xA453ba397c61B0c292EA3959A858821145B2707F",
+    },
+    cometRewards: {
+      [Chain.POLYGON_MAINNET]: "0x45939657d1CA34A8FA39A924B71D28Fe8431e581",
+      [Chain.MANTLE]: "0xCd83CbBFCE149d141A5171C3D6a0F0fCCeE225Ab",
+      [Chain.ARBITRUM_ONE]: '0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae',
+      [Chain.BASE]: "0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1",
+      [Chain.OP_MAINNET]: "0x443EA0340cb75a160F31A440722dec7b5bc3C2E9",
+    }
+  }
+  
+  export function getCompoundV3BaseAsset(lender: Lender | string, chainId: string) {
+    return COMPOUND_BASE_TOKENS[lender]?.[chainId] ?? SWAYLEND_BASE_TOKENS[lender]?.[chainId]
+  }
+  
+  

package/src/lending/user-data/compound-v3/index.ts

@@ -0,0 +1,3 @@
+export * from "./userCallBuild"
+export * from "./userCallParse"
+export * from "./addresses"

package/src/lending/user-data/compound-v3/userCallBuild.ts

@@ -0,0 +1,53 @@
+import { Lender } from "@1delta/asset-registry"
+import { Call } from "../../../utils/multicall"
+import { getComposerAddress, getLenderAssets } from "../../../utils"
+import { getCompoundV3BaseAsset, getCompoundV3CometAddress, getCompoundV3CometRewardsAddress } from "./addresses"
+
+export const buildCompoundV3UserCall = (chainId: string, lender: Lender, account: string): Call[] => {
+
+  const baseAsset = getCompoundV3BaseAsset(lender, chainId).baseAsset
+  const cometContractAddress = getCompoundV3CometAddress(chainId, lender)!
+  const assets = getLenderAssets(chainId, lender)
+  const assetsNoBase = assets.filter(a => a !== baseAsset)
+
+  const allowedCall = {
+    address: cometContractAddress,
+    name: 'isAllowed',
+    params: [account, getComposerAddress(chainId)],
+  }
+
+  const baseCalls = [
+    {
+      address: cometContractAddress,
+      name: 'balanceOf',
+      params: [account],
+    },
+    {
+      address: cometContractAddress,
+      name: 'borrowBalanceOf',
+      params: [account],
+    }
+  ]
+
+  const callsNonBase: Call[] = assetsNoBase.map((tk) => {
+    return {
+      address: cometContractAddress,
+      name: 'userCollateral',
+      params: [account, tk],
+    }
+  })
+
+  const callEarnedBalances = {
+    address: getCompoundV3CometRewardsAddress(chainId),
+    name: 'getRewardOwed',
+    params: [cometContractAddress, account],
+  }
+  const calls = [
+    ...callsNonBase,
+    ...baseCalls,
+    allowedCall,
+    callEarnedBalances
+  ]
+  return calls
+
+}

package/src/lending/user-data/compound-v3/userCallParse.ts

@@ -0,0 +1,123 @@
+import { Lender } from "@1delta/asset-registry"
+import { formatUnits } from "viem"
+import { CompoundV3UserReserveResponse, UserLendingPosition, UserRewardEntry } from "../types"
+import { getAssetMeta, getCompoundV3Assets, toOracleKey } from "../../../assets"
+import { getCompoundV3BaseAsset } from "./addresses"
+import { parseRawAmount } from "../../../utils/parsing"
+import { Asset as SupportedAssets } from "@1delta/asset-registry"
+import { createBaseTypeUserState } from "../utils"
+
+export const getCompoundV3UserDataConverter = (
+  lender: Lender,
+  chainId: string,
+  account: string,
+  prices: { [asset: string]: number },
+  pricesHist: { [asset: string]: number },
+  lenderData: any
+): [(data: any[]) => CompoundV3UserReserveResponse | undefined, number] => {
+
+  const assetAddresses = getCompoundV3Assets(chainId, lender)
+  const baseAsset = getCompoundV3BaseAsset(lender, chainId).baseAsset
+  const assetsNoBase = assetAddresses.filter(a => a !== baseAsset)
+  const expectedNumberOfCalls = assetsNoBase.length + 2 + 1 + 1
+  return [
+    (data: any[]) => {
+      if (data.length !== expectedNumberOfCalls) {
+        return undefined
+      }
+
+      const isAllowed = Boolean(data[expectedNumberOfCalls - 2])
+
+      let totalDebt24h = 0
+      let totalDeposits24h = 0
+
+      let result: { [asset: string]: any } = {}
+      for (let i = 0; i < assetsNoBase.length; i++) {
+        const asset = assetsNoBase[i]
+        const assetMeta = getAssetMeta(chainId, asset)
+        const decimals = assetMeta?.decimals ?? 18
+        const depositsRaw = data[i][0]?.toString()
+        const deposits = parseRawAmount(depositsRaw, decimals)
+        const price = prices[toOracleKey(assetMeta.assetGroup)] ?? 1
+
+        const priceHist = pricesHist?.[toOracleKey(assetMeta.assetGroup)] ?? price
+
+        // accure
+        totalDeposits24h += Number(deposits) * priceHist
+
+        result[asset] = {
+          poolId: asset,
+          underlying: asset,
+          deposits,
+          depositsUSD: Number(deposits) * price,
+          debtStableUSD: 0,
+          debt: 0,
+          debtUSD: 0,
+          collateralActive: true,
+          // user depos raw
+          depositsRaw,
+          // flag for allowance
+          isAllowed,
+        }
+      }
+
+      const depositsRaw = data[assetsNoBase.length]?.toString()
+      const debtRaw = data[assetsNoBase.length + 1]?.toString()
+      const baseMeta = getAssetMeta(chainId, baseAsset)
+      const baseDecimals = baseMeta.decimals ?? 18
+      const deposits = parseRawAmount(depositsRaw, baseDecimals)
+      const debt = parseRawAmount(debtRaw, baseDecimals)
+      const priceBase = prices[toOracleKey(baseMeta.assetGroup)]
+      const priceBaseHist = pricesHist?.[toOracleKey(baseMeta.assetGroup)] ?? priceBase
+
+      // accrue base data
+      totalDebt24h += Number(debt) * priceBaseHist
+      totalDeposits24h += Number(deposits) * priceBaseHist
+
+      const resultBase = {
+        [baseAsset]: {
+          poolId: baseAsset,
+          underlying: baseAsset,
+          deposits,
+          debt,
+          depositsUSD: Number(deposits) * priceBase,
+          debtUSD: Number(debt) * priceBase,
+          // populate values for totals
+          debtStable: 0,
+          debtStableUSD: 0,
+          collateralActive: true,
+          // user depos raw
+          depositsRaw,
+          // flag for allowance
+          isAllowed,
+        },
+      }
+
+
+      // the result is an array: [tokenAddress, owedAmount] (tokenAddress should be always COMP)
+      // so we take [1] to get the owedAmount
+      const earnedBalances = data[expectedNumberOfCalls - 1]
+
+      const compRewards = Number(parseRawAmount(earnedBalances?.owed?.toString(), 18))
+      const payload = {
+        lendingPositions: { [0]: { ...result, ...resultBase } },
+        chainId,
+        baseAsset,
+        rewards: {
+          [SupportedAssets.COMP]: {
+            totalRewards: compRewards,
+            claimableRewards: compRewards
+          }
+        },
+        account
+      }
+
+      const userData = createBaseTypeUserState(payload, lenderData, totalDeposits24h, totalDebt24h)
+      return {
+        ...payload,
+        ...userData
+      }
+    },
+    expectedNumberOfCalls,
+  ]
+} 

package/src/lending/user-data/fetchUserData.ts

@@ -0,0 +1,121 @@
+import { Call, multicallViemAbiArray } from "../../utils/multicall"
+import { Lender } from "@1delta/asset-registry"
+import { isAaveV2Type, isAaveV3Type, isInit } from "../../utils"
+import { LenderUserQuery } from "./types"
+import { GetEvmClientFunction } from "../../types"
+import { buildAaveV2UserCall } from "./aave-v2-type/userCallBuild"
+import { buildAaveV3UserCall } from "./aave-v3-type/userCallBuild"
+import { buildInitUserCall } from "./init/userCallBuild"
+import { buildCompoundV3UserCall } from "./compound-v3/userCallBuild"
+import { getAbi } from "./abis"
+import { getAaveV2UserDataConverter } from "./aave-v2-type/userCallParse"
+import { getAaveV3UserDataConverter } from "./aave-v3-type/userCallParse"
+import { getInitUserDataConverter } from "./init/userCallParse"
+import { getCompoundV3UserDataConverter } from "./compound-v3/userCallParse"
+
+function buildUserCall(
+  chainId: string,
+  lender: Lender,
+  account: string
+) {
+  if (isAaveV2Type(lender)) return buildAaveV2UserCall(chainId, lender, account)
+  if (isAaveV3Type(lender)) return buildAaveV3UserCall(chainId, lender, account)
+  if (isInit(lender)) return buildInitUserCall(chainId, lender, account)
+  return buildCompoundV3UserCall(chainId, lender, account)
+}
+
+function getUserDataConverter(
+  lender: Lender,
+  chainId: string,
+  account: string,
+  prices: { [a: string]: number },
+  pricesHist: { [a: string]: number },
+  lenderPublicState: any
+) {
+  if (isAaveV2Type(lender)) return getAaveV2UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+  if (isAaveV3Type(lender)) return getAaveV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+  if (lender === Lender.INIT) return getInitUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+  return getCompoundV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+}
+
+/**
+ * Builds the multicall calls for the given queries and returns the raw results
+ * @param chainId - The chain ID
+ * @param queries - The queries to fetch data for
+ * @param getEvmClient - Injected function to get EVM client
+ * @returns The raw results from the multicall
+ */
+export const getLenderUserDataResult = async (
+  chainId: string,
+  queries: LenderUserQuery[],
+  getEvmClient: GetEvmClientFunction
+): Promise<any[]> => {
+  let calls: {
+    call: Call
+    abi: any
+  }[] = []
+
+  for (const query of queries) {
+    const abi = getAbi(query.lender)
+    const callData = buildUserCall(chainId, query.lender, query.account)
+    const mappedCalls = callData.map((call) => ({ call, abi }))
+    calls = [...calls, ...mappedCalls]
+  }
+
+  return await multicallViemAbiArray(
+    chainId,
+    calls.map((call) => call.abi),
+    calls.map((call) => call.call),
+    getEvmClient,
+    true,
+    0,
+    3
+  )
+}
+
+/**
+ * Converts the raw results into the desired format
+ * @param chainId - The chain ID
+ * @param queries - The queries to fetch data for
+ * @param rawResults - The raw results from the multicall (getLenderUserDataResult)
+ * @param prices - The prices for the assets
+ * @param pricesHist - The historical prices for the assets
+ * @param lenderState - The state of the lender
+ * @returns The converted data
+ */
+export const convertLenderUserDataResult = (
+  chainId: string,
+  queries: LenderUserQuery[],
+  rawResults: any[],
+  prices: any,
+  pricesHist: any,
+  lenderState: any
+): { [lender: string]: any } => {
+
+  const lenderData: { [lender: string]: any } = {}
+  let currentSlice = 0
+  for (const query of queries) {
+    const [converter, sliceLength] = getUserDataConverter(
+      query.lender,
+      chainId,
+      query.account,
+      prices,
+      pricesHist,
+      lenderState[query.lender]?.[chainId]?.lenderData
+    )
+
+    try {
+      const data = rawResults.slice(currentSlice, currentSlice + sliceLength)
+      const convertedData = converter(data)
+
+      if (convertedData) {
+        lenderData[query.lender] = convertedData
+      }
+    } catch (e) {
+      console.log("Error parsing for", query.lender, "on", chainId, e)
+    }
+    currentSlice += sliceLength
+  }
+
+  return lenderData
+} 

package/src/lending/user-data/index.ts

@@ -0,0 +1,2 @@
+export * from "./fetchUserData"
+export * from "./types" 

package/src/lending/user-data/init/userCallBuild.ts

@@ -0,0 +1,26 @@
+import { Chain, Lender } from "@1delta/asset-registry"
+import { Call } from "../../../utils/multicall"
+import { getInitLensAddress } from "../../addresses/init"
+
+export const initBrokerAddresses = {
+  [Chain.MANTLE]: '0xc08BFef7E778f3519D79E96780b77066F5d4FCC0'
+}
+
+export function getInitFlashAggregatorAddress(chainId?: string) {
+  if (!chainId) return undefined
+  return initBrokerAddresses[chainId as keyof typeof initBrokerAddresses]
+}
+
+export const buildInitUserCall = (chainId: string, lender: Lender, account: string): Call[] => {
+  const lensContract = getInitLensAddress(chainId)
+  const brokerAddress = getInitFlashAggregatorAddress(chainId)
+
+  const call: Call = {
+    address: lensContract,
+    name: 'getUserPositionData',
+    params: [account, brokerAddress],
+  }
+
+  return [call]
+
+}

package/src/lending/user-data/init/userCallParse.ts

@@ -0,0 +1,115 @@
+import { Lender } from "@1delta/asset-registry"
+import { formatUnits } from "viem"
+import { InitUserReserveResponse, UserLendingPosition, UserRewardEntry } from "../types"
+import { getInitFlashAggregatorAddress } from "./userCallBuild"
+import { InitGetUserPositionDataIndexes } from "../../init/types"
+import { getLenderAssets } from "../../../utils"
+import { getAssetMeta, toOracleKey } from "../../../assets"
+import { parseRawAmount } from "../../../utils/parsing"
+import { createMultiAccountTypeUserState } from "../utils/createMultiAccountStyleUserState"
+
+export const getInitUserDataConverter = (
+  lender: Lender,
+  chainId: string,
+  account: string,
+  prices: { [asset: string]: number },
+  pricesHist: { [asset: string]: number },
+  lenderData: any
+): [(data: any[]) => InitUserReserveResponse | undefined, number] => {
+  const validOwner = account.toLowerCase()
+  const brokerAddress = getInitFlashAggregatorAddress(chainId) ?? ''
+  const expectedNumberOfCalls = 1
+  return [
+    (_data: any[]) => {
+      if (_data.length !== expectedNumberOfCalls) {
+        return undefined
+      }
+      const [data] = _data
+      // filter for owner
+      const indexes = data[InitGetUserPositionDataIndexes.posMeta].map(
+        (e: any, i: any) => { return { e, i } }
+      ).filter((a: { e: { owner: string } }) => a.e.owner.toLowerCase() === validOwner).map((a: { i: any }) => a.i)
+      const assets = getLenderAssets(chainId, Lender.INIT)
+
+      let histData: { [id: string]: { totalDebt24h: number; totalDeposits24h: number } } = {}
+
+      // map data
+      const result: any = Object.assign(
+        {},
+        ...indexes.map((index: string | number) => {
+          const entry = data[InitGetUserPositionDataIndexes.posMeta][index]
+          const mode = entry.mode
+          const id = entry.posId.toString()
+          const collatData = Object.assign({}, ...data[InitGetUserPositionDataIndexes.collaterals][index].map((c: { underlying: string; amount: { toString: () => any } }) => {
+            const asset = c.underlying.toLowerCase()
+            const decimals = getAssetMeta(chainId, asset)?.decimals ?? 18
+            const depositsRaw = c.amount.toString()
+            return { [asset]: { deposits: parseRawAmount(depositsRaw, decimals), depositsRaw } }
+          })
+          )
+          const debtData = Object.assign({}, ...data[InitGetUserPositionDataIndexes.debts][index].map((c: { underlying: string; amount: { toString: () => string | undefined } }) => {
+            const asset = c.underlying.toLowerCase()
+            const decimals = getAssetMeta(chainId, asset)?.decimals ?? 18
+            return { [asset]: { debt: parseRawAmount(c.amount.toString(), decimals) } }
+          })
+          )
+
+          return {
+            [id]: {
+              mode,
+              ...Object.assign({}, ...assets.map(a => {
+                const ams = toOracleKey(getAssetMeta(chainId, a)?.assetGroup!)
+                const price = prices[ams] ?? 1
+                const priceHist = pricesHist?.[ams] ?? price
+                if (!histData[id]) histData[id] = {
+                  totalDebt24h: 0,
+                  totalDeposits24h: 0,
+                }
+                const debt = debtData[a]?.debt ?? 0
+                const deposits = collatData[a]?.deposits ?? 0
+                const depositsRaw = collatData[a]?.depositsRaw ?? "0"
+
+                histData[id].totalDebt24h += Number(debt) * priceHist
+                histData[id].totalDeposits24h += Number(deposits) * priceHist
+
+                return {
+                  [a]: {
+                    poolId: a,
+                    underlying: a,
+                    deposits: deposits,
+                    depositsRaw,
+                    debt: debt,
+                    debtStable: 0,
+                    debtStableUSD: 0,
+                    depositsUSD: price * Number(deposits),
+                    debtUSD: price * Number(debt),
+                    collateralActive: true,
+                    isAllowed: entry.approved.toLowerCase() === brokerAddress.toLowerCase(),
+                  }
+                }
+              })
+              )
+            }
+          }
+        })
+      )
+
+      const payload = {
+        chainId,
+        lendingPositions: result,
+        account
+      }
+
+      const userState = createMultiAccountTypeUserState(
+        { ...payload, assets },
+        lenderData,
+        histData
+      )
+      return {
+        ...payload,
+        ...userState
+      } as any
+    },
+    expectedNumberOfCalls,
+  ]
+}