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

package/src/portfolio/customDeFiData.ts

@@ -0,0 +1,379 @@
+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, pinProviderBlock } 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 pin = (p: EthereumProvider) => (options.blockNumber !== undefined ? pinProviderBlock(p, options.blockNumber) : p);
+  const client = getViemProvider(pin(provider), network, { batch: { multicall: { batchSize } } });
+  const defaultClient = getViemProvider(pin(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,
+  };
+}