@defisaver/positions-sdk 2.1.168-stable-pair-dev → 2.1.169-custom-fetching-dev

package/esm/types/morphoBlue.d.ts

@@ -110,6 +110,7 @@ export declare enum MorphoBlueVersions {
     MorphoBlueUSDeUSDC_915_Base = "morphoblueusdeusdc_915_base",// USDe/USDC 0.915
     MorphoBlueCbEthUSDC_770_Base = "morphobluecbethusdc_770_base",// cbETH/USDC 0.77
     MorphoBlueCbXRPUSDC_625_Base = "morphobluecbxrpusdc_625_base",// cbXRP/USDC 0.625
+    MorphoBlueCbHYPEUSDC_625_Base = "morphobluecbhypeusdc_625_base",// cbHYPE/USDC 0.625
     MorphoBlueSyrupUSDCUSDC_915_Arb = "morphobluesyrupusdcusdc_915_arb",// syrupUSDC/USDC
     MorphoBlueWBTCUSDC_860_Arb = "morphobluewbtcusdc_860_arb",// WBTC/USDC
     MorphoBlueWstEthUSDC_860_Arb = "morphobluewstethusdc_860_arb",// wstETH/USDC

package/esm/types/morphoBlue.js

@@ -117,6 +117,7 @@ export var MorphoBlueVersions;
     MorphoBlueVersions["MorphoBlueUSDeUSDC_915_Base"] = "morphoblueusdeusdc_915_base";
     MorphoBlueVersions["MorphoBlueCbEthUSDC_770_Base"] = "morphobluecbethusdc_770_base";
     MorphoBlueVersions["MorphoBlueCbXRPUSDC_625_Base"] = "morphobluecbxrpusdc_625_base";
+    MorphoBlueVersions["MorphoBlueCbHYPEUSDC_625_Base"] = "morphobluecbhypeusdc_625_base";
     // ARBITRUM
     MorphoBlueVersions["MorphoBlueSyrupUSDCUSDC_915_Arb"] = "morphobluesyrupusdcusdc_915_arb";
     MorphoBlueVersions["MorphoBlueWBTCUSDC_860_Arb"] = "morphobluewbtcusdc_860_arb";

package/esm/types/portfolio.d.ts

@@ -60,6 +60,40 @@ export interface PortfolioPositionsDataForAddress {
 export interface PortfolioPositionsData {
     [key: EthAddress]: PortfolioPositionsDataForAddress;
 }
+export declare enum PortfolioProtocol {
+    AaveV2 = "aaveV2",
+    AaveV3 = "aaveV3",
+    AaveV4 = "aaveV4",
+    CompoundV2 = "compoundV2",
+    CompoundV3 = "compoundV3",
+    Spark = "spark",
+    MorphoBlue = "morphoBlue",
+    MorphoMidnight = "morphoMidnight",
+    CrvUsd = "crvUsd",
+    LlamaLend = "llamaLend",
+    Maker = "maker",
+    Liquity = "liquity",
+    LiquityV2 = "liquityV2",
+    Fluid = "fluid"
+}
+export interface CustomDeFiDataOptions {
+    /** Defaults to every protocol. */
+    protocols?: PortfolioProtocol[];
+    fetchStaking?: boolean;
+    fetchRewards?: boolean;
+    /** Keep Aave V3 / Spark positions with no supply so the eMode category is available. */
+    returnEmptyEModePositions?: boolean;
+    fetchFluidMarkets?: boolean;
+    isSim?: boolean;
+    /** viem multicall calldata cap in bytes; defaults to 250k (2k when isSim). */
+    batchSize?: number;
+}
+export interface CustomDeFiData {
+    positions: PortfolioPositionsData;
+    stakingPositions: Record<string, any>;
+    rewardsData: Record<string, any>;
+    markets: PortfolioMarketsData;
+}
 export interface PortfolioMarketsData {
     morphoMarketsData: Record<string, MorphoBlueMarketInfo>;
     morphoMidnightMarketsData: Record<string, MorphoMidnightMarketInfo>;

package/esm/types/portfolio.js

@@ -1 +1,17 @@
-export {};
+export var PortfolioProtocol;
+(function (PortfolioProtocol) {
+    PortfolioProtocol["AaveV2"] = "aaveV2";
+    PortfolioProtocol["AaveV3"] = "aaveV3";
+    PortfolioProtocol["AaveV4"] = "aaveV4";
+    PortfolioProtocol["CompoundV2"] = "compoundV2";
+    PortfolioProtocol["CompoundV3"] = "compoundV3";
+    PortfolioProtocol["Spark"] = "spark";
+    PortfolioProtocol["MorphoBlue"] = "morphoBlue";
+    PortfolioProtocol["MorphoMidnight"] = "morphoMidnight";
+    PortfolioProtocol["CrvUsd"] = "crvUsd";
+    PortfolioProtocol["LlamaLend"] = "llamaLend";
+    PortfolioProtocol["Maker"] = "maker";
+    PortfolioProtocol["Liquity"] = "liquity";
+    PortfolioProtocol["LiquityV2"] = "liquityV2";
+    PortfolioProtocol["Fluid"] = "fluid";
+})(PortfolioProtocol || (PortfolioProtocol = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.168-stable-pair-dev",
+  "version": "2.1.169-custom-fetching-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -22,7 +22,7 @@
   "repository": "https://github.com/defisaver/defisaver-positions-sdk",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/tokens": "^1.7.45",
+    "@defisaver/tokens": "^1.7.50",
     "@types/lodash": "^4.17.15",
     "@types/memoizee": "^0.4.12",
     "decimal.js": "^10.6.0",

package/src/markets/morphoBlue/index.ts

@@ -1659,6 +1659,21 @@ export const MORPHO_BLUE_CBXRP_USDC_625_BASE = (networkId: NetworkNumber = Netwo
   marketId: '0xd4a903dc6d949519060c7707f9604fdc9772c046e05c2e3a8fce0bd7196e4109',
   protocolName: 'morpho-blue',
 });
+export const MORPHO_BLUE_CBHYPE_USDC_625_BASE = (networkId: NetworkNumber = NetworkNumber.Base): MorphoBlueMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Blue',
+  shortLabel: 'cbHYPE/USDC',
+  value: MorphoBlueVersions.MorphoBlueCbHYPEUSDC_625_Base,
+  url: 'cbhypeusdc-76629002',
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  collateralToken: '0xB200000000000000000000451d033a5000cb479e',
+  oracle: '0x7FaD8B8De2DDb7b4B415e1Aa3613e45EeF9E4bFf',
+  oracleType: MorphoBlueOracleType.MARKET_RATE,
+  irm: '0x46415998764C29aB2a25CbeA6254146D50D22687',
+  lltv: 0.625,
+  marketId: '0x76629002c9fdb20fb2092053a4f22c5c65e04a81887218b9546f2a2d82b4c0a8',
+  protocolName: 'morpho-blue',
+});
 
 // ARBITRUM
 export const MORPHO_BLUE_SYRUPUSDC_USDC_915_ARB = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
@@ -1935,6 +1950,7 @@ export const MorphoBlueMarkets = (networkId: NetworkNumber) => ({
   [MorphoBlueVersions.MorphoBlueUSDeUSDC_915_Base]: MORPHO_BLUE_USDE_USDC_915_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbEthUSDC_770_Base]: MORPHO_BLUE_CBETH_USDC_770_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbXRPUSDC_625_Base]: MORPHO_BLUE_CBXRP_USDC_625_BASE(networkId),
+  [MorphoBlueVersions.MorphoBlueCbHYPEUSDC_625_Base]: MORPHO_BLUE_CBHYPE_USDC_625_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueWsuperOETHbWETH_915_Base]: MORPHO_BLUE_WSUPEROETHB_WETH_915_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbEthEth_945_Base]: MORPHO_BLUE_CBETH_ETH_945_BASE(networkId),
   [MorphoBlueVersions.MorphoBlueCbEthEth_965_Base]: MORPHO_BLUE_CBETH_ETH_965_BASE(networkId),

package/src/portfolio/customDeFiData.ts

@@ -0,0 +1,378 @@
+import Dec from 'decimal.js';
+import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import {
+  AaveMarkets,
+  AaveV4Spokes,
+  CompoundMarkets,
+  CrvUsdMarkets,
+  LiquityV2Markets,
+  LlamaLendMarkets,
+  MakerActiveIlks,
+  MorphoBlueMarkets,
+  MorphoMidnightMarkets,
+  SparkMarkets,
+} from '../markets';
+import {
+  AaveVersions,
+  CdpInfo,
+  CompoundVersions,
+  CustomDeFiData,
+  CustomDeFiDataOptions,
+  PortfolioMarketsData,
+  PortfolioPositionsData,
+  PortfolioProtocol,
+} from '../types';
+import { getViemProvider } from '../services/viem';
+import { ZERO_ADDRESS } from '../constants';
+import { _getAaveV2AccountData, _getAaveV2MarketsData } from '../aaveV2';
+import { _getAaveV3AccountData, _getAaveV3MarketData, getStakeAaveData } from '../aaveV3';
+import { _getAaveV4AccountData, _getAaveV4SpokeData } from '../aaveV4';
+import { _getCompoundV2AccountData, _getCompoundV2MarketsData } from '../compoundV2';
+import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
+import { _getSparkAccountData, _getSparkMarketsData } from '../spark';
+import { _getCurveUsdGlobalData, _getCurveUsdUserData } from '../curveUsd';
+import { _getLlamaLendGlobalData, _getLlamaLendUserData } from '../llamaLend';
+import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData } from '../morphoMidnight';
+import { _getMakerCdpData, _getMakerIlksData, _getUserCdps } from '../maker';
+import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
+import { _getLiquityV2MarketData, getLiquitySAndYBold, getLiquityV2Staking } from '../liquityV2';
+import { _getAllFluidMarketDataPortfolio, _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
+import { getUmbrellaData } from '../umbrella';
+import { getMerklUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
+import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
+import { getKingRewards } from '../claiming/king';
+import { fetchEthenaAirdropRewards } from '../claiming/ethena';
+import { getUniswapRewards } from '../claiming/uniswap';
+
+const lower = (address: EthAddress) => address.toLowerCase() as EthAddress;
+const positive = (value: string | undefined) => new Dec(value || '0').gt(0);
+
+const supported = <T extends { chainIds: NetworkNumber[] }>(list: Record<string, T>, network: NetworkNumber) => (
+  Object.values(list).filter((m) => m.chainIds.includes(network))
+);
+
+export async function getCustomDeFiData(
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  defaultProvider: EthereumProvider,
+  addresses: EthAddress[],
+  options: CustomDeFiDataOptions = {},
+): Promise<CustomDeFiData> {
+  const {
+    protocols = Object.values(PortfolioProtocol),
+    fetchStaking = false,
+    fetchRewards = false,
+    returnEmptyEModePositions = false,
+    fetchFluidMarkets = false,
+    isSim = false,
+  } = options;
+  // JSON-RPC body ends up ~4x the calldata cap; 250k keeps it under the ~2.5MB provider limit.
+  const batchSize = options.batchSize ?? (isSim ? 2_000 : 250_000);
+  const has = (protocol: PortfolioProtocol) => protocols.includes(protocol);
+
+  const isMainnet = network === NetworkNumber.Eth;
+  const isFluidSupported = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base, NetworkNumber.Plasma].includes(network);
+
+  const client = getViemProvider(provider, network, { batch: { multicall: { batchSize } } });
+  const defaultClient = getViemProvider(defaultProvider, network, { batch: { multicall: { batchSize } } });
+
+  const aaveV3Markets = has(PortfolioProtocol.AaveV3)
+    ? [AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi].map((v) => AaveMarkets(network)[v]).filter((m) => m.chainIds.includes(network))
+    : [];
+  const aaveV2Markets = has(PortfolioProtocol.AaveV2) ? [AaveMarkets(network)[AaveVersions.AaveV2]].filter((m) => m.chainIds.includes(network)) : [];
+  const aaveV4Spokes = has(PortfolioProtocol.AaveV4) ? supported(AaveV4Spokes(network), network) : [];
+  const compoundV3Markets = has(PortfolioProtocol.CompoundV3) ? supported(CompoundMarkets(network), network).filter((m) => m.value !== CompoundVersions.CompoundV2) : [];
+  const compoundV2Markets = has(PortfolioProtocol.CompoundV2) ? [CompoundMarkets(network)[CompoundVersions.CompoundV2]].filter((m) => m.chainIds.includes(network)) : [];
+  const sparkMarkets = has(PortfolioProtocol.Spark) ? supported(SparkMarkets(network), network) : [];
+  const morphoMarkets = has(PortfolioProtocol.MorphoBlue) ? supported(MorphoBlueMarkets(network), network) : [];
+  const morphoMidnightMarkets = has(PortfolioProtocol.MorphoMidnight) ? supported(MorphoMidnightMarkets(network), network) : [];
+  const crvUsdMarkets = has(PortfolioProtocol.CrvUsd) ? supported(CrvUsdMarkets(network), network) : [];
+  const llamaLendMarkets = has(PortfolioProtocol.LlamaLend) && [NetworkNumber.Eth, NetworkNumber.Arb].includes(network) ? supported(LlamaLendMarkets(network), network) : [];
+  const liquityV2Markets = has(PortfolioProtocol.LiquityV2) && isMainnet ? Object.values(LiquityV2Markets(network)) : [];
+  const liquityV2StakingMarkets = liquityV2Markets.filter((m) => !m.isLegacy);
+  const fetchMaker = has(PortfolioProtocol.Maker) && isMainnet;
+  const fetchLiquity = has(PortfolioProtocol.Liquity) && isMainnet;
+  const fetchFluid = has(PortfolioProtocol.Fluid) && isFluidSupported;
+
+  const markets: PortfolioMarketsData = {
+    morphoMarketsData: {},
+    morphoMidnightMarketsData: {},
+    compoundV3MarketsData: {},
+    sparkMarketsData: {},
+    aaveV3MarketsData: {},
+    aaveV2MarketsData: {},
+    compoundV2MarketsData: {},
+    crvUsdMarketsData: {},
+    llamaLendMarketsData: {},
+    liquityV2MarketsData: {},
+    aaveV4SpokesData: {},
+    fluidMarketsData: {},
+    makerMarketsData: {},
+  };
+  const makerCdps: Record<string, CdpInfo[]> = {};
+  const positions: PortfolioPositionsData = {};
+  const stakingPositions: Record<string, any> = {};
+  const rewardsData: Record<string, any> = {};
+
+  for (const address of addresses) {
+    positions[lower(address)] = {
+      aaveV3: {},
+      aaveV4: {},
+      morphoBlue: {},
+      morphoMidnight: {},
+      compoundV3: {},
+      spark: {},
+      maker: {},
+      aaveV2: {},
+      compoundV2: {},
+      liquity: {},
+      crvUsd: {},
+      llamaLend: {},
+      fluid: { error: '', data: {} },
+    };
+    if (fetchStaking) {
+      stakingPositions[lower(address)] = {
+        aaveV3: {}, morphoBlue: {}, liquity: {}, liquityV2: {}, fluid: { error: '', data: {} },
+      };
+    }
+    if (fetchRewards) {
+      rewardsData[lower(address)] = {
+        merkl: {}, aaveV3: {}, spark: {}, spk: {}, king: {}, ethena: {}, uniswap: {},
+      };
+    }
+  }
+
+  const run = async <T>(label: string, fetch: () => Promise<T>, store: (data: T) => void, onError: (err: { error: string, data: null }) => void) => {
+    try {
+      store(await fetch());
+    } catch (error) {
+      console.error(`Error fetching ${label}:`, error);
+      onError({ error: `Error fetching ${label}`, data: null });
+    }
+  };
+
+  const perAddress = <M>(list: M[], task: (market: M, address: EthAddress) => Promise<void>) => list.map((m) => addresses.map((a) => task(m, a))).flat();
+
+  const batchRewards = (key: string, label: string, fetch: () => Promise<Record<string, any>>, enabled = true) => (async () => {
+    if (!enabled) {
+      for (const address of addresses) rewardsData[lower(address)][key] = { error: '', data: [] };
+      return;
+    }
+    try {
+      const result = await fetch();
+      for (const address of addresses) rewardsData[lower(address)][key] = { error: '', data: result[lower(address)] || [] };
+    } catch (error) {
+      console.error(`Error fetching ${label}:`, error);
+      for (const address of addresses) rewardsData[lower(address)][key] = { error: `Error fetching ${label}`, data: null };
+    }
+  })();
+
+  await Promise.allSettled([
+    ...morphoMarkets.map(async (m) => { markets.morphoMarketsData[m.value] = await _getMorphoBluePortfolioMarketData(client, network, m); }),
+    ...morphoMidnightMarkets.map(async (m) => { markets.morphoMidnightMarketsData[m.value] = await _getMorphoMidnightMarketData(client, network, m); }),
+    ...compoundV3Markets.map(async (m) => { markets.compoundV3MarketsData[m.value] = await _getCompoundV3MarketsData(client, network, m, defaultClient); }),
+    ...sparkMarkets.map(async (m) => { markets.sparkMarketsData[m.value] = await _getSparkMarketsData(client, network, m); }),
+    ...aaveV3Markets.map(async (m) => { markets.aaveV3MarketsData[m.value] = await _getAaveV3MarketData(client, network, m); }),
+    ...aaveV4Spokes.map(async (s) => { markets.aaveV4SpokesData[s.value] = await _getAaveV4SpokeData(client, network, s); }),
+    ...aaveV2Markets.map(async (m) => { markets.aaveV2MarketsData[m.value] = await _getAaveV2MarketsData(client, network, m); }),
+    ...compoundV2Markets.map(async (m) => { markets.compoundV2MarketsData[m.value] = await _getCompoundV2MarketsData(client, network); }),
+    ...crvUsdMarkets.map(async (m) => { markets.crvUsdMarketsData[m.value] = await _getCurveUsdGlobalData(client, network, m); }),
+    ...llamaLendMarkets.map(async (m) => { markets.llamaLendMarketsData[m.value] = await _getLlamaLendGlobalData(client, network, m); }),
+    ...liquityV2Markets.map(async (m) => { markets.liquityV2MarketsData[m.value] = await _getLiquityV2MarketData(client, network, m); }),
+    (async () => {
+      if (!fetchFluid || !fetchFluidMarkets) return;
+      try { markets.fluidMarketsData = await _getAllFluidMarketDataPortfolio(client, network); } catch (error) { console.error('Error fetching Fluid markets data:', error); }
+    })(),
+    (async () => {
+      if (!fetchMaker) return;
+      try { markets.makerMarketsData = await _getMakerIlksData(client, network, MakerActiveIlks); } catch (error) { console.error('Error fetching Maker ilks data:', error); }
+    })(),
+
+    ...addresses.map(async (address) => {
+      if (!fetchMaker) return;
+      makerCdps[lower(address)] = await _getUserCdps(client, network, address);
+    }),
+    ...addresses.map((address) => fetchFluid && run(
+      `Fluid positions for address ${address}`,
+      () => _getUserPositionsPortfolio(client, network, address),
+      (userPositions) => {
+        for (const position of userPositions) {
+          if (position.userData && positive(position.userData.suppliedUsd)) positions[lower(address)].fluid.data[position.userData.nftId] = position.userData;
+        }
+      },
+      (err) => { positions[lower(address)].fluid = { error: err.error, data: {} }; },
+    )),
+
+    ...(fetchStaking ? [
+      ...addresses.map((address) => fetchFluid && run(
+        `Fluid lend data for address ${address}`,
+        () => _getAllUserEarnPositionsWithFTokens(client, network, address),
+        (data) => { stakingPositions[lower(address)].fluid = data; },
+        (err) => { stakingPositions[lower(address)].fluid = err; },
+      )),
+      ...addresses.map((address) => fetchLiquity && run(
+        `Liquity staking data for address ${address}`,
+        () => getLiquityStakingData(client, network, address),
+        (data) => { stakingPositions[lower(address)].liquity = data; },
+        (err) => { stakingPositions[lower(address)].liquity = err; },
+      )),
+      ...addresses.map((address) => has(PortfolioProtocol.AaveV3) && isMainnet && run(
+        `Aave V3 staking data for address ${address}`,
+        () => getStakeAaveData(client, network, address),
+        (data) => { stakingPositions[lower(address)].aaveV3 = data; },
+        (err) => { stakingPositions[lower(address)].aaveV3 = err; },
+      )),
+      ...addresses.map((address) => has(PortfolioProtocol.AaveV3) && isMainnet && run(
+        `Umbrella staking data for address ${address}`,
+        () => getUmbrellaData(client, network, address),
+        (data) => { stakingPositions[lower(address)].umbrella = data; },
+        (err) => { stakingPositions[lower(address)].umbrella = err; },
+      )),
+      ...perAddress(liquityV2StakingMarkets, (market, address) => run(
+        `Liquity V2 staking data for address ${address}, market ${market.value}`,
+        () => getLiquityV2Staking(client, network, market.value, address),
+        (data) => { stakingPositions[lower(address)].liquityV2[market.value] = { error: '', data }; },
+        (err) => { stakingPositions[lower(address)].liquityV2[market.value] = err; },
+      )),
+    ] : []),
+
+    ...(fetchRewards ? [
+      batchRewards('king', 'King rewards data', () => getKingRewards(client, network, addresses), isMainnet),
+      batchRewards('uniswap', 'Uniswap rewards data', () => getUniswapRewards(client, network, addresses), isMainnet),
+      batchRewards('spk', 'Spark Airdrop rewards data', () => fetchSparkAirdropRewards(client, network, addresses), isMainnet && has(PortfolioProtocol.Spark)),
+      batchRewards('ethena', 'Ethena Airdrop rewards data', () => fetchEthenaAirdropRewards(addresses), isMainnet),
+      ...addresses.map((address) => run(
+        `Merkl rewards data for address ${address}`,
+        () => getMerklUnclaimedRewards(address, network),
+        (data) => { rewardsData[lower(address)].merkl = { error: '', data }; },
+        (err) => { rewardsData[lower(address)].merkl = err; },
+      )),
+      ...perAddress(aaveV3Markets, (market, address) => run(
+        `Aave V3 rewards data for address ${address}, market ${market.value}`,
+        () => getUnclaimedRewardsForAllMarkets(client, network, address, market.providerAddress),
+        (data) => { rewardsData[lower(address)].aaveV3[market.value] = { error: '', data }; },
+        (err) => { rewardsData[lower(address)].aaveV3[market.value] = err; },
+      )),
+      ...perAddress(sparkMarkets, (market, address) => {
+        if (!isMainnet) {
+          rewardsData[lower(address)].spark[market.value] = { error: '', data: [] };
+          return Promise.resolve();
+        }
+        return run(
+          `Spark rewards data for address ${address}, market ${market.value}`,
+          () => fetchSparkRewards(client, network, address, market.providerAddress),
+          (data) => { rewardsData[lower(address)].spark[market.value] = { error: '', data }; },
+          (err) => { rewardsData[lower(address)].spark[market.value] = err; },
+        );
+      }),
+    ] : []),
+  ]);
+
+  await Promise.all([
+    ...perAddress(aaveV3Markets, (market, address) => run(
+      `AaveV3 account data for address ${address} on market ${market.value}`,
+      () => _getAaveV3AccountData(client, network, address, { selectedMarket: market, ...markets.aaveV3MarketsData[market.value] }),
+      (data) => { if (returnEmptyEModePositions || positive(data.suppliedUsd)) positions[lower(address)].aaveV3[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].aaveV3[market.value] = err; },
+    )),
+    ...perAddress(sparkMarkets, (market, address) => run(
+      `Spark account data for address ${address} on market ${market.value}`,
+      () => _getSparkAccountData(client, network, address, { selectedMarket: market, assetsData: markets.sparkMarketsData[market.value].assetsData, eModeCategoriesData: markets.sparkMarketsData[market.value].eModeCategoriesData }),
+      (data) => { if (returnEmptyEModePositions || positive(data.suppliedUsd)) positions[lower(address)].spark[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].spark[market.value] = err; },
+    )),
+    ...perAddress(aaveV4Spokes, (spoke, address) => run(
+      `AaveV4 account data for address ${address} on spoke ${spoke.value}`,
+      () => _getAaveV4AccountData(client, network, markets.aaveV4SpokesData[spoke.value], address),
+      (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].aaveV4[spoke.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].aaveV4[spoke.value] = err; },
+    )),
+    ...perAddress(morphoMarkets, (market, address) => run(
+      `MorphoBlue account data for address ${address} on market ${market.value}`,
+      () => _getMorphoBlueAccountData(client, network, address, market, markets.morphoMarketsData[market.value]),
+      (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].morphoBlue[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].morphoBlue[market.value] = err; },
+    )),
+    ...(fetchStaking ? perAddress(morphoMarkets, (market, address) => run(
+      `MorphoBlue earn data for address ${address} on market ${market.value}`,
+      () => getMorphoEarn(client, network, address, market, markets.morphoMarketsData[market.value]),
+      (data) => { if (data && positive(data.amount)) stakingPositions[lower(address)].morphoBlue[market.value] = { error: '', data }; },
+      (err) => { stakingPositions[lower(address)].morphoBlue[market.value] = err; },
+    )) : []),
+    ...perAddress(morphoMidnightMarkets, (market, address) => {
+      if (!markets.morphoMidnightMarketsData[market.value]?.isCreated) return Promise.resolve();
+      return run(
+        `MorphoMidnight account data for address ${address} on market ${market.value}`,
+        () => _getMorphoMidnightAccountData(client, network, address, market, markets.morphoMidnightMarketsData[market.value]),
+        (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].morphoMidnight[market.value] = { error: '', data }; },
+        (err) => { positions[lower(address)].morphoMidnight[market.value] = err; },
+      );
+    }),
+    ...perAddress(compoundV3Markets, (market, address) => run(
+      `CompoundV3 account data for address ${address} on market ${market.value}`,
+      () => _getCompoundV3AccountData(client, network, address, ZERO_ADDRESS, { selectedMarket: market, assetsData: markets.compoundV3MarketsData[market.value].assetsData }),
+      (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].compoundV3[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].compoundV3[market.value] = err; },
+    )),
+    ...perAddress(compoundV2Markets, (market, address) => run(
+      `CompoundV2 account data for address ${address}`,
+      () => _getCompoundV2AccountData(client, network, address, markets.compoundV2MarketsData[market.value].assetsData),
+      (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].compoundV2[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].compoundV2[market.value] = err; },
+    )),
+    ...perAddress(aaveV2Markets, (market, address) => run(
+      `AaveV2 account data for address ${address}`,
+      () => _getAaveV2AccountData(client, network, address, markets.aaveV2MarketsData[market.value].assetsData, market),
+      (data) => { if (positive(data.suppliedUsd)) positions[lower(address)].aaveV2[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].aaveV2[market.value] = err; },
+    )),
+    ...perAddress(crvUsdMarkets, (market, address) => run(
+      `Curve USD account data for address ${address} on market ${market.value}`,
+      () => _getCurveUsdUserData(client, network, address, market, markets.crvUsdMarketsData[market.value].activeBand, markets.crvUsdMarketsData[market.value].borrowRate),
+      (data) => { if (positive(data.suppliedUsd) || positive(data.borrowedUsd)) positions[lower(address)].crvUsd[market.value] = { error: '', data }; },
+      (err) => { positions[lower(address)].crvUsd[market.value] = err; },
+    )),
+    ...perAddress(llamaLendMarkets, (market, address) => run(
+      `LlamaLend account data for address ${address} on market ${market.value}`,
+      () => _getLlamaLendUserData(client, network, address, market, markets.llamaLendMarketsData[market.value]),
+      (data) => {
+        if (positive(data.suppliedUsd) || positive(data.borrowedUsd)) {
+          positions[lower(address)].llamaLend[market.value] = { error: '', data: { ...data, borrowRate: markets.llamaLendMarketsData[market.value].borrowRate } };
+        }
+      },
+      (err) => { positions[lower(address)].llamaLend[market.value] = err; },
+    )),
+    ...addresses.map((address) => (makerCdps[lower(address)] || []).map((cdpInfo) => run(
+      `Maker CDP data for address ${address} with ID ${cdpInfo.id}`,
+      () => _getMakerCdpData(client, network, cdpInfo, markets.makerMarketsData[cdpInfo.ilkLabel]),
+      (data) => { if (data) positions[lower(address)].maker[cdpInfo.id] = { error: '', data }; },
+      (err) => { positions[lower(address)].maker[cdpInfo.id] = err; },
+    ))).flat(),
+    ...addresses.map((address) => fetchLiquity && run(
+      `Liquity trove info for address ${address}`,
+      () => _getLiquityTroveInfo(client, network, address),
+      (data) => { if (positive(data.collateral)) positions[lower(address)].liquity = { error: '', data }; },
+      (err) => { positions[lower(address)].liquity = err; },
+    )),
+    ...(fetchStaking && has(PortfolioProtocol.LiquityV2) ? addresses.map((address) => {
+      if (!isMainnet) {
+        stakingPositions[lower(address)].liquityV2SBoldYBold = { error: '', data: null };
+        return Promise.resolve();
+      }
+      return run(
+        `sBold/yBold data for address ${address}`,
+        () => getLiquitySAndYBold(client, network, stakingPositions[lower(address)].liquityV2, address),
+        (data) => { stakingPositions[lower(address)].liquityV2SBoldYBold = { error: '', data }; },
+        (err) => { stakingPositions[lower(address)].liquityV2SBoldYBold = err; },
+      );
+    }) : []),
+  ]);
+
+  return {
+    positions,
+    stakingPositions,
+    rewardsData,
+    markets,
+  };
+}