@1delta/margin-fetcher 0.0.10 → 0.0.13

package/src/lending/morpho/fetchPublic.ts

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

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

@@ -0,0 +1,129 @@
+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/user-data/aave-v3-type/userCallBuild.ts

@@ -1,18 +1,14 @@
 import { Lender } from "@1delta/asset-registry"
 import { Call } from "../../../utils/multicall"
-import { getAaveAssets, getAaveStyleProtocolTokenMap, getAaveTypePoolDataProviderAddress, getAaveTypePoolAddress } from "../../../assets"
-import { getComposerAddress, isYLDR } from "../../../utils"
-
-const fallbackDebtToken = '0x52A1CeB68Ee6b7B5D13E0376A1E0E4423A8cE26e'
+import { getAaveAssets, getAaveTypePoolDataProviderAddress, getAaveTypePoolAddress } from "../../../assets"
+import { isYLDR } from "../../../utils"
 
 const getBaseAaveV3Calls = (
   chainId: string,
   account: string,
   lender: Lender,
   assetsToQuery: string[],
-  aaveTokenMap: any
 ) => {
-  const broker = getComposerAddress(chainId)
   return assetsToQuery.flatMap((tk) => [
     {
       address: getAaveTypePoolDataProviderAddress(chainId, lender),
@@ -24,7 +20,6 @@ const getBaseAaveV3Calls = (
 
 export const buildAaveV3UserCall = (chainId: string, lender: Lender, account: string): Call[] => {
   const assetsToQuery = getAaveAssets(chainId, lender)
-  const aaveTokenMap = getAaveStyleProtocolTokenMap(chainId, lender)
 
   const calls = [
     ...getBaseAaveV3Calls(
@@ -32,7 +27,6 @@ export const buildAaveV3UserCall = (chainId: string, lender: Lender, account: st
       account,
       lender,
       assetsToQuery,
-      aaveTokenMap
     ),
   ]
   if (!isYLDR(lender)) {

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

@@ -1,5 +1,5 @@
 import { Lender } from "@1delta/asset-registry"
-import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type, isYLDR } from "../../utils"
+import { isAaveV2Type, isAaveV3Type, isCompoundV3, isInit, isAaveV32Type, isYLDR, isMorphoType } from "../../utils"
 import { IncentivesControllerAbi } from "../../abis/lendle/IncentivesController"
 import { RewarderAbi } from "../../abis/aurelius/Rewarder"
 import { AavePoolV3UpgradedAbi } from "../../abis/aave/AavePoolV3Upgraded"
@@ -15,6 +15,8 @@ import { MultiFeeDistributionAbi } from "../../abis/lendle/MultiFeeDistribution"
 import { PullRewardsIncentivesController } from "../../abis/meridian/PullRewardsIncentivesController"
 import { CometRewardsAbi } from "../../abis/compound-v3/CometRewards"
 import { YLDRAbi } from "../../abis/aave-v3/YLDR"
+import { MorphoBlueAbi } from "../../abis/morpho/blue"
+import { MorphoLensAbi } from "../../abis/morpho/lens"
 
 export const getAbi = (lender: Lender) => {
   if (isAaveV2Type(lender as any)) return [
@@ -45,6 +47,7 @@ export const getAbi = (lender: Lender) => {
     ...CometExtAbi,
     ...CometRewardsAbi,
   ]
+  if(isMorphoType(lender)) return [...MorphoBlueAbi, ...MorphoLensAbi]
   if (isInit(lender as any)) return InitLensAbi
   return []
 }

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

@@ -52,7 +52,8 @@ export const getCompoundV3UserDataConverter = (
           deposits,
           depositsUSD: Number(deposits) * price,
           debtStableUSD: 0,
-          debt: 0,
+          debt: "0",
+          debtStable: "0",
           debtUSD: 0,
           collateralActive: true,
           // user depos raw
@@ -85,7 +86,7 @@ export const getCompoundV3UserDataConverter = (
           depositsUSD: Number(deposits) * priceBase,
           debtUSD: Number(debt) * priceBase,
           // populate values for totals
-          debtStable: 0,
+          debtStable: "0",
           debtStableUSD: 0,
           collateralActive: true,
           // user depos raw

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

@@ -1,27 +1,39 @@
-import { Call, multicallViemAbiArray } from "../../utils/multicall"
-import { Lender } from "@1delta/asset-registry"
-import { isAaveV2Type, isAaveV3Type, isInit, isYLDR } 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"
-import { getYldrUserDataConverter } from "./aave-v3-type/userCallParseYldr"
+import { Call, multicallViemAbiArray } from '../../utils/multicall'
+import { Lender } from '@1delta/asset-registry'
+import {
+  isAaveV2Type,
+  isAaveV3Type,
+  isInit,
+  isMorphoType,
+  isMultiMarket,
+  isYLDR,
+} from '../../utils'
+import { LenderUserQuery, organizeUserQueries } 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'
+import { getYldrUserDataConverter } from './aave-v3-type/userCallParseYldr'
+import { buildMorphoUserCallWithLens } from './morpho/userCallBuild'
+import { getMorphoUserDataConverterWithlens } from './morpho/userCallParse'
 
 function buildUserCall(
   chainId: string,
   lender: Lender,
-  account: string
+  account: string,
+  params?: any,
 ) {
   if (isAaveV2Type(lender)) return buildAaveV2UserCall(chainId, lender, account)
   if (isAaveV3Type(lender)) return buildAaveV3UserCall(chainId, lender, account)
   if (isInit(lender)) return buildInitUserCall(chainId, lender, account)
+  if (isMorphoType(lender))
+    return buildMorphoUserCallWithLens(chainId, account, lender, params)
   return buildCompoundV3UserCall(chainId, lender, account)
 }
 
@@ -31,13 +43,63 @@ function getUserDataConverter(
   account: string,
   prices: { [a: string]: number },
   pricesHist: { [a: string]: number },
-  lenderPublicState: any
+  lenderPublicState: any,
+  params?: any,
 ) {
-  if (isYLDR(lender)) return getYldrUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isAaveV2Type(lender)) return getAaveV2UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isAaveV3Type(lender)) return getAaveV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  if (isInit(lender)) return getInitUserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
-  return getCompoundV3UserDataConverter(lender, chainId, account, prices, pricesHist, lenderPublicState)
+  if (isYLDR(lender))
+    return getYldrUserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isAaveV2Type(lender))
+    return getAaveV2UserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isAaveV3Type(lender))
+    return getAaveV3UserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isInit(lender))
+    return getInitUserDataConverter(
+      lender,
+      chainId,
+      account,
+      prices,
+      pricesHist,
+      lenderPublicState?.data?.[lender]?.data,
+    )
+  if (isMorphoType(lender))
+    return getMorphoUserDataConverterWithlens(
+      lender,
+      chainId,
+      account,
+      params,
+      prices,
+      pricesHist,
+      lenderPublicState?.data,
+    )
+  return getCompoundV3UserDataConverter(
+    lender,
+    chainId,
+    account,
+    prices,
+    pricesHist,
+    lenderPublicState,
+  )
 }
 
 /**
@@ -49,17 +111,23 @@ function getUserDataConverter(
  */
 export const getLenderUserDataResult = async (
   chainId: string,
-  queries: LenderUserQuery[],
-  getEvmClient: GetEvmClientFunction
+  queriesRaw: LenderUserQuery[],
+  getEvmClient: GetEvmClientFunction,
 ): Promise<any[]> => {
   let calls: {
     call: Call
     abi: any
   }[] = []
 
+  const queries = organizeUserQueries(queriesRaw)
   for (const query of queries) {
     const abi = getAbi(query.lender)
-    const callData = buildUserCall(chainId, query.lender, query.account)
+    const callData = buildUserCall(
+      chainId,
+      query.lender,
+      query.account,
+      query.params,
+    )
     const mappedCalls = callData.map((call) => ({ call, abi }))
     calls = [...calls, ...mappedCalls]
   }
@@ -71,7 +139,7 @@ export const getLenderUserDataResult = async (
     getEvmClient,
     true,
     0,
-    3
+    3,
   )
 }
 
@@ -87,12 +155,13 @@ export const getLenderUserDataResult = async (
  */
 export const convertLenderUserDataResult = (
   chainId: string,
-  queries: LenderUserQuery[],
+  queriesRaw: LenderUserQuery[],
   rawResults: any[],
   prices: any,
   pricesHist: any,
-  lenderState: any
+  lenderState: any,
 ): { [lender: string]: any } => {
+  const queries = organizeUserQueries(queriesRaw)
 
   const lenderData: { [lender: string]: any } = {}
   let currentSlice = 0
@@ -103,7 +172,8 @@ export const convertLenderUserDataResult = (
       query.account,
       prices,
       pricesHist,
-      lenderState[chainId]?.data?.[query.lender]?.data
+      lenderState[chainId],
+      query.params,
     )
 
     try {
@@ -111,14 +181,25 @@ export const convertLenderUserDataResult = (
       const convertedData = converter(data)
 
       if (convertedData) {
-        // map it to the user address
-        lenderData[query.lender] = { [query.account.toLowerCase()]: convertedData }
+        if (isMultiMarket(query.lender)) {
+          Object.keys(convertedData).forEach((market) => {
+            lenderData[market] = {
+              // @ts-ignore
+              [query.account.toLowerCase()]: convertedData[market],
+            }
+          })
+        } else {
+          // map it to the user address
+          lenderData[query.lender] = {
+            [query.account.toLowerCase()]: convertedData,
+          }
+        }
       }
     } catch (e) {
-      console.log("Error parsing for", query.lender, "on", chainId, e)
+      console.log('Error parsing for', query.lender, 'on', chainId, e)
     }
     currentSlice += sliceLength
   }
 
   return lenderData
-} 
+}

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

@@ -79,7 +79,7 @@ export const getInitUserDataConverter = (
                     deposits: deposits,
                     depositsRaw,
                     debt: debt,
-                    debtStable: 0,
+                    debtStable: "0",
                     debtStableUSD: 0,
                     depositsUSD: price * Number(deposits),
                     debtUSD: price * Number(debt),

package/src/lending/user-data/morpho/decoder.ts

@@ -0,0 +1,71 @@
+export interface BalanceInfo {
+  index: number;           // uint16 (2 bytes)
+  supplyShares: bigint;    // uint256 (32 bytes)
+  borrowShares: bigint;    // uint128 (16 bytes)
+  supplyAssets: bigint;    // uint256 (32 bytes)
+  borrowAssets: bigint;    // uint256 (32 bytes)
+  collateral: bigint;      // uint128 (16 bytes)
+}
+
+const WORD = 32;
+const HALF = 16;
+
+/** Read `len` bytes at `off` as a big‐endian BigInt. */
+function readBigIntBE(buf: Uint8Array, off: number, len: number): bigint {
+  let v = 0n;
+  for (let i = 0; i < len; i++) {
+    v = (v << 8n) | BigInt(buf[off + i]);
+  }
+  return v;
+}
+
+/**
+ * Decode:
+ *  [ uint256 count (32 bytes) ]
+ *  then for each of `count` records:
+ *    uint16  index (2 bytes),
+ *    uint256 supplyShares (32 bytes),
+ *    uint128 borrowShares (16 bytes),
+ *    uint256 supplyAssets (32 bytes),
+ *    uint256 borrowAssets (32 bytes),
+ *    uint128 collateral   (16 bytes)
+ */
+export function decodePackedDataset(hex: string): BalanceInfo[] {
+  if (hex.startsWith("0x")) hex = hex.slice(2);
+  const buf = Uint8Array.from(hex.match(/.{1,2}/g)!.map((b) => parseInt(b, 16)));
+
+  // 1) count (uint256)
+  const count = Number(readBigIntBE(buf, 0, 2));
+  const out: BalanceInfo[] = [];
+
+  let off = 2;
+  for (let i = 0; i < count; i++) {
+    // 2) index (uint16)
+    const index = Number(readBigIntBE(buf, off, 2)); 
+    off += 2;
+
+    // 3) supplyShares (uint256)
+    const supplyShares = readBigIntBE(buf, off, WORD);
+    off += WORD;
+
+    // 4) borrowShares (uint128)
+    const borrowShares = readBigIntBE(buf, off, HALF);
+    off += HALF;
+
+    // 5) supplyAssets (uint256)
+    const supplyAssets = readBigIntBE(buf, off, WORD);
+    off += WORD;
+
+    // 6) borrowAssets (uint256)
+    const borrowAssets = readBigIntBE(buf, off, WORD);
+    off += WORD;
+
+    // 7) collateral (uint128)
+    const collateral = readBigIntBE(buf, off, HALF);
+    off += HALF;
+
+    out.push({ index, supplyShares, borrowShares, supplyAssets, borrowAssets, collateral });
+  }
+
+  return out;
+}

package/src/lending/user-data/morpho/morphoLib.ts

@@ -0,0 +1,61 @@
+// Constants
+const VIRTUAL_SHARES = 10n ** 6n;
+const VIRTUAL_ASSETS = 1n;
+
+
+function mulDivDown(x: bigint, y: bigint, d: bigint): bigint {
+    return (x * y) / d;
+}
+
+function mulDivUp(x: bigint, y: bigint, d: bigint): bigint {
+    return (x * y + (d - 1n)) / d;
+}
+
+
+export function toSharesDown(
+    assets: bigint,
+    totalAssets: bigint,
+    totalShares: bigint
+): bigint {
+    return mulDivDown(
+        assets,
+        totalShares + VIRTUAL_SHARES,
+        totalAssets + VIRTUAL_ASSETS
+    );
+}
+
+export function toAssetsDown(
+    shares: bigint,
+    totalAssets: bigint,
+    totalShares: bigint
+): bigint {
+    return mulDivDown(
+        shares,
+        totalAssets + VIRTUAL_ASSETS,
+        totalShares + VIRTUAL_SHARES
+    );
+}
+
+export function toSharesUp(
+    assets: bigint,
+    totalAssets: bigint,
+    totalShares: bigint
+): bigint {
+    return mulDivUp(
+        assets,
+        totalShares + VIRTUAL_SHARES,
+        totalAssets + VIRTUAL_ASSETS
+    );
+}
+
+export function toAssetsUp(
+    shares: bigint,
+    totalAssets: bigint,
+    totalShares: bigint
+): bigint {
+    return mulDivUp(
+        shares,
+        totalAssets + VIRTUAL_ASSETS,
+        totalShares + VIRTUAL_SHARES
+    );
+}

package/src/lending/user-data/morpho/types.ts

@@ -0,0 +1,12 @@
+export enum MorphoPositionParams {
+    supplyShares = 0,
+    borrowShares,
+    collateral,
+}
+
+export enum MorphoMarketParams {
+    totalSupplyAssets = 0,
+    totalSupplyShares,
+    totalBorrowAssets,
+    totalBorrowShares,
+}