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

package/cjs/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/cjs/types/morphoBlue.js

@@ -120,6 +120,7 @@ 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/cjs/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/cjs/types/portfolio.js

@@ -1,2 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortfolioProtocol = void 0;
+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 || (exports.PortfolioProtocol = PortfolioProtocol = {}));

package/esm/markets/morphoBlue/index.d.ts

@@ -109,6 +109,7 @@ export declare const MORPHO_BLUE_AERO_USDC_625_BASE: (networkId?: NetworkNumber)
 export declare const MORPHO_BLUE_USDE_USDC_915_BASE: (networkId?: NetworkNumber) => MorphoBlueMarketData;
 export declare const MORPHO_BLUE_CBETH_USDC_770_BASE: (networkId?: NetworkNumber) => MorphoBlueMarketData;
 export declare const MORPHO_BLUE_CBXRP_USDC_625_BASE: (networkId?: NetworkNumber) => MorphoBlueMarketData;
+export declare const MORPHO_BLUE_CBHYPE_USDC_625_BASE: (networkId?: NetworkNumber) => MorphoBlueMarketData;
 export declare const MORPHO_BLUE_SYRUPUSDC_USDC_915_ARB: (networkId?: NetworkNumber) => MorphoBlueMarketData;
 export declare const MorphoBlueWBTCUSDC_860_Arb: (networkId?: NetworkNumber) => MorphoBlueMarketData;
 export declare const MORPHO_BLUE_WSTETH_USDC_860_ARB: (networkId?: NetworkNumber) => MorphoBlueMarketData;
@@ -226,6 +227,7 @@ export declare const MorphoBlueMarkets: (networkId: NetworkNumber) => {
     readonly morphoblueusdeusdc_915_base: MorphoBlueMarketData;
     readonly morphobluecbethusdc_770_base: MorphoBlueMarketData;
     readonly morphobluecbxrpusdc_625_base: MorphoBlueMarketData;
+    readonly morphobluecbhypeusdc_625_base: MorphoBlueMarketData;
     readonly morphobluewsuperoethbweth_915_base: MorphoBlueMarketData;
     readonly morphobluecbetheth_945_base: MorphoBlueMarketData;
     readonly morphobluecbetheth_965_base: MorphoBlueMarketData;

package/esm/markets/morphoBlue/index.js

@@ -1652,6 +1652,21 @@ export const MORPHO_BLUE_CBXRP_USDC_625_BASE = (networkId = NetworkNumber.Base)
     marketId: '0xd4a903dc6d949519060c7707f9604fdc9772c046e05c2e3a8fce0bd7196e4109',
     protocolName: 'morpho-blue',
 });
+export const MORPHO_BLUE_CBHYPE_USDC_625_BASE = (networkId = NetworkNumber.Base) => ({
+    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.Eth) => ({
     chainIds: [NetworkNumber.Arb],
@@ -1926,6 +1941,7 @@ export const MorphoBlueMarkets = (networkId) => ({
     [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/esm/portfolio/customDeFiData.d.ts

@@ -0,0 +1,3 @@
+import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import { CustomDeFiData, CustomDeFiDataOptions } from '../types';
+export declare function getCustomDeFiData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], options?: CustomDeFiDataOptions): Promise<CustomDeFiData>;

package/esm/portfolio/customDeFiData.js

@@ -0,0 +1,256 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { NetworkNumber } from '../types/common';
+import { AaveMarkets, AaveV4Spokes, CompoundMarkets, CrvUsdMarkets, LiquityV2Markets, LlamaLendMarkets, MakerActiveIlks, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets, } from '../markets';
+import { AaveVersions, CompoundVersions, 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) => address.toLowerCase();
+const positive = (value) => new Dec(value || '0').gt(0);
+const supported = (list, network) => (Object.values(list).filter((m) => m.chainIds.includes(network)));
+export function getCustomDeFiData(provider_1, network_1, defaultProvider_1, addresses_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, defaultProvider, addresses, options = {}) {
+        var _a;
+        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 = (_a = options.batchSize) !== null && _a !== void 0 ? _a : (isSim ? 2000 : 250000);
+        const has = (protocol) => 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 = {
+            morphoMarketsData: {},
+            morphoMidnightMarketsData: {},
+            compoundV3MarketsData: {},
+            sparkMarketsData: {},
+            aaveV3MarketsData: {},
+            aaveV2MarketsData: {},
+            compoundV2MarketsData: {},
+            crvUsdMarketsData: {},
+            llamaLendMarketsData: {},
+            liquityV2MarketsData: {},
+            aaveV4SpokesData: {},
+            fluidMarketsData: {},
+            makerMarketsData: {},
+        };
+        const makerCdps = {};
+        const positions = {};
+        const stakingPositions = {};
+        const rewardsData = {};
+        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 = (label, fetch, store, onError) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                store(yield fetch());
+            }
+            catch (error) {
+                console.error(`Error fetching ${label}:`, error);
+                onError({ error: `Error fetching ${label}`, data: null });
+            }
+        });
+        const perAddress = (list, task) => list.map((m) => addresses.map((a) => task(m, a))).flat();
+        const batchRewards = (key, label, fetch, enabled = true) => (() => __awaiter(this, void 0, void 0, function* () {
+            if (!enabled) {
+                for (const address of addresses)
+                    rewardsData[lower(address)][key] = { error: '', data: [] };
+                return;
+            }
+            try {
+                const result = yield 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 };
+            }
+        }))();
+        yield Promise.allSettled([
+            ...morphoMarkets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.morphoMarketsData[m.value] = yield _getMorphoBluePortfolioMarketData(client, network, m); })),
+            ...morphoMidnightMarkets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.morphoMidnightMarketsData[m.value] = yield _getMorphoMidnightMarketData(client, network, m); })),
+            ...compoundV3Markets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.compoundV3MarketsData[m.value] = yield _getCompoundV3MarketsData(client, network, m, defaultClient); })),
+            ...sparkMarkets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.sparkMarketsData[m.value] = yield _getSparkMarketsData(client, network, m); })),
+            ...aaveV3Markets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.aaveV3MarketsData[m.value] = yield _getAaveV3MarketData(client, network, m); })),
+            ...aaveV4Spokes.map((s) => __awaiter(this, void 0, void 0, function* () { markets.aaveV4SpokesData[s.value] = yield _getAaveV4SpokeData(client, network, s); })),
+            ...aaveV2Markets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.aaveV2MarketsData[m.value] = yield _getAaveV2MarketsData(client, network, m); })),
+            ...compoundV2Markets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.compoundV2MarketsData[m.value] = yield _getCompoundV2MarketsData(client, network); })),
+            ...crvUsdMarkets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.crvUsdMarketsData[m.value] = yield _getCurveUsdGlobalData(client, network, m); })),
+            ...llamaLendMarkets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.llamaLendMarketsData[m.value] = yield _getLlamaLendGlobalData(client, network, m); })),
+            ...liquityV2Markets.map((m) => __awaiter(this, void 0, void 0, function* () { markets.liquityV2MarketsData[m.value] = yield _getLiquityV2MarketData(client, network, m); })),
+            (() => __awaiter(this, void 0, void 0, function* () {
+                if (!fetchFluid || !fetchFluidMarkets)
+                    return;
+                try {
+                    markets.fluidMarketsData = yield _getAllFluidMarketDataPortfolio(client, network);
+                }
+                catch (error) {
+                    console.error('Error fetching Fluid markets data:', error);
+                }
+            }))(),
+            (() => __awaiter(this, void 0, void 0, function* () {
+                if (!fetchMaker)
+                    return;
+                try {
+                    markets.makerMarketsData = yield _getMakerIlksData(client, network, MakerActiveIlks);
+                }
+                catch (error) {
+                    console.error('Error fetching Maker ilks data:', error);
+                }
+            }))(),
+            ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                if (!fetchMaker)
+                    return;
+                makerCdps[lower(address)] = yield _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; });
+                }),
+            ] : []),
+        ]);
+        yield Promise.all([
+            ...perAddress(aaveV3Markets, (market, address) => run(`AaveV3 account data for address ${address} on market ${market.value}`, () => _getAaveV3AccountData(client, network, address, Object.assign({ 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) => {
+                var _a;
+                if (!((_a = markets.morphoMidnightMarketsData[market.value]) === null || _a === void 0 ? void 0 : _a.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: Object.assign(Object.assign({}, 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,
+        };
+    });
+}

package/esm/portfolio/index.d.ts

@@ -11,4 +11,5 @@ export declare function getShifterPortfolioData(provider: EthereumProvider, netw
     markets: PortfolioMarketsData;
 }>;
 export * from './discovery';
+export * from './customDeFiData';
 export { getWalletLendingSummaries } from './lendingSummaries';