@defisaver/positions-sdk 0.0.186 → 0.0.188-dev-markets

package/src/helpers/morphoBlueHelpers/index.ts

@@ -1,15 +1,18 @@
 import Dec from 'decimal.js';
-import { assetAmountInWei } from '@defisaver/tokens';
+import { assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
 import Web3 from 'web3';
 import { calcLeverageLiqPrice, getAssetsTotal, isLeveragedPos } from '../../moneymarket';
 import { calculateNetApy } from '../../staking';
 import { MMAssetsData, MMUsedAssets, NetworkNumber } from '../../types/common';
 import {
   MorphoBlueAggregatedPositionData, MorphoBlueAssetsData, MorphoBlueMarketData, MorphoBlueMarketInfo,
+  MorphoBluePublicAllocatorItem,
+  MorphoBlueRealloactionMarketData,
 } from '../../types';
 import { borrowOperations, SECONDS_PER_YEAR, WAD } from '../../constants';
 import { MorphoBlueViewContract } from '../../contracts';
 import { MarketParamsStruct } from '../../types/contracts/generated/MorphoBlueView';
+import { compareAddresses } from '../../services/utils';
 
 export const getMorphoBlueAggregatedPositionData = ({ usedAssets, assetsData, marketInfo }: { usedAssets: MMUsedAssets, assetsData: MorphoBlueAssetsData, marketInfo: MorphoBlueMarketInfo }): MorphoBlueAggregatedPositionData => {
   const payload = {} as MorphoBlueAggregatedPositionData;
@@ -89,28 +92,234 @@ export const getBorrowRate = (borrowRate: string, totalBorrowShares: string) =>
   return new Dec(compound(borrowRate)).div(1e18).mul(100).toString();
 };
 
-export const getApyAfterValuesEstimation = async (selectedMarket: MorphoBlueMarketData, action: string, amount: string, asset: string, web3: Web3, network: NetworkNumber) => {
+export const getApyAfterValuesEstimation = async (selectedMarket: MorphoBlueMarketData, actions: { action: string, amount: string, asset: string }[], web3: Web3, network: NetworkNumber) => {
   const morphoBlueViewContract = MorphoBlueViewContract(web3, network);
   const lltvInWei = assetAmountInWei(selectedMarket.lltv, 'ETH');
   const marketData: MarketParamsStruct = [selectedMarket.loanToken, selectedMarket.collateralToken, selectedMarket.oracle, selectedMarket.irm, lltvInWei];
-  const isBorrowOperation = borrowOperations.includes(action);
-  const amountInWei = assetAmountInWei(amount, asset);
-  let liquidityAdded;
-  let liquidityRemoved;
-  if (isBorrowOperation) {
-    liquidityAdded = action === 'payback' ? amountInWei : '0';
-    liquidityRemoved = action === 'borrow' ? amountInWei : '0';
-  } else {
-    liquidityAdded = action === 'collateral' ? amountInWei : '0';
-    liquidityRemoved = action === 'withdraw' ? amountInWei : '0';
-  }
-  const data = await morphoBlueViewContract.methods.getApyAfterValuesEstimation([
+
+  const params = actions.map(({ action, asset, amount }) => {
+    const isBorrowOperation = borrowOperations.includes(action);
+    const amountInWei = assetAmountInWei(amount, asset);
+    let liquidityAdded;
+    let liquidityRemoved;
+    if (isBorrowOperation) {
+      liquidityAdded = action === 'payback' ? amountInWei : '0';
+      liquidityRemoved = action === 'borrow' ? amountInWei : '0';
+    } else {
+      liquidityAdded = action === 'collateral' ? amountInWei : '0';
+      liquidityRemoved = action === 'withdraw' ? amountInWei : '0';
+    }
+    return {
+      liquidityAdded,
+      liquidityRemoved,
+      isBorrowOperation,
+    };
+  });
+  const data = await morphoBlueViewContract.methods.getApyAfterValuesEstimation(
     marketData,
-    isBorrowOperation,
-    liquidityAdded,
-    liquidityRemoved,
-  ]).call();
+    params,
+  ).call();
   const borrowRate = getBorrowRate(data.borrowRate, data.market.totalBorrowShares);
   const supplyRate = getSupplyRate(data.market.totalSupplyAssets, data.market.totalBorrowAssets, data.borrowRate, data.market.fee);
   return { borrowRate, supplyRate };
-};
+};
+
+const API_URL = 'https://blue-api.morpho.org/graphql';
+const MARKET_QUERY = `
+  query MarketByUniqueKey($uniqueKey: String!, $chainId: Int!) {
+      marketByUniqueKey(uniqueKey: $uniqueKey, chainId: $chainId) {
+        reallocatableLiquidityAssets
+        targetBorrowUtilization
+        loanAsset {
+          address
+          decimals
+          priceUsd
+        }
+        state {
+          liquidityAssets
+          borrowAssets
+          supplyAssets
+        }
+        publicAllocatorSharedLiquidity {
+          assets
+          vault {
+            address
+            name
+          }
+          allocationMarket {
+            uniqueKey
+            loanAsset {
+              address
+            }
+            collateralAsset {
+              address
+            }
+            irmAddress
+            oracle {
+              address
+            }
+            lltv
+          }
+        }
+        loanAsset {
+          address
+        }
+        collateralAsset {
+          address
+        }
+        oracle {
+          address
+        }
+        irmAddress
+        lltv  
+      }
+    }
+`;
+
+/**
+ * Get reallocatable liquidity to a given market and target borrow utilization
+ * @param marketId - Unique key of the market liquidity is reallocated to
+ * @param network - The network number
+ * @returns The reallocatable liquidity and target borrow utilization
+*/
+export const getReallocatableLiquidity = async (marketId: string, network: NetworkNumber = NetworkNumber.Eth): Promise<{ reallocatableLiquidity: string, targetBorrowUtilization: string }> => {
+  const response = await fetch(API_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      query: MARKET_QUERY,
+      variables: { uniqueKey: marketId, chainId: network },
+    }),
+  });
+
+  const data: { data: { marketByUniqueKey: MorphoBlueRealloactionMarketData } } = await response.json();
+  const marketData: MorphoBlueRealloactionMarketData = data?.data?.marketByUniqueKey;
+
+  if (!marketData) throw new Error('Market data not found');
+
+  return { reallocatableLiquidity: marketData.reallocatableLiquidityAssets, targetBorrowUtilization: marketData.targetBorrowUtilization };
+};
+
+/**
+ * Get liquidity to allocate for a given amount to borrow.
+ * First, the function will try to calculate the amount of liquidity to allocate to be able to
+ * hit the target utilization. If it is not possible to allocate enough liquidity to hit the
+ * target utilization, the function will allocate the amount of liquidity needed to be able to
+ * borrow the selected amount.
+ * @param amountToBorrow - The amount to borrow
+ * @param totalBorrow - The total amount borrowed from market
+ * @param totalSupply - The total amount supplied to market
+ * @param targetBorrowUtilization - The target borrow utilization of market
+ * @param reallocatableLiquidityAssets - The amount of liquidity that can be reallocated from other markets
+ * @returns The amount of liquidity to allocate
+*/
+export const getLiquidityToAllocate = (amountToBorrow: string, totalBorrow: string, totalSupply: string, targetBorrowUtilization: string, reallocatableLiquidityAssets: string) => {
+  const newTotalBorrowAssets = new Dec(totalBorrow).add(amountToBorrow).toString();
+  const leftToBorrow = new Dec(totalSupply).sub(totalBorrow).toString();
+  let liquidityToAllocate = new Dec(newTotalBorrowAssets).div(targetBorrowUtilization).mul(1e18).sub(totalSupply)
+    .toFixed(0)
+    .toString();
+
+  if (new Dec(reallocatableLiquidityAssets).lt(liquidityToAllocate) || new Dec(liquidityToAllocate).lt('0')) {
+    liquidityToAllocate = new Dec(amountToBorrow).lt(leftToBorrow) ? '0' : new Dec(amountToBorrow).sub(leftToBorrow).toString();
+    if (new Dec(reallocatableLiquidityAssets).lt(liquidityToAllocate)) throw new Error('Not enough liquidity available to allocate');
+  }
+
+  return liquidityToAllocate;
+};
+
+/**
+ * Get the vaults and withdrawals needed to reallocate liquidity for a given amount to borrow.
+ * Amount to be reallocated is calculated in `getLiquidityToAllocate`
+ * @param market - The market data
+ * @param assetsData - The assets data
+ * @param amountToBorrow - Amount being borrowed (not the amount being reallocated)
+ * @param network - The network number
+ * @returns The vaults and withdrawals needed to reallocate liquidity
+ */
+export const getReallocation = async (market: MorphoBlueMarketData, assetsData: MorphoBlueAssetsData, amountToBorrow: string, network: NetworkNumber = NetworkNumber.Eth): Promise<{ vaults: string[], withdrawals: (string | string[])[][][] }> => {
+  const { marketId, loanToken } = market;
+  const response = await fetch(API_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      query: MARKET_QUERY,
+      variables: { uniqueKey: marketId, chainId: network },
+    }),
+  });
+
+  const data: { data: { marketByUniqueKey: MorphoBlueRealloactionMarketData } } = await response.json();
+  const marketData: MorphoBlueRealloactionMarketData = data?.data?.marketByUniqueKey;
+
+  if (!marketData) throw new Error('Market data not found');
+
+  const loanAssetInfo = getAssetInfoByAddress(loanToken, network);
+  const { totalBorrow, totalSupply } = assetsData[loanAssetInfo.symbol] || { totalBorrow: '0', totalSupply: '0' };
+  const totalBorrowWei = assetAmountInWei(totalBorrow!, loanAssetInfo.symbol);
+  const totalSupplyWei = assetAmountInWei(totalSupply!, loanAssetInfo.symbol);
+
+  const newTotalBorrowAssets = new Dec(totalBorrowWei).add(amountToBorrow).toString();
+
+  const newUtil = new Dec(newTotalBorrowAssets).div(totalSupplyWei).toString();
+  const newUtilScaled = new Dec(newUtil).mul(1e18).toString();
+
+  if (new Dec(newUtilScaled).lt(marketData.targetBorrowUtilization)) return { vaults: [], withdrawals: [] };
+
+  const liquidityToAllocate = getLiquidityToAllocate(amountToBorrow, totalBorrowWei, totalSupplyWei, marketData.targetBorrowUtilization, marketData.reallocatableLiquidityAssets);
+
+  const vaultTotalAssets = marketData.publicAllocatorSharedLiquidity.reduce(
+    (acc: Record<string, string>, item: MorphoBluePublicAllocatorItem) => {
+      const vaultAddress = item.vault.address;
+      acc[vaultAddress] = new Dec(acc[vaultAddress] || '0').add(item.assets).toString();
+      return acc;
+    },
+    {},
+  );
+
+  const sortedVaults = Object.entries(vaultTotalAssets).sort(
+    ([, a]: [string, string], [, b]: [string, string]) => new Dec(b || '0').sub(a || '0').toNumber(),
+  );
+
+  const withdrawalsPerVault: Record<string, [string[], string, string][]> = {};
+  let totalReallocated = '0';
+  for (const [vaultAddress] of sortedVaults) {
+    if (new Dec(totalReallocated).gte(liquidityToAllocate)) break;
+
+    const vaultAllocations = marketData.publicAllocatorSharedLiquidity.filter(
+      (item: MorphoBluePublicAllocatorItem) => compareAddresses(item.vault.address, vaultAddress),
+    );
+    for (const item of vaultAllocations) {
+      if (new Dec(totalReallocated).gte(liquidityToAllocate)) break;
+      const itemAmount = item.assets;
+      const leftToAllocate = new Dec(liquidityToAllocate).sub(totalReallocated).toString();
+      const amountToTake = new Dec(itemAmount).lt(leftToAllocate) ? itemAmount : leftToAllocate;
+      totalReallocated = new Dec(totalReallocated).add(amountToTake).toString();
+      const withdrawal: [string[], string, string] = [
+        [
+          item.allocationMarket.loanAsset.address,
+          item.allocationMarket.collateralAsset?.address,
+          item.allocationMarket.oracle?.address,
+          item.allocationMarket.irmAddress,
+          item.allocationMarket.lltv,
+        ],
+        amountToTake.toString(),
+        item.allocationMarket.uniqueKey,
+      ];
+      if (!withdrawalsPerVault[vaultAddress]) {
+        withdrawalsPerVault[vaultAddress] = [];
+      }
+      withdrawalsPerVault[vaultAddress].push(withdrawal);
+    }
+  }
+
+  const vaults = Object.keys(withdrawalsPerVault);
+  const withdrawals = vaults.map(
+    (vaultAddress) => withdrawalsPerVault[vaultAddress].sort(
+      (a, b) => a[2].localeCompare(b[2]),
+    ).map(w => [w[0], w[1]]),
+  );
+  return {
+    vaults,
+    withdrawals,
+  };
+};

package/src/markets/compound/index.ts

@@ -6,8 +6,8 @@ import {
   v3ETHCollAssets,
   v3USDbCCollAssets,
   v3USDCCollAssets,
-  v3USDCeCollAssets,
-  v3USDTCollAssets,
+  v3USDCeCollAssets, v3USDSCollAssets,
+  v3USDTCollAssets, v3wstETHCollAssets,
 } from './marketsAssets';
 
 export {
@@ -31,6 +31,8 @@ const BULKER_OPTIONS: Record<NetworkNumber, Record<CompoundVersions, CompoundBul
     [CompoundVersions.CompoundV3USDC]: { supply: 2, withdraw: 5 },
     [CompoundVersions.CompoundV3ETH]: STANDARD_BULKER_OPTIONS,
     [CompoundVersions.CompoundV3USDT]: STANDARD_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3wstETH]: STANDARD_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3USDS]: STANDARD_BULKER_OPTIONS,
 
     // Non-existing markets, keeping it because of typescript
     [CompoundVersions.CompoundV2]: EMPTY_BULKER_OPTIONS,
@@ -46,6 +48,8 @@ const BULKER_OPTIONS: Record<NetworkNumber, Record<CompoundVersions, CompoundBul
     // Non-existing markets, keeping it because of typescript
     [CompoundVersions.CompoundV2]: EMPTY_BULKER_OPTIONS,
     [CompoundVersions.CompoundV3USDbC]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3wstETH]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3USDS]: EMPTY_BULKER_OPTIONS,
   },
   [NetworkNumber.Base]: {
     [CompoundVersions.CompoundV3ETH]: STANDARD_BULKER_OPTIONS,
@@ -56,6 +60,8 @@ const BULKER_OPTIONS: Record<NetworkNumber, Record<CompoundVersions, CompoundBul
     [CompoundVersions.CompoundV2]: EMPTY_BULKER_OPTIONS,
     [CompoundVersions.CompoundV3USDCe]: EMPTY_BULKER_OPTIONS,
     [CompoundVersions.CompoundV3USDT]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3wstETH]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3USDS]: EMPTY_BULKER_OPTIONS,
   },
   [NetworkNumber.Opt]: {
     [CompoundVersions.CompoundV3USDC]: STANDARD_BULKER_OPTIONS,
@@ -65,6 +71,8 @@ const BULKER_OPTIONS: Record<NetworkNumber, Record<CompoundVersions, CompoundBul
     [CompoundVersions.CompoundV3USDbC]: EMPTY_BULKER_OPTIONS,
     [CompoundVersions.CompoundV2]: EMPTY_BULKER_OPTIONS,
     [CompoundVersions.CompoundV3USDCe]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3wstETH]: EMPTY_BULKER_OPTIONS,
+    [CompoundVersions.CompoundV3USDS]: EMPTY_BULKER_OPTIONS,
   },
 };
 
@@ -164,6 +172,36 @@ export const COMPOUND_V3_USDT = (networkId: NetworkNumber): CompoundMarketData =
   // icon: SvgAdapter(protocolIcons.compoundv3),
 });
 
+export const COMPOUND_V3_WSTETH = (networkId: NetworkNumber): CompoundMarketData => ({
+  chainIds: [NetworkNumber.Eth],
+  label: 'Compound V3 - wstETH',
+  shortLabel: 'v3',
+  value: CompoundVersions.CompoundV3wstETH,
+  baseAsset: 'wstETH',
+  collAssets: networkId ? v3wstETHCollAssets[networkId] : [],
+  baseMarket: 'cWstETHv3',
+  baseMarketAddress: getConfigContractAddress('cWstETHv3', networkId),
+  secondLabel: 'Market',
+  bulkerName: networkId === NetworkNumber.Eth ? 'CompV3BulkerMainnetETH' : 'CompV3BulkerL2',
+  bulkerAddress: getConfigContractAddress(networkId === NetworkNumber.Eth ? 'CompV3BulkerMainnetETH' : 'CompV3BulkerL2', networkId),
+  bulkerOptions: BULKER_OPTIONS[networkId][CompoundVersions.CompoundV3wstETH],
+});
+
+export const COMPOUND_V3_USDS = (networkId: NetworkNumber): CompoundMarketData => ({
+  chainIds: [NetworkNumber.Eth],
+  label: 'Compound V3 - USDS',
+  shortLabel: 'v3',
+  value: CompoundVersions.CompoundV3USDS,
+  baseAsset: 'USDS',
+  collAssets: networkId ? v3USDSCollAssets[networkId] : [],
+  baseMarket: 'cUSDSv3',
+  baseMarketAddress: getConfigContractAddress('cUSDSv3', networkId),
+  secondLabel: 'Market',
+  bulkerName: networkId === NetworkNumber.Eth ? 'CompV3BulkerMainnetETH' : 'CompV3BulkerL2',
+  bulkerAddress: getConfigContractAddress(networkId === NetworkNumber.Eth ? 'CompV3BulkerMainnetETH' : 'CompV3BulkerL2', networkId),
+  bulkerOptions: BULKER_OPTIONS[networkId][CompoundVersions.CompoundV3USDS],
+});
+
 export const CompoundMarkets = (networkId: NetworkNumber) => ({
   [CompoundVersions.CompoundV2]: COMPOUND_V2,
   [CompoundVersions.CompoundV3ETH]: COMPOUND_V3_ETH(networkId),
@@ -171,4 +209,6 @@ export const CompoundMarkets = (networkId: NetworkNumber) => ({
   [CompoundVersions.CompoundV3USDbC]: COMPOUND_V3_USDBC(networkId),
   [CompoundVersions.CompoundV3USDCe]: COMPOUND_V3_USDCe(networkId),
   [CompoundVersions.CompoundV3USDT]: COMPOUND_V3_USDT(networkId),
+  [CompoundVersions.CompoundV3wstETH]: COMPOUND_V3_WSTETH(networkId),
+  [CompoundVersions.CompoundV3USDS]: COMPOUND_V3_USDS(networkId),
 }) as const;

package/src/markets/compound/marketsAssets.ts

@@ -7,7 +7,7 @@ export const compoundV2CollateralAssets = [
 ].map((symbol) => getAssetInfo(symbol));
 
 export const v3USDCCollAssetsEth = ['COMP', 'WBTC', 'ETH', 'UNI', 'LINK', 'wstETH', 'cbBTC', 'tBTC'];
-export const v3USDCCollAssetsArb = ['ARB', 'ETH', 'GMX', 'WBTC', 'wstETH', 'ezETH'];
+export const v3USDCCollAssetsArb = ['ARB', 'ETH', 'GMX', 'WBTC', 'wstETH', 'ezETH', 'wUSDM'];
 export const v3USDCCollAssetsBase = ['ETH', 'cbETH', 'wstETH', 'cbBTC'];
 export const v3USDCCollAssetsOpt = ['ETH', 'OP', 'WBTC', 'wstETH'];
 
@@ -52,7 +52,7 @@ export const v3USDbCCollAssets = {
   [NetworkNumber.Base]: v3USDbCCollAssetsBase,
 };
 
-export const v3USDTCollAssetsEth = ['COMP', 'ETH', 'WBTC', 'UNI', 'LINK', 'wstETH', 'cbBTC', 'tBTC', 'wUSDM', 'sFRAX'];
+export const v3USDTCollAssetsEth = ['COMP', 'ETH', 'WBTC', 'UNI', 'LINK', 'wstETH', 'cbBTC', 'tBTC', 'wUSDM', 'sFRAX', 'mETH'];
 export const v3USDTCollAssetsArb = ['ETH', 'WBTC', 'wstETH', 'ARB', 'GMX'];
 export const v3USDTCollAssetsOpt = ['ETH', 'WBTC', 'OP', 'wstETH'];
 
@@ -62,4 +62,22 @@ export const v3USDTCollAssets = {
   [NetworkNumber.Opt]: v3USDTCollAssetsOpt,
   [NetworkNumber.Arb]: v3USDTCollAssetsArb,
   [NetworkNumber.Base]: [],
+};
+
+export const v3USDSCollAssetsEth = ['wstETH', 'ETH', 'sUSDS', 'cbETH', 'tBTC', 'USDe'];
+
+export const v3USDSCollAssets = {
+  [NetworkNumber.Eth]: v3USDSCollAssetsEth,
+  [NetworkNumber.Opt]: [],
+  [NetworkNumber.Arb]: [],
+  [NetworkNumber.Base]: [],
+};
+
+export const v3wstETHCollAssetsEth = ['rsETH', 'ezETH'];
+
+export const v3wstETHCollAssets = {
+  [NetworkNumber.Eth]: v3wstETHCollAssetsEth,
+  [NetworkNumber.Opt]: [],
+  [NetworkNumber.Arb]: [],
+  [NetworkNumber.Base]: [],
 };

package/src/markets/morphoBlue/index.ts

@@ -723,7 +723,7 @@ export const MORPHO_BLUE_CBBTC_USDC_860_BASE = (networkId: NetworkNumber = Netwo
 export const MORPHO_BLUE_WSUPEROETHB_WETH_915_BASE = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
   chainIds: [NetworkNumber.Base],
   label: 'Morpho',
-  shortLabel: 'wsuperOETHb/WETH',
+  shortLabel: 'wsuperOETHb/ETH',
   value: MorphoBlueVersions.MorphoBlueWsuperOETHbWETH_915_Base,
   url: 'wsuperoethbweth-144bf18d',
   loanToken: '0x4200000000000000000000000000000000000006',
@@ -736,6 +736,70 @@ export const MORPHO_BLUE_WSUPEROETHB_WETH_915_BASE = (networkId: NetworkNumber =
   protocolName: 'morpho-blue',
 });
 
+export const MORPHO_BLUE_LBTC_WBTC_945 = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
+  chainIds: [NetworkNumber.Eth],
+  label: 'Morpho',
+  shortLabel: 'LBTC/WBTC',
+  value: MorphoBlueVersions.MorphoBlueLBTCWBTC_945,
+  url: 'lbtcwbtc-f6a05662',
+  loanToken: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
+  collateralToken: '0x8236a87084f8B84306f72007F36F2618A5634494',
+  oracle: '0xa98105B8227E0f2157816Feb7A331364A9B74F80',
+  oracleType: MorphoBlueOracleType.MARKET_RATE,
+  irm: '0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC',
+  lltv: 0.945,
+  marketId: '0xf6a056627a51e511ec7f48332421432ea6971fc148d8f3c451e14ea108026549',
+  protocolName: 'morpho-blue',
+});
+
+export const MORPHO_BLUE_LBTC_CBBTC_945_BASE = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho',
+  shortLabel: 'LBTC/cbBTC',
+  value: MorphoBlueVersions.MorphoBlueLBTCCbBTC_945_Base,
+  url: 'lbtccbbtc-30767836',
+  loanToken: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+  collateralToken: '0xecAc9C5F704e954931349Da37F60E39f515c11c1',
+  oracle: '0x9Ae0E86e88AEE94B700240eBE0BD17D969BAD0EA',
+  oracleType: MorphoBlueOracleType.MARKET_RATE,
+  irm: '0x46415998764C29aB2a25CbeA6254146D50D22687',
+  lltv: 0.945,
+  marketId: '0x30767836635facec1282e6ef4a5981406ed4e72727b3a63a3a72c74e8279a8d7',
+  protocolName: 'morpho-blue',
+});
+
+export const MORPHO_BLUE_WSTETH_EURC_860_BASE = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho',
+  shortLabel: 'wstETH/EURC',
+  value: MorphoBlueVersions.MorphoBlueWstEthEURC_860_Base,
+  url: 'wstetheurc-f7e40290',
+  loanToken: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+  collateralToken: '0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452',
+  oracle: '0xa54122f0E0766258377Ffe732e454A3248f454F4',
+  oracleType: MorphoBlueOracleType.MARKET_RATE,
+  irm: '0x46415998764C29aB2a25CbeA6254146D50D22687',
+  lltv: 0.86,
+  marketId: '0xf7e40290f8ca1d5848b3c129502599aa0f0602eb5f5235218797a34242719561',
+  protocolName: 'morpho-blue',
+});
+
+export const MORPHO_BLUE_CBBTC_EURC_860_BASE = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho',
+  shortLabel: 'cbBTC/EURC',
+  value: MorphoBlueVersions.MorphoBlueCbBTCEURC_860_Base,
+  url: 'cbbtceurc-67ebd84b',
+  loanToken: '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+  collateralToken: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+  oracle: '0xA857411CB2231a6A87a3bEF987a4cED8A067d799',
+  oracleType: MorphoBlueOracleType.MARKET_RATE,
+  irm: '0x46415998764C29aB2a25CbeA6254146D50D22687',
+  lltv: 0.86,
+  marketId: '0x67ebd84b2fb39e3bc5a13d97e4c07abe1ea617e40654826e9abce252e95f049e',
+  protocolName: 'morpho-blue',
+});
+
 export const MorphoBlueMarkets = (networkId: NetworkNumber) => ({
   [MorphoBlueVersions.MorphoBlueWstEthUSDC]: MORPHO_BLUE_WSTETH_USDC(networkId),
   [MorphoBlueVersions.MorphoBlueSDAIUSDC]: MORPHO_BLUE_SDAI_USDC(networkId),
@@ -760,6 +824,7 @@ export const MorphoBlueMarkets = (networkId: NetworkNumber) => ({
   [MorphoBlueVersions.MorphoBlueCbBTCUSDC_860]: MORPHO_BLUE_CBBTC_USDC_860(networkId),
   [MorphoBlueVersions.MorphoBlueREthEth_945]: MORPHO_BLUE_RETH_ETH_945(networkId),
   [MorphoBlueVersions.MorphoBlueSUSDeUSDC_915]: MORPHO_BLUE_SUSDE_USDC_915(networkId),
+  [MorphoBlueVersions.MorphoBlueLBTCWBTC_945]: MORPHO_BLUE_LBTC_WBTC_945(networkId),
 
   // wstETH/WETH
   [MorphoBlueVersions.MorphoBlueWstEthEth_945]: MORPHO_BLUE_WSTETH_ETH_945(networkId),
@@ -786,6 +851,10 @@ export const MorphoBlueMarkets = (networkId: NetworkNumber) => ({
   [MorphoBlueVersions.MorphoBlueREthEth_945_Base]: MORPHO_BLUE_RETH_ETH_945_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbBTCEth_915_Base]: MORPHO_BLUE_CBBTC_ETH_915_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbBTCUSDC_860_Base]: MORPHO_BLUE_CBBTC_USDC_860_BASE(networkId),
+  [MorphoBlueVersions.MorphoBlueCbBTCEURC_860_Base]: MORPHO_BLUE_CBBTC_EURC_860_BASE(networkId),
+  [MorphoBlueVersions.MorphoBlueWstEthEURC_860_Base]: MORPHO_BLUE_WSTETH_EURC_860_BASE(networkId),
+  [MorphoBlueVersions.MorphoBlueLBTCCbBTC_945_Base]: MORPHO_BLUE_LBTC_CBBTC_945_BASE(networkId),
+
 
   // wsuperOETHb/WETH Base
   [MorphoBlueVersions.MorphoBlueWsuperOETHbWETH_915_Base]: MORPHO_BLUE_WSUPEROETHB_WETH_915_BASE(networkId),

package/src/morphoBlue/index.ts

@@ -1,41 +1,58 @@
 import Web3 from 'web3';
 import Dec from 'decimal.js';
-import { assetAmountInEth, getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
 import {
   Blockish, EthAddress, MMUsedAssets, NetworkNumber, PositionBalances,
 } from '../types/common';
-import {
-  FeedRegistryContract,
-  MorphoBlueViewContract,
-} from '../contracts';
+import { DFSFeedRegistryContract, FeedRegistryContract, MorphoBlueViewContract } from '../contracts';
 import {
   MorphoBlueAssetsData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBluePositionData,
 } from '../types';
-import { WAD, USD_QUOTE } from '../constants';
+import { USD_QUOTE, WAD } from '../constants';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
 import { wethToEth } from '../services/utils';
 import { getBorrowRate, getMorphoBlueAggregatedPositionData, getSupplyRate } from '../helpers/morphoBlueHelpers';
+import { getChainlinkAssetAddress } from '../services/priceService';
+
+const isMainnetNetwork = (network: NetworkNumber) => network === NetworkNumber.Eth;
 
 export async function getMorphoBlueMarketData(web3: Web3, network: NetworkNumber, selectedMarket: MorphoBlueMarketData, mainnetWeb3: Web3): Promise<MorphoBlueMarketInfo> {
   const {
     loanToken, collateralToken, oracle, irm, lltv, oracleType,
   } = selectedMarket;
+
   const lltvInWei = new Dec(lltv).mul(WAD).toString();
   const loanTokenInfo = getAssetInfoByAddress(loanToken, network);
   const collateralTokenInfo = getAssetInfoByAddress(collateralToken, network);
-  let loanTokenFeedAddress = loanTokenInfo.addresses[NetworkNumber.Eth];
-  if (loanTokenInfo.symbol === 'WETH') {
-    const ethAddress = getAssetInfo('ETH').address;
-    loanTokenFeedAddress = ethAddress;
-  }
 
-  const feedRegistryContract = FeedRegistryContract(mainnetWeb3, NetworkNumber.Eth);
+  const loanTokenFeedAddress = getChainlinkAssetAddress(loanTokenInfo.symbol, network);
+
   const morphoBlueViewContract = MorphoBlueViewContract(web3, network);
 
-  const [loanTokenPrice, marketInfo] = await Promise.all([
-    loanTokenInfo.symbol === 'USDA' ? '100000000' : feedRegistryContract.methods.latestAnswer(loanTokenFeedAddress, USD_QUOTE).call(),
-    morphoBlueViewContract.methods.getMarketInfoNotTuple(loanToken, collateralToken, oracle, irm, lltvInWei).call(),
-  ]);
+  let marketInfo;
+  let loanTokenPrice;
+  const isTokenUSDA = loanTokenInfo.symbol === 'USDA';
+  const isMainnet = isMainnetNetwork(network);
+  if (isMainnet) {
+    const feedRegistryContract = FeedRegistryContract(mainnetWeb3, NetworkNumber.Eth);
+    const [_loanTokenPrice, _marketInfo] = await Promise.all([
+      isTokenUSDA ? Promise.resolve('100000000') : feedRegistryContract.methods.latestAnswer(loanTokenFeedAddress, USD_QUOTE).call(),
+      morphoBlueViewContract.methods.getMarketInfoNotTuple(loanToken, collateralToken, oracle, irm, lltvInWei).call(),
+    ]);
+    marketInfo = _marketInfo;
+    loanTokenPrice = _loanTokenPrice;
+  } else {
+    // Currently only base network is supported
+    const feedRegistryContract = DFSFeedRegistryContract(web3, network);
+
+    const [loanTokenPriceRound, _marketInfo] = await Promise.all([
+      isTokenUSDA ? Promise.resolve({ answer: '100000000' }) // Normalize to match the expected object structure
+        : feedRegistryContract.methods.latestRoundData(loanTokenFeedAddress, USD_QUOTE).call(),
+      morphoBlueViewContract.methods.getMarketInfoNotTuple(loanToken, collateralToken, oracle, irm, lltvInWei).call(),
+    ]);
+    marketInfo = _marketInfo;
+    loanTokenPrice = loanTokenPriceRound.answer;
+  }
 
   const supplyRate = getSupplyRate(marketInfo.totalSupplyAssets, marketInfo.totalBorrowAssets, marketInfo.borrowRate, marketInfo.fee);
   const compoundedBorrowRate = getBorrowRate(marketInfo.borrowRate, marketInfo.totalBorrowShares);

package/src/services/priceService.ts

@@ -1,7 +1,14 @@
 import Web3 from 'web3';
 import Dec from 'decimal.js';
-import { COMPPriceFeedContract, ETHPriceFeedContract, USDCPriceFeedContract } from '../contracts';
+import { getAssetInfo } from '@defisaver/tokens';
+import {
+  COMPPriceFeedContract,
+  ETHPriceFeedContract,
+  USDCPriceFeedContract,
+  WstETHPriceFeedContract,
+} from '../contracts';
 import { NetworkNumber } from '../types/common';
+import { multicall } from '../multicall';
 
 export const getEthPrice = async (web3: Web3) => {
   const contract = ETHPriceFeedContract(web3, NetworkNumber.Eth);
@@ -19,4 +26,36 @@ export const getCompPrice = async (web3: Web3) => {
   const contract = COMPPriceFeedContract(web3, NetworkNumber.Eth);
   const price = await contract.methods.latestAnswer().call();
   return new Dec(price).div(1e8).toString();
-};
+};
+
+export const getWstETHPrice = async (web3: Web3) => {
+  const wstETHFeedContract = WstETHPriceFeedContract(web3, NetworkNumber.Eth);
+  const ethFeedContract = ETHPriceFeedContract(web3, NetworkNumber.Eth);
+  const calls = [
+    {
+      target: ethFeedContract.options.address,
+      abiItem: ethFeedContract.options.jsonInterface.find(({ name }) => name === 'latestAnswer'),
+      params: [],
+    },
+    {
+      target: wstETHFeedContract.options.address,
+      abiItem: wstETHFeedContract.options.jsonInterface.find(({ name }) => name === 'latestRoundData'),
+      params: [],
+    },
+  ];
+
+  const multicallRes = await multicall(calls, web3);
+
+  const ethPrice = new Dec(multicallRes[0][0]).div(1e8);
+
+  const wstETHRate = new Dec(multicallRes[1].answer).div(1e8);
+
+  return new Dec(ethPrice).mul(wstETHRate).toString();
+};
+
+// chainlink price feed available only on mainnet
+export const getChainlinkAssetAddress = (symbol: string, network: NetworkNumber) => {
+  if (['WBTC', 'RENBTC'].includes(symbol?.toUpperCase())) return '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB';
+  if (symbol?.toUpperCase() === 'WETH') return getAssetInfo('ETH').addresses[network];
+  return getAssetInfo(symbol).addresses[network];
+};

package/src/types/compound.ts

@@ -9,6 +9,8 @@ export enum CompoundVersions {
   'CompoundV3ETH' = 'v3-ETH',
   'CompoundV3USDbC' = 'v3-USDbC',
   'CompoundV3USDT' = 'v3-USDT',
+  'CompoundV3USDS' = 'v3-USDS',
+  'CompoundV3wstETH' = 'v3-wstETH',
 }
 
 export interface CompoundBulkerOptions {